expose strong checker API, for use by analyzer_cli

lib/src/checker/resolver.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.
 
 /// Encapsulates how to invoke the analyzer resolver and overrides how it
 /// computes types on expressions to use our restricted set of types.
 library dev_compiler.src.checker.resolver;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source.dart' show Source;
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart'
     show DirectedGraph;
 import 'package:logging/logging.dart' as logger;
 
-import 'package:dev_compiler/src/options.dart';
 import 'package:dev_compiler/src/utils.dart';
+import 'package:dev_compiler/strong_mode.dart' show StrongModeOptions;
 
 final _log = new logger.Logger('dev_compiler.src.resolver');
 
 /// A [LibraryResolver] that performs inference on top-levels and fields based
 /// on the value of the initializer, and on fields and methods based on
 /// overridden members in super classes.
 class LibraryResolverWithInference extends LibraryResolver {
-  final ResolverOptions _options;
+  final StrongModeOptions _options;
 
   LibraryResolverWithInference(context, this._options) : super(context);
 
   @override
   void resolveReferencesAndTypes() {
     _resolveVariableReferences();
 
     // Run resolution in two stages, skipping method bodies first, so we can run
     // type-inference before we fully analyze methods.
     var visitors = _createVisitors();
@@ skipping 166 matching lines @@
       // here will be dynamic.
       var enclosingElement = varElement.enclosingElement;
       var type = searchTypeFor(enclosingElement.type, getter);
 
       // Infer from the RHS when there are no overrides.
       if (type == null) {
         if (variable.initializer != null) pending.add(variable);
         continue;
       }
 
-      // When field is final and overriden getter is dynamic, we can infer from
+      // When field is final and overridden getter is dynamic, we can infer from
       // the RHS without breaking subtyping rules (return type is covariant).
       if (type.returnType.isDynamic) {
         if (variables.isFinal && variable.initializer != null) {
           pending.add(variable);
         }
         continue;
       }
 
       // Use type from the override.
       var newType = type.returnType;
@@ skipping 122 matching lines @@
   /// Internal state, whether we are revisiting an initializer, so we minimize
   /// the work being done elsewhere.
   bool _revisiting = false;
 
   /// Initializers that have been visited, reanalyzed, and for which no node was
   /// internally skipped. These initializers are fully resolved and don't need
   /// to be re-resolved on a sunsequent pass.
   final _visitedInitializers = new Set<VariableDeclaration>();
 
   RestrictedResolverVisitor(Library library, Source source,
-      TypeProvider typeProvider, ResolverOptions options)
+      TypeProvider typeProvider, StrongModeOptions options)
       : _typeProvider = typeProvider,
         super.con1(library, source, typeProvider,
             typeAnalyzerFactory: RestrictedStaticTypeAnalyzer.constructor);
 
   reanalyzeInitializer(VariableDeclaration variable) {
     try {
       _revisiting = true;
       _nodeWasSkipped = false;
       var node = variable.parent.parent;
       var oldState;
@@ skipping 316 matching lines @@
     }
   }
 
   // Review note: no longer need to override visitFunctionExpression, this is
   // handled by the analyzer internally.
   // TODO(vsm): in visitbinaryExpression: check computeStaticReturnType result?
   // TODO(vsm): in visitFunctionDeclaration: Should we ever use the expression
   // type in a (...) => expr or just the written type?
 
 }