Add BazelPackageUriResolver with resolveAbsolute().

pkg/analyzer/lib/src/generated/bazel.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.src.generated.bazel;
 
+import 'dart:collection';
 import 'dart:core';
 
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:path/path.dart';
 
 /**
  * Instances of the class `BazelFileUriResolver` resolve `file` URI's by first
  * resolving file uri's in the expected way, and then by looking in the
@@ skipping 14 matching lines @@
     String path = provider.pathContext.fromUri(uri);
     File file = workspace.findFile(path);
     if (file != null) {
       return file.createSource(actualUri ?? uri);
     }
     return null;
   }
 }
 
 /**
+ * The [UriResolver] that can resolve `package` URIs in [BazelWorkspace].
+ */
+class BazelPackageUriResolver extends UriResolver {
+  final BazelWorkspace workspace;
+
+  /**
+   * The cache of absolute [Uri]s to [Source]s mappings.
+   */
+  final Map<Uri, Source> _sourceCache = new HashMap<Uri, Source>();
+
+  BazelPackageUriResolver(this.workspace);
+
+  @override
+  Source resolveAbsolute(Uri uri, [Uri actualUri]) {
+    return _sourceCache.putIfAbsent(uri, () {
+      _BazelPackageUri bazelUri = _BazelPackageUri.parse(uri);
+      if (bazelUri == null) {
+        return null;
+      }
+      if (bazelUri.package.indexOf('.') == -1) {
+        String path = '${workspace.root}/third_party/dart/'

[Paul Berry, 2016/10/07 15:30:57]

This won't work on Windows because it uses hardcoded '/'s.  Also because
bazelUri.path may contain '/'s.

[scheglov, 2016/10/07 16:02:43]

Thanks.
I tested it now manually with Windows style MemoryResourceProvider and fixed
these problems.

+            '${bazelUri.package}/lib/${bazelUri.path}';
+        File file = workspace.getFile(path);
+        return file?.createSource(uri);
+      } else {
+        String packagePath = bazelUri.package
+            .replaceAll('.', workspace.provider.pathContext.separator);
+        String path = '${workspace.root}/$packagePath/lib/${bazelUri.path}';

[Paul Berry, 2016/10/07 15:30:57]

Similar problem here.

[scheglov, 2016/10/07 16:02:43]

Acknowledged.

+        File file = workspace.findFile(path);
+        return file?.createSource(uri);
+      }
+    });
+  }
+}
+
+/**
  * Information about a Bazel workspace.
  */
 class BazelWorkspace {
   static const String _WORKSPACE = 'WORKSPACE';
   static const String _READONLY = 'READONLY';
 
   final ResourceProvider provider;
 
   /**
    * The absolute workspace root path.
@@ skipping 107 matching lines @@
         if (file.exists) {
           return file;
         }
       }
       // Not generated, return the default one.
       return provider.getFile(absolutePath);
     } catch (_) {
       return null;
     }
   }
+
+  /**
+   * Return the file with the given [absolutePath] in the workspace [root].
+   * The file is returned even if it does not exist. Return `null` if the given
+   * [absolutePath] is not in the workspace [root].

[Paul Berry, 2016/10/07 15:30:57]

Since the caller always provides a path within the workspace root, the
"isWithin" check seems wasteful.

How about if instead we say that the argument to getPath is relative to the
workspace root.  Then this function can just be:

return provider.getFile(provider.pathContext.join(root, path));

And "${workspace.root}/" can be dropped from the caller.

[scheglov, 2016/10/07 16:02:43]

Done.

+   */
+  File getFile(String absolutePath) {
+    if (provider.pathContext.isWithin(root, absolutePath)) {
+      return provider.getFile(absolutePath);
+    }
+    return null;
+  }
 }
+
+/**
+ * A `package` URI that has been parsed according to Bazel rules.
+ *
+ * For example, "package:dart.tools.analyzer/src/foo.dart" will be split
+ * into "dart.tools.analyzer" (the package) and "src/foo.dart" (the suffix).
+ */
+class _BazelPackageUri {
+  /**
+   * The name of the package being imported or exported.
+   *
+   * For example, if the URI is "package:foo.bar/baz.dart" then the package
+   * name is "foo.bar".
+   */
+  final String package;
+
+  /**
+   * The path from the `lib` folder for the package to the file.
+   *
+   * For example, if the URI is "package:foo/bar/baz.dart" then the path is
+   * "bar/baz.dart".
+   */
+  final String path;
+
+  _BazelPackageUri(this.package, this.path);
+
+  @override
+  String toString() => toUri().toString();
+
+  /**
+   * Return the reconstituted `package` URI.
+   */
+  Uri toUri() {
+    return new Uri(scheme: 'package', path: '$package/$path');
+  }
+
+  /**
+   * Parses a Dart `package` URI according to Bazel rules.
+   *
+   * Returns `null` if it's not a valid Bazel `package` URI.
+   */
+  static _BazelPackageUri parse(Uri uri) {
+    if (uri.scheme != 'package') {
+      return null;
+    }
+    String path = uri.path;
+    int slash = path.indexOf('/');
+
+    // If the path either starts with a slash or has no slash, it is invalid.
+    if (slash < 1) {
+      return null;
+    }
+
+    String packageName = path.substring(0, slash);
+    String suffix = path.substring(slash + 1);
+    return new _BazelPackageUri(packageName, suffix);
+  }
+}