Qualify library names in packages

test/codegen_test.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.
 
 /// Tests code generation.
 /// Runs Dart Dev Compiler on all input in the `codegen` directory and checks
 /// that the output is what we expected.
 library dev_compiler.test.codegen_test;
 
 import 'dart:convert' show JSON;
@@ skipping 53 matching lines @@
 
   var allDirs = [null];
   allDirs.addAll(testDirs);
   for (var dir in allDirs) {
     if (codeCoverage && dir != null) continue;
 
     group('dartdevc ' + path.join('test', 'codegen', dir), () {
       var outDir = new Directory(path.join(expectDir, dir));
       if (!outDir.existsSync()) outDir.createSync(recursive: true);
 
-      var testFiles = _findTests(path.join(inputDir, dir), filePattern);
+      var baseDir = path.join(inputDir, dir);
+      var testFiles = _findTests(baseDir, filePattern);
       for (var filePath in testFiles) {
         if (multitests.contains(filePath)) continue;
 
         var filename = path.basenameWithoutExtension(filePath);
 
         test('$filename.dart', () {
           // Check if we need to use special compile options.
           var contents = new File(filePath).readAsStringSync();
           var match =
               new RegExp(r'// compile options: (.*)').matchAsPrefix(contents);
 
           var args = new List.from(defaultOptions);
           if (match != null) {
             args.addAll(match.group(1).split(' '));
           }
           var options =
               new CompilerOptions.fromArguments(compilerArgParser.parse(args));
 
           // Collect any other files we've imported.
           var files = new Set<String>();
           _collectTransitiveImports(contents, files, from: filePath);
 
-          var unit = new BuildUnit(filename, files.toList(), _moduleForLibrary);
+          var unit = new BuildUnit(
+              filename, baseDir, files.toList(), _moduleForLibrary);
           var module = compiler.compile(unit, options);
           _writeModule(path.join(outDir.path, filename), module);
         });
       }
     });
   }
 
   if (codeCoverage) {
     test('build_sdk code coverage', () {
       var generatedSdkDir =
@@ skipping 13 matching lines @@
     new File(outPath + '.js').writeAsStringSync(result.code);
     if (result.sourceMap != null) {
       var mapPath = outPath + '.js.map';
       new File(mapPath)
           .writeAsStringSync(JSON.encode(result.placeSourceMap(mapPath)));
     }
   }
 }
 
 void _buildSunflower(ModuleCompiler compiler, String expectDir) {
+  var baseDir = path.join(inputDir, 'sunflower');
   var files = ['sunflower', 'circle', 'painter']
-      .map((f) => path.join(inputDir, 'sunflower', '$f.dart'))
+      .map((f) => path.join(baseDir, '$f.dart'))
       .toList();
-  var input = new BuildUnit('sunflower', files, _moduleForLibrary);
+  var input = new BuildUnit('sunflower', baseDir, files, _moduleForLibrary);
   var options = new CompilerOptions(summarizeApi: false);
 
   var built = compiler.compile(input, options);
   _writeModule(path.join(expectDir, 'sunflower', 'sunflower'), built);
 }
 
 void _buildPackages(ModuleCompiler compiler, String expectDir) {
   // Note: we don't summarize these, as we're going to rely on our in-memory
   // shared analysis context for caching, and `_moduleForLibrary` below
   // understands these are from other modules.
   var options = new CompilerOptions(sourceMap: false, summarizeApi: false);
 
   for (var uri in packageUrlMappings.keys) {
     assert(uri.startsWith('package:'));
     var uriPath = uri.substring('package:'.length);
     var name = path.basenameWithoutExtension(uriPath);
     test(name, () {
-      var input = new BuildUnit(name, [uri], _moduleForLibrary);
+      var input = new BuildUnit(name, inputDir, [uri], _moduleForLibrary);
       var built = compiler.compile(input, options);
 
       var outPath = path.join(expectDir, path.withoutExtension(uriPath));
       _writeModule(outPath, built);
     });
   }
 }
 
 void _buildMatcher(ModuleCompiler compiler, String expectDir) {
   var options = new CompilerOptions(sourceMap: false, summarizeApi: false);
 
-  var filePath = path.join(inputDir, 'packages', 'matcher', 'matcher.dart');
+  var packageRoot = path.join(inputDir, 'packages');
+  var filePath = path.join(packageRoot, 'matcher', 'matcher.dart');
   var contents = new File(filePath).readAsStringSync();
 
   // Collect any other files we've imported.
   var files = new Set<String>();
-  _collectTransitiveImports(contents, files, from: filePath);
+  _collectTransitiveImports(contents, files,
+      packageRoot: packageRoot, from: filePath);
 
-  var unit = new BuildUnit('matcher', files.toList(), _moduleForLibrary);
+  var unit =
+      new BuildUnit('matcher', inputDir, files.toList(), _moduleForLibrary);
   var module = compiler.compile(unit, options);
 
   var outPath = path.join(expectDir, 'matcher', 'matcher');
   _writeModule(outPath, module);
 }
 
 String _moduleForLibrary(Source source) {
   var scheme = source.uri.scheme;
   if (scheme == 'package') {
     return source.uri.pathSegments.first;
@@ skipping 58 matching lines @@
         .where((p) => p.endsWith('_test.dart') || p.endsWith('_multi.dart'));
   }
   return files;
 }
 
 /// Parse directives from [contents] and find the complete set of transitive
 /// imports, reading files as needed.
 ///
 /// This will not include dart:* libraries, as those are implicitly available.
 void _collectTransitiveImports(String contents, Set<String> libraries,
-    {String from}) {
-  if (!libraries.add(from)) return;
+    {String packageRoot, String from}) {
+  var uri = from;
+  if (packageRoot != null && path.isWithin(packageRoot, from)) {
+    uri = 'package:${path.relative(from, from: packageRoot)}';
+  }
+  if (!libraries.add(uri)) return;
 
   var unit = parseDirectives(contents, name: from, suppressErrors: true);
   for (var d in unit.directives) {
     if (d is ImportDirective || d is ExportDirective) {
       String uri = _resolveDirective(d);
       if (uri == null ||
           uri.startsWith('dart:') ||
           uri.startsWith('package:')) {
         continue;
       }
 
       var f = new File(path.join(path.dirname(from), uri));
       if (f.existsSync()) {
         _collectTransitiveImports(f.readAsStringSync(), libraries,
-            from: f.path);
+            packageRoot: packageRoot, from: f.path);
       }
     }
   }
 }
 
 /// Simplified from ParseDartTask.resolveDirective.
 String _resolveDirective(UriBasedDirective directive) {
   StringLiteral uriLiteral = directive.uri;
   String uriContent = uriLiteral.stringValue;
   if (uriContent != null) {
     uriContent = uriContent.trim();
     directive.uriContent = uriContent;
   }
   return directive.validate() == null ? uriContent : null;
 }