fixes #201, add support for custom URL mapping

lib/src/options.dart

 // Copyright (c) 2014, 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.
 
 /// Set of flags and options passed to the compiler
 library dev_compiler.src.options;
 
 import 'dart:io';
 
 import 'package:args/args.dart';
 import 'package:cli_util/cli_util.dart' show getSdkDir;
 import 'package:dev_compiler/config.dart';
 import 'package:logging/logging.dart' show Level;
 import 'package:path/path.dart' as path;
 import 'package:yaml/yaml.dart';
 
 /// Options used by our checker.
-// TODO(jmesserly): move useMultiPackage/packageRoot to CompilerOptions.
-class ResolverOptions {
-  /// Whether to resolve 'package:' uris using the multi-package resolver.
-  final bool useMultiPackage;

[vsm, 2015/06/03 15:37:47]

Seems a little weird to move these out of ResolverOptions - each is directly
related to resolution.

Perhaps we don't even need a separate ResolverOptions class at this point?

[Jennifer Messerly, 2015/06/03 16:24:11]

Hmmm. What is "resolution" in this context? Analyzer uses it for at least two
meanings: URI resolution and name resolution. I thought the etymology of this
ResolutionOptions was "options used by our TypeResolver class", which is gone
now.

After my change, it was supposed to mean: "options used by our
RestrictedResolverVisitor". (lib/src/checker/resolver.dart)

IMO, there's not really a relationship between URI resolution stuff (package
roots, etc) and type inference options... both are in this class now. They are
consumed in very different places in our code base. The URI resolution stuff
won't be needed when we use analyzer_cli, for example. (... and I just noticed
entryPointFile and useImplicitHtml should be moved out too)

I'd be happy to make a seperate "URI resolution" options class, if that helps?

I also noticed Checker consumes CompilerOptions right now. Maybe worth having a
CheckerOptions class?


Hah, and here I thought I would just fix a little TODO while I was here.
Apparently options is quite a rabbit hole :-)
True, we certainly don't need it. I don't recall exactly how we arrived here,
but it did seem useful to be able to create a RestrictedResolverVisitor and have
it only depend on its own options. This might help, e.g. with analyzer_cli
integration. I guess I should restore the constructor though, in that case, and
also make sure checker's options are split out from CompilerOptions.

