Changes in analyzer needed for dev_compiler

pkg/analyzer/lib/src/generated/resolver.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 engine.resolver;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 17 matching lines @@
 /**
  * Callback signature used by ImplicitConstructorBuilder to register
  * computations to be performed, and their dependencies.  A call to this
  * callback indicates that [computation] may be used to compute implicit
  * constructors for [classElement], but that the computation may not be invoked
  * until after implicit constructors have been built for [superclassElement].
  */
 typedef void ImplicitConstructorBuilderCallback(ClassElement classElement,
     ClassElement superclassElement, void computation());
 
+typedef LibraryResolver LibraryResolverFactory(AnalysisContext context);
+
 typedef ResolverVisitor ResolverVisitorFactory(
     Library library, Source source, TypeProvider typeProvider);
 
 typedef StaticTypeAnalyzer StaticTypeAnalyzerFactory(ResolverVisitor visitor);
 
 typedef TypeResolverVisitor TypeResolverVisitorFactory(
     Library library, Source source, TypeProvider typeProvider);
 
 typedef void VoidFunction();
 
@@ skipping 7628 matching lines @@
    * The object representing the async library.
    */
   Library _asyncLibrary;
 
   /**
    * The object used to access the types from the core library.
    */
   TypeProvider _typeProvider;
 
   /**
+   * The object used to access the types from the core library.
+   */
+  TypeProvider get typeProvider => _typeProvider;
+
+  /**
    * A table mapping library sources to the information being maintained for those libraries.
    */
   HashMap<Source, Library> _libraryMap = new HashMap<Source, Library>();
 
   /**
    * A collection containing the libraries that are being resolved together.
    */
   Set<Library> _librariesInCycles;
 
   /**
@@ skipping 115 matching lines @@
     //
     // TODO(brianwilkerson) Decide whether we want to resolve all of the
     // libraries or whether we want to only resolve the target library.
     // The advantage to resolving everything is that we have already done part
     // of the work so we'll avoid duplicated effort. The disadvantage of
     // resolving everything is that we might do extra work that we don't
     // really care about. Another possibility is to add a parameter to this
     // method and punt the decision to the clients.
     //
     //if (analyzeAll) {
-    _resolveReferencesAndTypes();
+    resolveReferencesAndTypes();
     //} else {
     //  resolveReferencesAndTypes(targetLibrary);
     //}
     _performConstantEvaluation();
     return targetLibrary.libraryElement;
   }
 
   /**
    * Resolve the library specified by the given source in the given context.
    *
@@ skipping 60 matching lines @@
     //
     // TODO(brianwilkerson) Decide whether we want to resolve all of the
     // libraries or whether we want to only resolve the target library. The
     // advantage to resolving everything is that we have already done part of
     // the work so we'll avoid duplicated effort. The disadvantage of
     // resolving everything is that we might do extra work that we don't
     // really care about. Another possibility is to add a parameter to this
     // method and punt the decision to the clients.
     //
     //if (analyzeAll) {
-    _resolveReferencesAndTypes();
+    resolveReferencesAndTypes();
     //} else {
     //  resolveReferencesAndTypes(targetLibrary);
     //}
     _performConstantEvaluation();
     return targetLibrary.libraryElement;
   }
 
   /**
    * Add a dependency to the given map from the referencing library to the referenced library.
    *
@@ skipping 547 matching lines @@
       }
     });
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the libraries in the current cycle.
    *
    * @throws AnalysisException if any of the identifiers could not be resolved or if any of the
    *           libraries could not have their types analyzed
    */
