Use .packages instead of pubspec.yaml

pkg/dev_compiler/lib/src/analyzer/context.dart

 // Copyright (c) 2015, 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.
 
 import 'package:args/args.dart' show ArgParser, ArgResults;
 import 'package:analyzer/file_system/file_system.dart'
     show ResourceProvider, ResourceUriResolver;
 import 'package:analyzer/file_system/physical_file_system.dart'
     show PhysicalResourceProvider;
 import 'package:analyzer/source/custom_resolver.dart';
@@ skipping 33 matching lines @@
 
   /// Path to the dart-sdk summary.  If this is set, it will be used in favor
   /// of the unsummarized one.
   final String dartSdkSummaryPath;
 
   AnalyzerOptions(
       {this.summaryPaths: const [],
       String dartSdkPath,
       this.dartSdkSummaryPath,
       this.customUrlMappings: const {},
-      this.packageRoot: 'packages/',
+      this.packageRoot: null,

[Bob Nystrom, 2016/09/28 16:02:47]

You should be able to just omit this argument, right? Or does AnalyzerOptions
have a different default value than null for packageRoot?

[vsm, 2016/09/28 16:10:03]

Good point.  Looking into whether I can just remove the option altogether.  Not
sure if it's used anywhere.

       this.packagePaths: const []})
       : dartSdkPath = dartSdkPath ?? getSdkDir().path;
 
   AnalyzerOptions.fromArguments(ArgResults args)
       : summaryPaths = args['summary'] as List<String>,
         dartSdkPath = args['dart-sdk'] ?? getSdkDir().path,
         dartSdkSummaryPath = args['dart-sdk-summary'],
         customUrlMappings = _parseUrlMappings(args['url-mapping']),
         packageRoot = args['package-root'],
         packagePaths = (args['package-paths'] as String)?.split(',') ?? [];
 
   /// Whether to resolve 'package:' uris using the multi-package resolver.
   bool get useMultiPackage => packagePaths.isNotEmpty;
 
   static void addArguments(ArgParser parser) {
     parser
       ..addOption('summary',
           abbr: 's', help: 'summary file(s) to include', allowMultiple: true)
       ..addOption('dart-sdk', help: 'Dart SDK Path', defaultsTo: null)
       ..addOption('dart-sdk-summary',
           help: 'Dart SDK Summary Path', defaultsTo: null)
       ..addOption('package-root',
-          abbr: 'p',
-          help: 'Package root to resolve "package:" imports',
-          defaultsTo: 'packages/')
+          abbr: 'p', help: 'Package root to resolve "package:" imports')
       ..addOption('url-mapping',
           help: '--url-mapping=libraryUri,/path/to/library.dart uses\n'
               'library.dart as the source for an import of of "libraryUri".',
           allowMultiple: true,
           splitCommas: false)
       ..addOption('package-paths',
           help: 'use a list of directories to resolve "package:" imports');
   }
 
   static Map<String, String> _parseUrlMappings(Iterable argument) {
@@ skipping 45 matching lines @@
         createFileResolvers(options, resourceProvider: resourceProvider);
   resolvers.addAll(fileResolvers);
   return new SourceFactory(resolvers, null, resourceProvider);
 }
 
 List<UriResolver> createFileResolvers(AnalyzerOptions options,
     {ResourceProvider resourceProvider}) {
   resourceProvider ??= PhysicalResourceProvider.INSTANCE;
   UriResolver packageResolver() {
     ContextBuilder builder = new ContextBuilder(resourceProvider, null, null);
-    builder.defaultPackagesDirectoryPath = options.packageRoot;
+    if (options.packageRoot != null) {
+      builder.defaultPackagesDirectoryPath = options.packageRoot;
+    }
     return new PackageMapUriResolver(resourceProvider,
         builder.convertPackagesToMap(builder.createPackageMap('')));
   }
 
   return [
     new ResourceUriResolver(resourceProvider),
     options.useMultiPackage
         ? new MultiPackageResolver(options.packagePaths)
         : packageResolver()
   ];
 }
 
 FolderBasedDartSdk _createFolderBasedDartSdk(String sdkPath) {
   var resourceProvider = PhysicalResourceProvider.INSTANCE;
   var sdk = new FolderBasedDartSdk(resourceProvider,
       resourceProvider.getFolder(sdkPath), /*useDart2jsPaths:*/ true);
   sdk.useSummary = true;
   sdk.analysisOptions = new AnalysisOptionsImpl()..strongMode = true;
   return sdk;
 }
 
 /// Creates a [DartUriResolver] that uses the SDK at the given [sdkPath].
 DartUriResolver createSdkPathResolver(String sdkSummaryPath, String sdkPath) {
   var sdk = (sdkSummaryPath != null)
       ? new SummaryBasedDartSdk(sdkSummaryPath, true)
       : _createFolderBasedDartSdk(sdkPath);
   return new DartUriResolver(sdk);
 }