-
-  /// Package root when resolving 'package:' urls the standard way.
-  final String packageRoot;
-
-  /// List of paths used for the multi-package resolver.
-  final List<String> packagePaths;
-
-  /// List of additional non-Dart resources to resolve and serve.
-  final List<String> resources;
-
+abstract class ResolverOptions {
   /// Whether to infer return types and field types from overriden members.
-  final bool inferFromOverrides;
+  bool get inferFromOverrides;
   static const inferFromOverridesDefault = true;
 
   /// Whether to infer types for consts and fields by looking at initializers on
   /// the RHS. For example, in a constant declaration like:
   ///
   ///      const A = B;
   ///
   /// We can infer the type of `A` based on the type of `B`.
   ///
   /// The inference algorithm determines what variables depend on others, and
   /// computes types by visiting the variable dependency graph in topological
   /// order. This ensures that the inferred type is deterministic when applying
   /// inference on library cycles.
   ///
   /// When this feature is turned off, we don't use the type of `B` to infer the
   /// type of `A`, even if `B` has a declared type.
-  final bool inferTransitively;
+  bool get inferTransitively;
   static const inferTransitivelyDefault = true;
 
   /// Restrict inference of fields and top-levels to those that are final and
   /// const.
-  final bool onlyInferConstsAndFinalFields;
+  bool get onlyInferConstsAndFinalFields;
   static const onlyInferConstAndFinalFieldsDefault = false;
 
   /// File where to start compilation from.
-  final String entryPointFile;
+  String get entryPointFile;
 
   // True if the resolver should implicitly provide an html entry point.
-  final bool useImplicitHtml;
+  bool get useImplicitHtml;
   static const String implicitHtmlFile = 'index.html';
-
-  ResolverOptions({this.useMultiPackage: false, this.packageRoot: 'packages/',
-      this.packagePaths: const <String>[], this.resources: const <String>[],
-      this.inferFromOverrides: inferFromOverridesDefault,
-      this.inferTransitively: inferTransitivelyDefault,
-      this.onlyInferConstsAndFinalFields: onlyInferConstAndFinalFieldsDefault,
-      this.entryPointFile: null, this.useImplicitHtml: false});
 }
 
 // TODO(vsm): Merge RulesOptions and TypeOptions
 /// Options used by our RestrictedRules.
 class RulesOptions extends TypeOptions {
   /// Whether to allow casts in constant contexts.
   final bool allowConstCasts;
 
   /// Whether to use covariant generics
   final bool covariantGenerics;
@@ skipping 93 matching lines @@
   final String host;
 
   /// Whether to use covariant generics
   @override
   final bool covariantGenerics;
 
   /// Whether to inject casts between Dart assignable types.
   @override
   final bool relaxedCasts;
 
+  /// Custom URI mappings, such as "dart:foo" -> "path/to/foo.dart"
+  final Map<String, String> customUrlMappings;
+
   /// Whether to resolve 'package:' uris using the multi-package resolver.
-  @override
   final bool useMultiPackage;
 
   /// Package root when resolving 'package:' urls the standard way.
-  @override
   final String packageRoot;
 
   /// List of paths used for the multi-package resolver.
-  @override
   final List<String> packagePaths;
 
   /// List of additional non-Dart resources to resolve and serve.
-  @override
   final List<String> resources;
 
   /// Whether to infer types downwards from local context
   @override
   final bool inferDownwards;
 
   /// Whether to infer return types and field types from overriden members.
   @override
   final bool inferFromOverrides;
 
@@ skipping 28 matching lines @@
   /// package (if we can infer where that is located).
   final String runtimeDir;
 
   CompilerOptions({this.allowConstCasts: true, this.checkSdk: false,
       this.dumpInfo: false, this.dumpInfoFile, this.dumpSrcDir,
       this.forceCompile: false, this.formatOutput: false,
       this.ignoreTypes: false,
       this.wrapClosures: RulesOptions.wrapClosuresDefault, this.outputDir,
       this.outputDart: false, this.useColors: true,
       this.covariantGenerics: true, this.relaxedCasts: true,
-      this.useMultiPackage: false, this.packageRoot: 'packages/',
-      this.packagePaths: const <String>[], this.resources: const <String>[],
+      this.customUrlMappings: const {}, this.useMultiPackage: false,
+      this.packageRoot: 'packages/', this.packagePaths: const <String>[],
+      this.resources: const <String>[],
       this.inferDownwards: RulesOptions.inferDownwardsDefault,
       this.inferFromOverrides: ResolverOptions.inferFromOverridesDefault,
       this.inferTransitively: ResolverOptions.inferTransitivelyDefault,
       this.onlyInferConstsAndFinalFields: ResolverOptions.onlyInferConstAndFinalFieldsDefault,
       this.nonnullableTypes: TypeOptions.NONNULLABLE_TYPES, this.help: false,
       this.useMockSdk: false, this.dartSdkPath, this.logLevel: Level.SEVERE,
       this.emitSourceMaps: true, this.entryPointFile: null,
       this.serverMode: false, this.useImplicitHtml: false,
       this.enableHashing: false, this.host: 'localhost', this.port: 8080,
       this.runtimeDir});
 }
 
 /// Parses options from the command-line
 CompilerOptions parseOptions(List<String> argv) {
   ArgResults args = argParser.parse(argv);
+  bool showUsage = args['help'];
+
   var serverMode = args['server'];
   var enableHashing = args['hashing'];
   if (enableHashing == null) {
     enableHashing = serverMode;
   }
   // TODO(jmesserly): shouldn't level always default to warning?
   var logLevel = serverMode ? Level.WARNING : Level.SEVERE;
   var levelName = args['log'];
   if (levelName != null) {
     levelName = levelName.toUpperCase();
     logLevel = Level.LEVELS.firstWhere((l) => l.name == levelName,
         orElse: () => logLevel);
   }
   var useColors = stdioType(stdout) == StdioType.TERMINAL;
   var sdkPath = args['dart-sdk'];
   if (sdkPath == null && !args['mock-sdk']) {
     sdkPath = getSdkDir(argv).path;
   }
   var runtimeDir = args['runtime-dir'];
   if (runtimeDir == null) {
     runtimeDir = _computeRuntimeDir();
   }
   var outputDir = args['out'];
   if (outputDir == null && serverMode) {
     outputDir = Directory.systemTemp.createTempSync("dev_compiler_out_").path;
   }
   var dumpInfo = args['dump-info'];
   if (dumpInfo == null) dumpInfo = serverMode;
 
+  var customUrlMappings = <String, String>{};
+  for (var mapping in args['url-mapping']) {
+    var splitMapping = mapping.split(',');
+    if (splitMapping.length != 2) {
+      showUsage = true;
+      continue;
+    }
+    customUrlMappings[splitMapping[0]] = splitMapping[1];
+  }
+
   var entryPointFile = args.rest.length == 0 ? null : args.rest.first;
 
   return new CompilerOptions(
       allowConstCasts: args['allow-const-casts'],
       checkSdk: args['sdk-check'],
       dumpInfo: dumpInfo,
       dumpInfoFile: args['dump-info-file'],
       dumpSrcDir: args['dump-src-to'],
       forceCompile: args['force-compile'] || serverMode,
       formatOutput: args['dart-gen-fmt'],
       ignoreTypes: args['ignore-types'],
       wrapClosures: args['wrap-closures'],
       outputDart: args['dart-gen'],
       outputDir: outputDir,
       covariantGenerics: args['covariant-generics'],
       relaxedCasts: args['relaxed-casts'],
       useColors: useColors,
+      customUrlMappings: customUrlMappings,
       useMultiPackage: args['use-multi-package'],
       packageRoot: args['package-root'],
       packagePaths: args['package-paths'].split(','),
       resources: args['resources']
           .split(',')
           .where((s) => s.isNotEmpty)
           .toList(),
       inferDownwards: args['infer-downwards'],
       inferFromOverrides: args['infer-from-overrides'],
       inferTransitively: args['infer-transitively'],
       onlyInferConstsAndFinalFields: args['infer-only-finals'],
       nonnullableTypes: optionsToList(args['nonnullable'],
           defaultValue: TypeOptions.NONNULLABLE_TYPES),
-      help: args['help'],
+      help: showUsage,
       useMockSdk: args['mock-sdk'],
       dartSdkPath: sdkPath,
       logLevel: logLevel,
       emitSourceMaps: args['source-maps'],
       entryPointFile: entryPointFile,
       serverMode: serverMode,
       useImplicitHtml: serverMode && entryPointFile.endsWith('.dart'),
       enableHashing: enableHashing,
       host: args['host'],
       port: int.parse(args['port']),
@@ skipping 40 matching lines @@
   ..addOption('dart-sdk', help: 'Dart SDK Path', defaultsTo: null)
   ..addFlag('dart-gen',
       abbr: 'd', help: 'Generate dart output', defaultsTo: false)
   ..addFlag('dart-gen-fmt',
       help: 'Generate readable dart output', defaultsTo: true)
   ..addOption('dump-src-to', help: 'Dump dart src code', 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 library.dart\n'
+      'as the source for an import of of "libraryUri".',
+      allowMultiple: true,
+      splitCommas: false)
   ..addFlag('use-multi-package',
       help: 'Whether to use the multi-package resolver for "package:" imports',
       defaultsTo: false)
   ..addOption('package-paths',
       help: 'if using the multi-package resolver, the list of directories to\n'
       'look for packages in.', defaultsTo: '')
   ..addOption('resources',
       help: 'Additional resources to serve', defaultsTo: '')
   ..addFlag('source-maps',
       help: 'Whether to emit source map files', defaultsTo: true)
@@ skipping 65 matching lines @@
     // The pub-cache directory is two levels up, but we verify that the layout
     // looks correct.
     if (path.basename(dir) != 'dev_compiler') return null;
     dir = path.dirname(dir);
     if (path.basename(dir) != 'global_packages') return null;
     dir = path.dirname(dir);
     return path.join(dir, cacheDir, 'lib', 'runtime');
   }
   return null;
 }