Add explicit-sources flag and create an ExplicitSourceResolver for analyzer.

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/src/generated/engine.dart'
     show AnalysisContext, AnalysisEngine, AnalysisOptionsImpl;
 import 'package:analyzer/src/generated/java_io.dart' show JavaFile;
 import 'package:analyzer/src/generated/sdk_io.dart' show DirectoryBasedDartSdk;
 import 'package:analyzer/src/generated/source_io.dart'
     show
         CustomUriResolver,
         DartUriResolver,
+        ExplicitSourceResolver,
         FileUriResolver,
         PackageUriResolver,
         SourceFactory,
         UriResolver;
 import 'package:analyzer/src/summary/package_bundle_reader.dart'
     show
         InSummaryPackageUriResolver,
         InputPackagesResultProvider,
         SummaryDataStore;
 import 'package:cli_util/cli_util.dart' show getSdkDir;
 import 'package:path/path.dart' as path;
 
 import 'dart_sdk.dart' show MockDartSdk, mockSdkSources;
 import 'multi_package_resolver.dart' show MultiPackageResolver;
 
 /// Options used to set up Source URI resolution in the analysis context.
 class AnalyzerOptions {
-  /// Custom URI mappings, such as "dart:foo" -> "path/to/foo.dart"
+  /// Custom URI mappings, such as "dart:foo" -> "path/to/foo.dart".
   final Map<String, String> customUrlMappings;
 
+  /// Whether the [customUrlMappings] are all inclusive, in which case an error
+  /// should be produced if a lookup fails.
+  final bool allInclusive;
+
   /// Package root when resolving 'package:' urls the standard way.
   final String packageRoot;
 
   /// List of summary file paths.
   final List<String> summaryPaths;
 
   /// List of paths used for the multi-package resolver.
   final List<String> packagePaths;
 
   /// Whether to use a mock-sdk during compilation.
   final bool useMockSdk;
 
   /// Path to the dart-sdk. Null if `useMockSdk` is true or if the path couldn't
   /// be determined
   final String dartSdkPath;
 
   AnalyzerOptions(
       {this.summaryPaths: const [],
       this.useMockSdk: false,
       String dartSdkPath,
       this.customUrlMappings: const {},
+      this.allInclusive: false,
       this.packageRoot: 'packages/',
       this.packagePaths: const []})
       : dartSdkPath = dartSdkPath ?? getSdkDir().path;
 
   AnalyzerOptions.fromArguments(ArgResults args)
       : summaryPaths = args['summary'],
         useMockSdk = false,
         dartSdkPath = args['dart-sdk'] ?? getSdkDir().path,
         customUrlMappings = _parseUrlMappings(args['url-mapping']),
+        allInclusive = args['all-inclusive'],
         packageRoot = args['package-root'],
         packagePaths = args['package-paths']?.split(',') ?? [];
 
   /// Whether to resolve 'package:' uris using the multi-package resolver.
   bool get useMultiPackage => packagePaths.isNotEmpty;
 
   static ArgParser addArguments(ArgParser parser) {
     return parser
       ..addOption('summary',
           abbr: 's', help: 'summary file(s) to include', allowMultiple: true)
       ..addOption('dart-sdk', help: 'Dart SDK Path', defaultsTo: null)
       ..addOption('package-root',
           abbr: 'p',
           help: 'Package root to resolve "package:" imports',
           defaultsTo: 'packages/')
       ..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)
+      ..addFlag('all-inclusive',
+          help: 'whether all `package:` uris are explicitly listed \n'
+              'via the url-mapping flag.',
+          defaultsTo: false)
       ..addOption('package-paths',
           help: 'use a list of directories to resolve "package:" imports');
   }
 
   static Map<String, String> _parseUrlMappings(Iterable argument) {
     var mappings = <String, String>{};
     for (var mapping in argument) {
       var splitMapping = mapping.split(',');
       if (splitMapping.length >= 2) {
         mappings[splitMapping[0]] = path.absolute(splitMapping[1]);
@@ skipping 46 matching lines @@
 /// Use [options.useMockSdk] to specify the SDK mode, or use [sdkResolver]
 /// to entirely override the DartUriResolver.
 ///
 /// If supplied, [fileResolvers] will override the default `file:` and
 /// `package:` URI resolvers.
 SourceFactory _createSourceFactory(AnalyzerOptions options,
     {DartUriResolver sdkResolver,
     List<UriResolver> fileResolvers,
     SummaryDataStore summaryData}) {
   var resolvers = <UriResolver>[];
-  if (options.customUrlMappings.isNotEmpty) {
+  if (!options.allInclusive && options.customUrlMappings.isNotEmpty) {
     resolvers.add(new CustomUriResolver(options.customUrlMappings));
   }
   resolvers.add(sdkResolver);
   if (summaryData != null) {
     resolvers.add(new InSummaryPackageUriResolver(summaryData));
   }
 
   if (fileResolvers == null) fileResolvers = createFileResolvers(options);
   resolvers.addAll(fileResolvers);
   return new SourceFactory(resolvers);
 }
 
 List<UriResolver> createFileResolvers(AnalyzerOptions options) {
-  return [
-    new FileUriResolver(),
-    options.useMultiPackage
-        ? new MultiPackageResolver(options.packagePaths)
-        : new PackageUriResolver([new JavaFile(options.packageRoot)])
-  ];
+  var resolvers = <UriResolver>[];
+  if (options.allInclusive) {
+    resolvers.add(new ExplicitSourceResolver(
+        _createUriToFileMap(options.customUrlMappings)));
+  }
+  resolvers.add(new FileUriResolver());
+  resolvers.add(options.useMultiPackage
+      ? new MultiPackageResolver(options.packagePaths)
+      : new PackageUriResolver([new JavaFile(options.packageRoot)]));
+  return resolvers;
+}
+
+// TODO(sigmund): delete, this was adapted from analyzer_cli, ideally this
+// should be shared code in package:analyzer.
+Map<Uri, JavaFile> _createUriToFileMap(Map<String, String> mapping) {
+  var uriToFileMap = <Uri, JavaFile>{};
+  mapping.forEach((key, value) {
+    uriToFileMap[Uri.parse(key)] = new JavaFile(value);
+  });
+  return uriToFileMap;
 }
 
 /// Creates a [DartUriResolver] that uses a mock 'dart:' library contents.
 DartUriResolver createMockSdkResolver(Map<String, String> mockSources) =>
     new MockDartSdk(mockSources, reportMissing: true).resolver;
 
 /// Creates a [DartUriResolver] that uses the SDK at the given [sdkPath].
 DartUriResolver createSdkPathResolver(String sdkPath) {
   var sdk = new DirectoryBasedDartSdk(
       new JavaFile(sdkPath), /*useDart2jsPaths:*/ true);
   sdk.useSummary = true;
   sdk.analysisOptions = new AnalysisOptionsImpl()..strongMode = true;
   return new DartUriResolver(sdk);
 }