Prepare for decoupling analyzer ASTs from element model.

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 analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/resolution_accessors.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/dart/element/visitor.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
@@ skipping 78 matching lines @@
       this._currentLibrary, this._manager,
       {TypeSystem typeSystem})
       : _nullType = typeProvider.nullType,
         _futureNullType = typeProvider.futureNullType,
         _typeSystem = typeSystem ?? new TypeSystemImpl() {
     inDeprecatedMember = _currentLibrary.isDeprecated;
   }
 
   @override
   Object visitAnnotation(Annotation node) {
-    if (node.elementAnnotation?.isFactory == true) {
+    if (elementAnnotationForAnnotation(node)?.isFactory == true) {
       AstNode parent = node.parent;
       if (parent is MethodDeclaration) {
         _checkForInvalidFactory(parent);
       } else {
         _errorReporter
             .reportErrorForNode(HintCode.INVALID_FACTORY_ANNOTATION, node, []);
       }
     }
     return super.visitAnnotation(node);
   }
@@ skipping 67 matching lines @@
   }
 
   @override
   Object visitConditionalExpression(ConditionalExpression node) {
     _checkForPossibleNullCondition(node.condition);
     return super.visitConditionalExpression(node);
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
-    if (node.element.isFactory) {
+    if (elementForConstructorDeclaration(node).isFactory) {
       if (node.body is BlockFunctionBody) {
         // Check the block for a return statement, if not, create the hint.
         if (!ExitDetector.exits(node.body)) {
           _errorReporter.reportErrorForNode(
               HintCode.MISSING_RETURN, node, [node.returnType.name]);
         }
       }
     }
     return super.visitConstructorDeclaration(node);
   }
@@ skipping 434 matching lines @@
         // or have the logic centralized elsewhere, instead of doing this logic
         // here.
         displayName = element.enclosingElement.displayName;
         if (!element.displayName.isEmpty) {
           displayName = "$displayName.${element.displayName}";
         }
       } else if (displayName == FunctionElement.CALL_METHOD_NAME &&
           node is MethodInvocation &&
           node.staticInvokeType is InterfaceType) {
         displayName =
-            "${node.staticInvokeType.displayName}.${element.displayName}";
+            "${staticInvokeTypeForInvocationExpression(node).displayName}.${element.displayName}";
       }
       _errorReporter.reportErrorForNode(
           HintCode.DEPRECATED_MEMBER_USE, node, [displayName]);
     }
   }
 
   /**
    * For [SimpleIdentifier]s, only call [checkForDeprecatedMemberUse]
    * if the node is not in a declaration context.
    *
@@ skipping 1618 matching lines @@
  * elements.
  *
  * The resulting AST must have everything resolved that would have been resolved
  * by a [DirectiveElementBuilder].
  */
 class DirectiveResolver extends SimpleAstVisitor {
   LibraryElement _enclosingLibrary;
 
   @override
   void visitCompilationUnit(CompilationUnit node) {
-    _enclosingLibrary = node.element.library;
+    _enclosingLibrary = elementForCompilationUnit(node).library;
     for (Directive directive in node.directives) {
       directive.accept(this);
     }
   }
 
   @override
   void visitExportDirective(ExportDirective node) {
     int nodeOffset = node.offset;
     node.element = null;
     for (ExportElement element in _enclosingLibrary.exports) {
@@ skipping 1286 matching lines @@
   bool _enableDart2JSHints = false;
 
   /**
    * The inheritance manager used to find overridden methods.
    */
   InheritanceManager _manager;
 
   GatherUsedLocalElementsVisitor _usedLocalElementsVisitor;
 
   HintGenerator(this._compilationUnits, this._context, this._errorListener) {
-    _library = _compilationUnits[0].element.library;
+    _library = elementForCompilationUnit(_compilationUnits[0]).library;
     _usedImportedElementsVisitor =
         new GatherUsedImportedElementsVisitor(_library);
     _enableDart2JSHints = _context.analysisOptions.dart2jsHint;
     _manager =
         new InheritanceManager(_library, includeAbstractFromSuperclasses: true);
     _usedLocalElementsVisitor = new GatherUsedLocalElementsVisitor(_library);
   }
 
   void generateForLibrary() {
     PerformanceStatistics.hints.makeCurrentWhile(() {
       int length = _compilationUnits.length;
       for (int i = 0; i < length; i++) {
         CompilationUnit unit = _compilationUnits[i];
         CompilationUnitElement element = unit.element;
         if (element != null) {
           _generateForCompilationUnit(unit, element.source);
         }
       }
       CompilationUnit definingUnit = _compilationUnits[0];
-      ErrorReporter definingUnitErrorReporter =
-          new ErrorReporter(_errorListener, definingUnit.element.source);
+      ErrorReporter definingUnitErrorReporter = new ErrorReporter(
+          _errorListener, elementForCompilationUnit(definingUnit).source);
       {
         ImportsVerifier importsVerifier = new ImportsVerifier();
         importsVerifier.addImports(definingUnit);
         importsVerifier
             .removeUsedElements(_usedImportedElementsVisitor.usedElements);
         importsVerifier.generateDuplicateImportHints(definingUnitErrorReporter);
         importsVerifier.generateUnusedImportHints(definingUnitErrorReporter);
         importsVerifier.generateUnusedShownNameHints(definingUnitErrorReporter);
       }
       _library.accept(new UnusedLocalElementsVerifier(
@@ skipping 2152 matching lines @@
     // We do not visit the label because it needs to be visited in the context
     // of the statement.
     //
     node.accept(elementResolver);
     node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
-    InferenceContext.setType(node.defaultValue, node.parameter.element?.type);
+    InferenceContext.setType(
+        node.defaultValue, elementForFormalParameter(node.parameter)?.type);
     super.visitDefaultFormalParameter(node);
     ParameterElement element = node.element;
     if (element.initializer != null && node.defaultValue != null) {
       (element.initializer as FunctionElementImpl).returnType =
           node.defaultValue.staticType;
     }
     // Clone the ASTs for default formal parameters, so that we can use them
     // during constant evaluation.
     if (!_hasSerializedConstantInitializer(element)) {
       (element as ConstVariableElement).constantInitializer =
@@ skipping 97 matching lines @@
     // We visit the iterator before the loop variable because the loop variable
     // cannot be in scope while visiting the iterator.
     //
     Expression iterable = node.iterable;
     DeclaredIdentifier loopVariable = node.loopVariable;
     SimpleIdentifier identifier = node.identifier;
     if (loopVariable?.type?.type != null) {
       InterfaceType targetType = (node.awaitKeyword == null)
           ? typeProvider.iterableType
           : typeProvider.streamType;
-      InferenceContext.setType(
-          iterable, targetType.instantiate([loopVariable.type.type]));
+      InferenceContext.setType(iterable,
+          targetType.instantiate([typeForTypeName(loopVariable.type)]));
     }
     iterable?.accept(this);
     loopVariable?.accept(this);
     identifier?.accept(this);
     Statement body = node.body;
     if (body != null) {
       _overrideManager.enterScope();
       try {
         if (loopVariable != null && iterable != null) {
           LocalVariableElement loopElement = loopVariable.element;
@@ skipping 89 matching lines @@
       _overrideManager.enterScope();
       try {
         DartType functionType = InferenceContext.getType(node);
         if (functionType is FunctionType) {
           functionType =
               matchFunctionTypeParameters(node.typeParameters, functionType);
           if (functionType is FunctionType) {
             _inferFormalParameterList(node.parameters, functionType);
 
             DartType returnType;
-            if (isFutureThen(node.staticParameterElement?.enclosingElement)) {
+            ParameterElement parameterElement =
+                staticParameterElementForExpression(node);
+            if (isFutureThen(parameterElement?.enclosingElement)) {
               var futureThenType =
                   InferenceContext.getContext(node.parent) as FunctionType;
 
               // Pretend the return type of Future<T>.then<S> first parameter is
               //
               //     T -> (S | Future<S>)
               //
               // We can't represent this in Dart so we populate it here during
               // inference.
               var typeParamS =
@@ skipping 140 matching lines @@
           //
           // For example it can infer this case:
           //
           //     class E<S, T> extends A<C<S>, T> { ... }
           //     A<C<int>, String> a0 = /*infer<int, String>*/new E("hello");
           //
           // See _inferArgumentTypesFromContext in this file for use of it.
           List<DartType> targs =
               inferenceContext.matchTypes(classTypeName.type, contextType);
           if (targs != null && targs.any((t) => !t.isDynamic)) {
-            ClassElement classElement = classTypeName.type.element;
+            ClassElement classElement = typeForTypeName(classTypeName).element;
             InterfaceType rawType = classElement.type;
             InterfaceType fullType =
                 rawType.substitute2(targs, rawType.typeArguments);
             // The element resolver uses the type on the constructor name, so
             // infer it first
             typeAnalyzer.inferConstructorName(node.constructorName, fullType);
             break;
           }
         }
       }
     }
     node.constructorName?.accept(this);
-    FunctionType constructorType = node.constructorName.staticElement?.type;
+    FunctionType constructorType =
+        staticElementForConstructorReference(node.constructorName)?.type;
     if (constructorType != null) {
       InferenceContext.setType(node.argumentList, constructorType);
     }
     node.argumentList?.accept(this);
     node.accept(elementResolver);
     node.accept(typeAnalyzer);
     return null;
   }
 
   @override
@@ skipping 138 matching lines @@
   }
 
   @override
   Object visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     //
     // We visit the argument list, but do not visit the optional identifier
     // because it needs to be visited in the context of the constructor
     // invocation.
     //
-    InferenceContext.setType(node.argumentList, node.staticElement?.type);
+    InferenceContext.setType(
+        node.argumentList, staticElementForConstructorReference(node)?.type);
     node.argumentList?.accept(this);
     node.accept(elementResolver);
     node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitReturnStatement(ReturnStatement node) {
     Expression e = node.expression;
     InferenceContext.setType(e, inferenceContext.returnContext);
@@ skipping 13 matching lines @@
   @override
   Object visitShowCombinator(ShowCombinator node) => null;
 
   @override
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     //
     // We visit the argument list, but do not visit the optional identifier
     // because it needs to be visited in the context of the constructor
     // invocation.
     //
-    InferenceContext.setType(node.argumentList, node.staticElement?.type);
+    InferenceContext.setType(
+        node.argumentList, staticElementForConstructorReference(node)?.type);
     node.argumentList?.accept(this);
     node.accept(elementResolver);
     node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitSwitchCase(SwitchCase node) {
     _overrideManager.enterScope();
     try {
@@ skipping 52 matching lines @@
         node.initializer != null) {
       (element as ConstVariableElement).constantInitializer =
           new ConstantAstCloner().cloneNode(node.initializer);
     }
     return null;
   }
 
   @override
   visitVariableDeclarationList(VariableDeclarationList node) {
     for (VariableDeclaration decl in node.variables) {
-      InferenceContext.setType(decl, decl.element?.type);
+      VariableElement variableElement = elementForVariableDeclaration(decl);
+      InferenceContext.setType(decl, variableElement?.type);
     }
     super.visitVariableDeclarationList(node);
   }
 
   @override
   Object visitWhileStatement(WhileStatement node) {
     // Note: since we don't call the base class, we have to maintain
     // _implicitLabelScope ourselves.
     ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
     try {
@@ skipping 266 matching lines @@
       return;
     }
     FunctionExpression closure = mayBeClosure as FunctionExpression;
     // prepare expected closure type
     if (mayByFunctionType is! FunctionType) {
       return;
     }
     FunctionType expectedClosureType = mayByFunctionType as FunctionType;
     // If the expectedClosureType is not more specific than the static type,
     // return.
-    DartType staticClosureType = closure.element?.type;
+    DartType staticClosureType = elementForFunctionExpression(closure)?.type;
     if (staticClosureType != null &&
         !FunctionTypeImpl.relate(
             expectedClosureType,
             staticClosureType,
             (DartType t, DartType s, _, __) =>
                 (t as TypeImpl).isMoreSpecificThan(s),
             new TypeSystemImpl().instantiateToBounds,
             returnRelation: (s, t) => true)) {
       return;
     }
@@ skipping 4004 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }