Add a function to pub for finding the canonical path of a file.

sdk/lib/_internal/pub/lib/src/io.dart

Index: sdk/lib/_internal/pub/lib/src/io.dart
diff --git a/sdk/lib/_internal/pub/lib/src/io.dart b/sdk/lib/_internal/pub/lib/src/io.dart
index 1620837c2b2f3362997abbf78ac581a52b543dab..c5adb8dd7afe6c6302fbf13864aafbea55e34a9d 100644
--- a/sdk/lib/_internal/pub/lib/src/io.dart
+++ b/sdk/lib/_internal/pub/lib/src/io.dart
@@ -40,6 +40,36 @@ bool linkExists(String link) => new Link(link).existsSync();
 /// for a symlink only if that symlink is unbroken and points to a file.
 bool fileExists(String file) => new File(file).existsSync();
 
+/// Returns the canonical path for [pathString]. This is the normalized,
+/// absolute path, with symlinks resolved. As in [transitiveTarget], broken or
+/// recursive symlinks will not be fully resolved.
+///
+/// This doesn't require [pathString] to point to a path that exists on the
+/// filesystem; nonexistent or unreadable path entries are treated as normal
+/// directories.
+String canonicalize(String pathString) {
+  var components = path.split(path.normalize(path.absolute(pathString)));
+  var newPath = components.removeAt(0);

[Bob Nystrom, 2013/05/07 17:36:14]

A comment explaining how this works would help. Something like:

Rebuild the path one component at a time, resolving through each directory that
happens to be a symlink.

[nweiz, 2013/05/07 20:40:15]

Done.

+  for (var component in components) {
+    newPath = transitiveTarget(path.join(newPath, component));
+  }
+  return newPath;
+}
+
+/// Returns the transitive target of [link]. If [link] is recursive, this

[Bob Nystrom, 2013/05/07 17:36:14]

"transitive target" doesn't mean anything to me, so this comment isn't helpful.
Maybe "resolveLink"?

"recursive" could also be defined more precisely. Does it mean a symlink that
points to one of its parent directories?

Better doc and maybe a few examples showing how different paths will be
processed.

[nweiz, 2013/05/07 20:40:15]

I think "transitive target" is pretty clear; symlinks have a target which may be
a symlink, and transitively following those targets gives you the transitive
target. I'll change the name if you want, but I think this is clearest.
Done.
Done.

[Bob Nystrom, 2013/05/07 20:43:07]

Maybe, but I think "resolved" is the more common term for a path that takes
symlinks into account. Also, this method is used for paths to things that are
not symlinks, so "target" isn't always meaningful.

+/// returns the path to the first repeated link.
+///
+/// This accepts paths to non-links or broken links, and returns them as-is.
+String transitiveTarget(String link) {
+  var seen = new Set<String>();
+  while (linkExists(link) && !seen.contains(link)) {
+    seen.add(link);
+    link = path.normalize(path.join(
+        path.dirname(link), new Link(link).targetSync()));
+  }
+  return link;
+}
+
 /// Reads the contents of the text file [file].
 String readTextFile(String file) =>
     new File(file).readAsStringSync(encoding: Encoding.UTF_8);
@@ -137,7 +167,7 @@ List<String> listDir(String dir, {bool recursive: false,
     var contents = <String>[];
 
     // Avoid recursive symlinks.
-    var resolvedPath = new File(dir).fullPathSync();
+    var resolvedPath = canonicalize(dir);
     if (listedDirectories.contains(resolvedPath)) return [];
 
     listedDirectories = new Set<String>.from(listedDirectories);