Exposing code_transformer's Resolvers options

pkg/code_transformers/lib/src/resolvers.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.
 
 library code_transformers.src.resolvers;
 
 import 'dart:async';
 import 'package:barback/barback.dart';
 
+import 'package:analyzer/src/generated/engine.dart' show AnalysisOptions;
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/source.dart' show DartUriResolver;
 
 import 'entry_point.dart';
 import 'resolver.dart';
 import 'resolver_impl.dart';
 import 'dart_sdk.dart' hide dartSdkDirectory;
 
 /// Barback-based code resolvers which maintains up-to-date resolved ASTs for
 /// the specified code entry points.
 ///
 /// This can used by transformers dependent on resolved ASTs to handle the
 /// resolution of the AST and cache the results between compilations.
 ///
 /// If multiple transformers rely on a resolved AST they should (ideally) share
 /// the same Resolvers object to minimize re-parsing the AST.
 class Resolvers {
   final Map<AssetId, Resolver> _resolvers = {};
   final DartSdk dartSdk;
   final DartUriResolver dartUriResolver;
+  final AnalysisOptions options;
 
-  Resolvers.fromSdk(this.dartSdk, this.dartUriResolver);
+  Resolvers.fromSdk(this.dartSdk, this.dartUriResolver, {this.options});
 
-  factory Resolvers(dartSdkDirectory) {
+  factory Resolvers(dartSdkDirectory, {AnalysisOptions options}) {
     var sdk = new DirectoryBasedDartSdkProxy(dartSdkDirectory);
     var uriResolver = new DartUriResolverProxy(sdk);
-    return new Resolvers.fromSdk(sdk, uriResolver);
+    return new Resolvers.fromSdk(sdk, uriResolver, options: options);
   }
 
   factory Resolvers.fromMock(Map<String, String> sources,
-      {bool reportMissing: false}) {
+      {bool reportMissing: false, AnalysisOptions options}) {
     var sdk = new MockDartSdk(sources, reportMissing: reportMissing);
-    return new Resolvers.fromSdk(sdk, sdk.resolver);
+    return new Resolvers.fromSdk(sdk, sdk.resolver, options: options);
   }
 
   /// Get a resolver for [transform]. If provided, this resolves the code
   /// starting from each of the assets in [entryPoints]. If not, this resolves
   /// the code starting from `transform.primaryInput.id` by default.
   ///
   /// [Resolver.release] must be called once it's done being used, or
   /// [ResolverTransformer] should be used to automatically release the
   /// resolver.
   Future<Resolver> get(Transform transform, [List<AssetId> entryPoints]) {
     var id = transform.primaryInput.id;
     var resolver = _resolvers.putIfAbsent(id,
-        () => new ResolverImpl(dartSdk, dartUriResolver));
+        () => new ResolverImpl(dartSdk, dartUriResolver, options: options));
     return resolver.resolve(transform, entryPoints);
   }
 }
 
 /// Transformer mixin which automatically gets and releases resolvers.
 ///
 /// To use mix this class in, set the resolvers field and override
 /// [applyResolver].
 abstract class ResolverTransformer implements Transformer {
   /// The cache of resolvers- must be set from subclass.
@@ skipping 47 matching lines @@
           resolver.release();
         });
     });
   }
 
   /// Invoked when the resolver is ready to be processed.
   ///
   /// Return a Future to indicate when apply is completed.
   applyResolver(Transform transform, Resolver resolver);
 }