New analyzer_experimental snapshot.

pkg/analyzer_experimental/lib/src/generated/resolver.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.resolver;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'source.dart';
 import 'error.dart';
 import 'scanner.dart' as sc;
@@ skipping 17 matching lines @@
   /**
    * Build the compilation unit element for the given source.
    *
    * @param source the source describing the compilation unit
    * @param unit the AST structure representing the compilation unit
    * @return the compilation unit element that was built
    * @throws AnalysisException if the analysis could not be performed
    */
   CompilationUnitElementImpl buildCompilationUnit(Source source, CompilationUnit unit) {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
-    if (unit == null) {
-      return null;
+    try {
+      if (unit == null) {
+        return null;
+      }
+      ElementHolder holder = new ElementHolder();
+      ElementBuilder builder = new ElementBuilder(holder);
+      unit.accept(builder);
+      CompilationUnitElementImpl element = new CompilationUnitElementImpl(source.shortName);
+      element.accessors = holder.accessors;
+      element.functions = holder.functions;
+      element.source = source;
+      element.typeAliases = holder.typeAliases;
+      element.types = holder.types;
+      element.topLevelVariables = holder.topLevelVariables;
+      unit.element = element;
+      return element;
+    } finally {
+      timeCounter.stop();
     }
-    ElementHolder holder = new ElementHolder();
-    ElementBuilder builder = new ElementBuilder(holder);
-    unit.accept(builder);
-    CompilationUnitElementImpl element = new CompilationUnitElementImpl(source.shortName);
-    element.accessors = holder.accessors;
-    element.functions = holder.functions;
-    element.source = source;
-    element.typeAliases = holder.typeAliases;
-    element.types = holder.types;
-    element.topLevelVariables = holder.topLevelVariables;
-    unit.element = element;
-    timeCounter.stop();
-    return element;
   }
 }
 /**
  * Instances of the class `ElementBuilder` traverse an AST structure and build the element
  * model representing the AST structure.
  *
  * @coverage dart.engine.resolver
  */
 class ElementBuilder extends RecursiveASTVisitor<Object> {
 
@@ skipping 1471 matching lines @@
    *
    * @param node the as expression to check
    * @return `true` if and only if a hint code is generated on the passed node
    * @see HintCode#UNNECESSARY_CAST
    */
   bool checkForUnnecessaryCast(AsExpression node) {
     Expression expression = node.expression;
     TypeName typeName = node.type;
     Type2 lhsType = expression.staticType;
     Type2 rhsType = typeName.type;
-    if (lhsType != null && rhsType != null && !lhsType.isDynamic && !rhsType.isDynamic && lhsType.isSubtypeOf(rhsType)) {
+    if (lhsType != null && rhsType != null && !lhsType.isDynamic && !rhsType.isDynamic && lhsType is! TypeParameterType && rhsType is! TypeParameterType && lhsType.isSubtypeOf(rhsType)) {
       _errorReporter.reportError2(HintCode.UNNECESSARY_CAST, node, []);
       return true;
     }
     return false;
   }
 }
 /**
  * Instances of the class `Dart2JSVerifier` traverse an AST structure looking for hints for
  * code that will be compiled to JS, such as [HintCode#IS_DOUBLE].
  *
@@ skipping 299 matching lines @@
   HintGenerator(List<CompilationUnit> compilationUnits, AnalysisContext context, AnalysisErrorListener errorListener) {
     this._compilationUnits = compilationUnits;
     this._context = context;
     this._errorListener = errorListener;
     LibraryElement library = compilationUnits[0].element.library;
     _importsVerifier = new ImportsVerifier(library);
     _enableDart2JSHints = context.analysisOptions.dart2jsHint;
   }
   void generateForLibrary() {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.hints.start();
-    for (int i = 0; i < _compilationUnits.length; i++) {
-      CompilationUnitElement element = _compilationUnits[i].element;
-      if (element != null) {
-        if (i == 0) {
-          _importsVerifier.inDefiningCompilationUnit = true;
-          generateForCompilationUnit(_compilationUnits[i], element.source);
-          _importsVerifier.inDefiningCompilationUnit = false;
-        } else {
-          generateForCompilationUnit(_compilationUnits[i], element.source);
+    try {
+      for (int i = 0; i < _compilationUnits.length; i++) {
+        CompilationUnitElement element = _compilationUnits[i].element;
+        if (element != null) {
+          if (i == 0) {
+            _importsVerifier.inDefiningCompilationUnit = true;
+            generateForCompilationUnit(_compilationUnits[i], element.source);
+            _importsVerifier.inDefiningCompilationUnit = false;
+          } else {
+            generateForCompilationUnit(_compilationUnits[i], element.source);
+          }
         }
       }
+      ErrorReporter definingCompilationUnitErrorReporter = new ErrorReporter(_errorListener, _compilationUnits[0].element.source);
+      _importsVerifier.generateDuplicateImportHints(definingCompilationUnitErrorReporter);
+      _importsVerifier.generateUnusedImportHints(definingCompilationUnitErrorReporter);
+    } finally {
+      timeCounter.stop();
     }
-    ErrorReporter definingCompilationUnitErrorReporter = new ErrorReporter(_errorListener, _compilationUnits[0].element.source);
-    _importsVerifier.generateDuplicateImportHints(definingCompilationUnitErrorReporter);
-    _importsVerifier.generateUnusedImportHints(definingCompilationUnitErrorReporter);
-    timeCounter.stop();
   }
   void generateForCompilationUnit(CompilationUnit unit, Source source) {
     ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
     _importsVerifier.visitCompilationUnit(unit);
     new DeadCodeVerifier(errorReporter).visitCompilationUnit(unit);
     if (_enableDart2JSHints) {
       new Dart2JSVerifier(errorReporter).visitCompilationUnit(unit);
     }
     new BestPracticesVerifier(errorReporter).visitCompilationUnit(unit);
   }
@@ skipping 3075 matching lines @@
       return resultMap;
     }
     if (superclassElt != null) {
       if (!visitedClasses.contains(superclassElt)) {
         javaSetAdd(visitedClasses, classElt);
         resultMap = new MemberMap.con2(computeClassChainLookupMap(superclassElt, visitedClasses));
       } else {
         _classLookup[superclassElt] = resultMap;
         return resultMap;
       }
+      substituteTypeParametersDownHierarchy(supertype, resultMap);
       recordMapWithClassMembers(resultMap, supertype);
     }
     List<InterfaceType> mixins = classElt.mixins;
     for (int i = mixins.length - 1; i >= 0; i--) {
       recordMapWithClassMembers(resultMap, mixins[i]);
     }
     _classLookup[classElt] = resultMap;
     return resultMap;
   }
 
@@ skipping 66 matching lines @@
     ClassElement superclassElement = supertype != null ? supertype.element : null;
     List<InterfaceType> mixins = classElt.mixins;
     List<InterfaceType> interfaces = classElt.interfaces;
     List<MemberMap> lookupMaps = new List<MemberMap>();
     if (superclassElement != null) {
       if (!visitedInterfaces.contains(superclassElement)) {
         try {
           javaSetAdd(visitedInterfaces, superclassElement);
           MemberMap map = computeInterfaceLookupMap(superclassElement, visitedInterfaces);
           map = new MemberMap.con2(map);
-          List<MethodElement> methods = supertype.methods;
-          for (MethodElement method in methods) {
-            if (method.isAccessibleIn(_library) && !method.isStatic) {
-              map.put(method.name, method);
-            }
-          }
-          List<PropertyAccessorElement> accessors = supertype.accessors;
-          for (PropertyAccessorElement accessor in accessors) {
-            if (accessor.isAccessibleIn(_library) && !accessor.isStatic) {
-              map.put(accessor.name, accessor);
-            }
-          }
+          substituteTypeParametersDownHierarchy(supertype, map);
+          recordMapWithClassMembers(map, supertype);
           lookupMaps.add(map);
         } finally {
           visitedInterfaces.remove(superclassElement);
         }
       } else {
         MemberMap map = _interfaceLookup[classElt];
         if (map != null) {
           lookupMaps.add(map);
         } else {
           _interfaceLookup[superclassElement] = resultMap;
           return resultMap;
         }
       }
     }
     for (InterfaceType mixinType in mixins) {
       MemberMap mapWithMixinMembers = new MemberMap();
       recordMapWithClassMembers(mapWithMixinMembers, mixinType);
       lookupMaps.add(mapWithMixinMembers);
     }
     for (InterfaceType interfaceType in interfaces) {
       ClassElement interfaceElement = interfaceType.element;
       if (interfaceElement != null) {
         if (!visitedInterfaces.contains(interfaceElement)) {
           try {
             javaSetAdd(visitedInterfaces, interfaceElement);
             MemberMap map = computeInterfaceLookupMap(interfaceElement, visitedInterfaces);
             map = new MemberMap.con2(map);
-            List<MethodElement> methods = interfaceType.methods;
-            for (MethodElement method in methods) {
-              if (method.isAccessibleIn(_library) && !method.isStatic) {
-                map.put(method.name, method);
-              }
-            }
-            List<PropertyAccessorElement> accessors = interfaceType.accessors;
-            for (PropertyAccessorElement accessor in accessors) {
-              if (accessor.isAccessibleIn(_library) && !accessor.isStatic) {
-                map.put(accessor.name, accessor);
-              }
-            }
+            substituteTypeParametersDownHierarchy(interfaceType, map);
+            recordMapWithClassMembers(map, interfaceType);
             lookupMaps.add(map);
           } finally {
             visitedInterfaces.remove(interfaceElement);
           }
         } else {
           MemberMap map = _interfaceLookup[classElt];
           if (map != null) {
             lookupMaps.add(map);
           } else {
             _interfaceLookup[interfaceElement] = resultMap;
@@ skipping 146 matching lines @@
    * @param arguments the arguments used to build the error message
    */
   void reportError(ClassElement classElt, int offset, int length, ErrorCode errorCode, List<Object> arguments) {
     Set<AnalysisError> errorSet = _errorsInClassElement[classElt];
     if (errorSet == null) {
       errorSet = new Set<AnalysisError>();
       _errorsInClassElement[classElt] = errorSet;
     }
     javaSetAdd(errorSet, new AnalysisError.con2(classElt.source, offset, length, errorCode, arguments));
   }
+
+  /**
+   * Loop through all of the members in some [MemberMap], performing type parameter
+   * substitutions using a passed supertype.
+   *
+   * @param superType the supertype to substitute into the members of the [MemberMap]
+   * @param map the MemberMap to perform the substitutions on
+   */
+  void substituteTypeParametersDownHierarchy(InterfaceType superType, MemberMap map) {
+    for (int i = 0; i < map.size; i++) {
+      String key = map.getKey(i);
+      ExecutableElement executableElement = map.getValue(i);
+      if (executableElement is MethodMember) {
+        executableElement = MethodMember.from(executableElement as MethodMember, superType);
+        map.put(key, executableElement);
+      } else if (executableElement is PropertyAccessorMember) {
+        executableElement = PropertyAccessorMember.from(executableElement as PropertyAccessorMember, superType);
+        map.put(key, executableElement);
+      }
+    }
+  }
 }
 /**
  * Instances of the class `Library` represent the data about a single library during the
  * resolution of some (possibly different) library. They are not intended to be used except during
  * the resolution process.
  *
  * @coverage dart.engine.resolver
  */
 class Library {
 
@@ skipping 709 matching lines @@
       List<ImportElement> imports = new List<ImportElement>();
       List<ExportElement> exports = new List<ExportElement>();
       for (Directive directive in library.definingCompilationUnit.directives) {
         if (directive is ImportDirective) {
           ImportDirective importDirective = directive as ImportDirective;
           Source importedSource = library.getSource(importDirective);
           if (importedSource != null) {
             Library importedLibrary = _libraryMap[importedSource];
             if (importedLibrary != null) {
               ImportElementImpl importElement = new ImportElementImpl();
+              importElement.offset = directive.offset;
+              StringLiteral uriLiteral = importDirective.uri;
+              if (uriLiteral != null) {
+                importElement.uriEnd = uriLiteral.end;
+              }
               importElement.uri = library.getUri(importDirective);
               importElement.combinators = buildCombinators(importDirective);
               LibraryElement importedLibraryElement = importedLibrary.libraryElement;
               if (importedLibraryElement != null) {
                 importElement.importedLibrary = importedLibraryElement;
               }
               SimpleIdentifier prefixNode = ((directive as ImportDirective)).prefix;
               if (prefixNode != null) {
+                importElement.prefixOffset = prefixNode.offset;
                 String prefixName = prefixNode.name;
                 PrefixElementImpl prefix = nameToPrefixMap[prefixName];
                 if (prefix == null) {
                   prefix = new PrefixElementImpl(prefixNode);
                   nameToPrefixMap[prefixName] = prefix;
                 }
                 importElement.prefix = prefix;
                 prefixNode.staticElement = prefix;
               }
               directive.element = importElement;
               imports.add(importElement);
               if (doesCompilationUnitHavePartOfDirective(importedLibrary.getAST(importedSource))) {
-                StringLiteral uriLiteral = importDirective.uri;
                 errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY, [uriLiteral.toSource()]));
               }
             }
           }
         } else if (directive is ExportDirective) {
           ExportDirective exportDirective = directive as ExportDirective;
           Source exportedSource = library.getSource(exportDirective);
           if (exportedSource != null) {
             Library exportedLibrary = _libraryMap[exportedSource];
             if (exportedLibrary != null) {
@@ skipping 41 matching lines @@
   }
 
   /**
    * Resolve the type hierarchy across all of the types declared in the libraries in the current
    * cycle.
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
   void buildTypeHierarchies() {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
-    for (Library library in resolvedLibraries) {
-      for (Source source in library.compilationUnitSources) {
-        TypeResolverVisitor visitor = new TypeResolverVisitor.con1(library, source, _typeProvider);
-        library.getAST(source).accept(visitor);
+    try {
+      for (Library library in resolvedLibraries) {
+        for (Source source in library.compilationUnitSources) {
+          TypeResolverVisitor visitor = new TypeResolverVisitor.con1(library, source, _typeProvider);
+          library.getAST(source).accept(visitor);
+        }
       }
+    } finally {
+      timeCounter.stop();
     }
-    timeCounter.stop();
   }
 
   /**
    * Compute a dependency map of libraries reachable from the given library. A dependency map is a
    * table that maps individual libraries to a list of the libraries that either import or export
    * those libraries.
    *
    * This map is used to compute all of the libraries involved in a cycle that include the root
    * library. Given that we only add libraries that are reachable from the root library, when we
    * work backward we are guaranteed to only get libraries in the cycle.
@@ skipping 193 matching lines @@
       identifiers[i] = names[i].name;
     }
     return identifiers;
   }
 
   /**
    * Compute a value for all of the constants in the libraries being analyzed.
    */
   void performConstantEvaluation() {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
-    ConstantValueComputer computer = new ConstantValueComputer();
-    for (Library library in resolvedLibraries) {
-      for (Source source in library.compilationUnitSources) {
-        try {
-          CompilationUnit unit = library.getAST(source);
-          if (unit != null) {
-            computer.add(unit);
+    try {
+      ConstantValueComputer computer = new ConstantValueComputer();
+      for (Library library in resolvedLibraries) {
+        for (Source source in library.compilationUnitSources) {
+          try {
+            CompilationUnit unit = library.getAST(source);
+            if (unit != null) {
+              computer.add(unit);
+            }
+          } on AnalysisException catch (exception) {
+            AnalysisEngine.instance.logger.logError2("Internal Error: Could not access AST for ${source.fullName} during constant evaluation", exception);
           }
-        } on AnalysisException catch (exception) {
-          AnalysisEngine.instance.logger.logError2("Internal Error: Could not access AST for ${source.fullName} during constant evaluation", exception);
         }
       }
+      computer.computeValues();
+    } finally {
+      timeCounter.stop();
     }
-    computer.computeValues();
-    timeCounter.stop();
   }
 
   /**
    * 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() {
     for (Library library in resolvedLibraries) {
       resolveReferencesAndTypes2(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
    *           the library cannot be analyzed
    */
   void resolveReferencesAndTypes2(Library library) {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
-    for (Source source in library.compilationUnitSources) {
-      ResolverVisitor visitor = new ResolverVisitor.con1(library, source, _typeProvider);
-      library.getAST(source).accept(visitor);
-      for (ProxyConditionalAnalysisError conditionalCode in visitor.proxyConditionalAnalysisErrors) {
-        if (conditionalCode.shouldIncludeErrorCode()) {
-          visitor.reportError(conditionalCode.analysisError);
+    try {
+      for (Source source in library.compilationUnitSources) {
+        ResolverVisitor visitor = new ResolverVisitor.con1(library, source, _typeProvider);
+        library.getAST(source).accept(visitor);
+        for (ProxyConditionalAnalysisError conditionalCode in visitor.proxyConditionalAnalysisErrors) {
+          if (conditionalCode.shouldIncludeErrorCode()) {
+            visitor.reportError(conditionalCode.analysisError);
+          }
         }
       }
+    } finally {
+      timeCounter.stop();
     }
-    timeCounter.stop();
   }
 
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
    * given library, or `null` if the URI is not valid.
    *
    * @param librarySource the source representing the library containing the directive
    * @param directive the directive which URI should be resolved
    * @return the result of resolving the URI against the URI of the library
    */
@@ skipping 6611 matching lines @@
       ParameterElement parameter = parameters[i];
       if (parameter.parameterKind.isOptional) {
         formalParameters.add(parameterLocations[i]);
         parameterElts.add(parameter as ParameterElementImpl);
       }
     }
     for (ParameterElement parameterElt in overriddenPEs) {
       if (parameterElt.parameterKind.isOptional) {
         if (parameterElt is ParameterElementImpl) {
           overriddenParameterElts.add(parameterElt as ParameterElementImpl);
-        } else if (parameterElt is ParameterMember) {
-          overriddenParameterElts.add(((parameterElt as ParameterMember)).baseElement as ParameterElementImpl);
         }
       }
     }
     if (parameterElts.length > 0) {
       if (identical(parameterElts[0].parameterKind, ParameterKind.NAMED)) {
         for (int i = 0; i < parameterElts.length; i++) {
           ParameterElementImpl parameterElt = parameterElts[i];
           EvaluationResultImpl result = parameterElt.evaluationResult;
           if (result == null || identical(result, ValidResult.RESULT_OBJECT)) {
             continue;
@@ skipping 3214 matching lines @@
   ResolverErrorCode.con2(String name, int ordinal, ErrorType type, String message, String correction) : super(name, ordinal) {
     this._type = type;
     this._message = message;
     this.correction9 = correction;
   }
   String get correction => correction9;
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
 }