-  void _resolveReferencesAndTypes() {
+  void resolveReferencesAndTypes() {
     for (Library library in _librariesInCycles) {
       _resolveReferencesAndTypesInLibrary(library);
     }
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the given library.
    *
    * @param library the library to be resolved
    * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
@@ skipping 4321 matching lines @@
 }
 
 /**
  * Instances of the class `TypeOverrideManager` manage the ability to override the type of an
  * element within a given context.
  */
 class TypeOverrideManager {
   /**
    * The current override scope, or `null` if no scope has been entered.
    */
-  TypeOverrideManager_TypeOverrideScope _currentScope;
+  TypeOverrideManager_TypeOverrideScope currentScope;
 
   /**
    * Apply a set of overrides that were previously captured.
    *
    * @param overrides the overrides to be applied
    */
   void applyOverrides(Map<VariableElement, DartType> overrides) {
-    if (_currentScope == null) {
+    if (currentScope == null) {
       throw new IllegalStateException("Cannot apply overrides without a scope");
     }
-    _currentScope.applyOverrides(overrides);
+    currentScope.applyOverrides(overrides);
   }
 
   /**
    * Return a table mapping the elements whose type is overridden in the current scope to the
    * overriding type.
    *
    * @return the overrides in the current scope
    */
   Map<VariableElement, DartType> captureLocalOverrides() {
-    if (_currentScope == null) {
+    if (currentScope == null) {
       throw new IllegalStateException(
           "Cannot capture local overrides without a scope");
     }
-    return _currentScope.captureLocalOverrides();
+    return currentScope.captureLocalOverrides();
   }
 
   /**
    * Return a map from the elements for the variables in the given list that have their types
    * overridden to the overriding type.
    *
    * @param variableList the list of variables whose overriding types are to be captured
    * @return a table mapping elements to their overriding types
    */
   Map<VariableElement, DartType> captureOverrides(
       VariableDeclarationList variableList) {
-    if (_currentScope == null) {
+    if (currentScope == null) {
       throw new IllegalStateException(
           "Cannot capture overrides without a scope");
     }
-    return _currentScope.captureOverrides(variableList);
+    return currentScope.captureOverrides(variableList);
   }
 
   /**
    * Enter a new override scope.
    */
   void enterScope() {
-    _currentScope = new TypeOverrideManager_TypeOverrideScope(_currentScope);
+    currentScope = new TypeOverrideManager_TypeOverrideScope(currentScope);
   }
 
   /**
    * Exit the current override scope.
    */
   void exitScope() {
-    if (_currentScope == null) {
+    if (currentScope == null) {
       throw new IllegalStateException("No scope to exit");
     }
-    _currentScope = _currentScope._outerScope;
+    currentScope = currentScope._outerScope;
   }
 
   /**
    * Return the best type information available for the given element. If the type of the element
    * has been overridden, then return the overriding type. Otherwise, return the static type.
    *
    * @param element the element for which type information is to be returned
    * @return the best type information available for the given element
    */
   DartType getBestType(VariableElement element) {
     DartType bestType = getType(element);
     return bestType == null ? element.type : bestType;
   }
 
   /**
    * Return the overridden type of the given element, or `null` if the type of the element has
    * not been overridden.
    *
    * @param element the element whose type might have been overridden
    * @return the overridden type of the given element
    */
   DartType getType(Element element) {
-    if (_currentScope == null) {
+    if (currentScope == null) {
       return null;
     }
-    return _currentScope.getType(element);
+    return currentScope.getType(element);
   }
 
   /**
    * Update overrides assuming [perBranchOverrides] is the collection of
    * per-branch overrides for *all* branches flowing into a join point.
    *
    * If a variable type in any of branches is not the same as its type before
    * the branching, then its propagated type is reset to `null`.
    */
   void mergeOverrides(List<Map<VariableElement, DartType>> perBranchOverrides) {
     for (Map<VariableElement, DartType> branch in perBranchOverrides) {
       branch.forEach((VariableElement variable, DartType branchType) {
-        DartType currentType = _currentScope.getType(variable);
+        DartType currentType = currentScope.getType(variable);
         if (currentType != branchType) {
-          _currentScope.resetType(variable);
+          currentScope.resetType(variable);
         }
       });
     }
   }
 
   /**
    * Set the overridden type of the given element to the given type
    *
    * @param element the element whose type might have been overridden
    * @param type the overridden type of the given element
    */
   void setType(VariableElement element, DartType type) {
-    if (_currentScope == null) {
+    if (currentScope == null) {
       throw new IllegalStateException("Cannot override without a scope");
     }
-    _currentScope.setType(element, type);
+    currentScope.setType(element, type);
   }
 }
 
 /**
  * Instances of the class `TypeOverrideScope` represent a scope in which the types of
  * elements can be overridden.
  */
 class TypeOverrideManager_TypeOverrideScope {
   /**
    * The outer scope in which types might be overridden.
@@ skipping 128 matching lines @@
 }
 
 /**
  * Instances of the class `TypePromotionManager` manage the ability to promote types of local
  * variables and formal parameters from their declared types based on control flow.
  */
 class TypePromotionManager {
   /**
    * The current promotion scope, or `null` if no scope has been entered.
    */
-  TypePromotionManager_TypePromoteScope _currentScope;
+  TypePromotionManager_TypePromoteScope currentScope;
 
   /**
    * Returns the elements with promoted types.
    */
-  Iterable<Element> get promotedElements => _currentScope.promotedElements;
+  Iterable<Element> get promotedElements => currentScope.promotedElements;
 
   /**
    * Enter a new promotions scope.
    */
   void enterScope() {
-    _currentScope = new TypePromotionManager_TypePromoteScope(_currentScope);
+    currentScope = new TypePromotionManager_TypePromoteScope(currentScope);
   }
 
   /**
    * Exit the current promotion scope.
    */
   void exitScope() {
-    if (_currentScope == null) {
+    if (currentScope == null) {
       throw new IllegalStateException("No scope to exit");
     }
-    _currentScope = _currentScope._outerScope;
+    currentScope = currentScope._outerScope;
   }
 
   /**
    * Returns static type of the given variable - declared or promoted.
    *
    * @return the static type of the given variable - declared or promoted
    */
   DartType getStaticType(VariableElement variable) {
     DartType staticType = getType(variable);
     if (staticType == null) {
       staticType = variable.type;
     }
     return staticType;
   }
 
   /**
    * Return the promoted type of the given element, or `null` if the type of the element has
    * not been promoted.
    *
    * @param element the element whose type might have been promoted
    * @return the promoted type of the given element
    */
   DartType getType(Element element) {
-    if (_currentScope == null) {
+    if (currentScope == null) {
       return null;
     }
-    return _currentScope.getType(element);
+    return currentScope.getType(element);
   }
 
   /**
    * Set the promoted type of the given element to the given type.
    *
    * @param element the element whose type might have been promoted
    * @param type the promoted type of the given element
    */
   void setType(Element element, DartType type) {
-    if (_currentScope == null) {
+    if (currentScope == null) {
       throw new IllegalStateException("Cannot promote without a scope");
     }
-    _currentScope.setType(element, type);
+    currentScope.setType(element, type);
   }
 }
 
 /**
  * Instances of the class `TypePromoteScope` represent a scope in which the types of
  * elements can be promoted.
  */
 class TypePromotionManager_TypePromoteScope {
   /**
    * The outer scope in which types might be promoter.
@@ skipping 2257 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }