Prepare for decoupling analyzer ASTs from element model.

pkg/analyzer/lib/src/generated/error_verifier.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.error_verifier;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 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/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/dart/element/type.dart';
@@ skipping 829 matching lines @@
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     bool old = _isInFunctionTypedFormalParameter;
     _isInFunctionTypedFormalParameter = true;
     try {
       _checkForTypeAnnotationDeferredClass(node.returnType);
 
       // TODO(jmesserly): ideally we'd use _checkForImplicitDynamicReturn, and
       // we can get the function element via `node?.element?.type?.element` but
       // it doesn't have hasImplicitReturnType set correctly.
       if (!_options.implicitDynamic && node.returnType == null) {
-        DartType parameterType = node.element.type;
+        DartType parameterType = elementForFormalParameter(node).type;
         if (parameterType is FunctionType &&
             parameterType.returnType.isDynamic) {
           _errorReporter.reportErrorForNode(
               StrongModeCode.IMPLICIT_DYNAMIC_RETURN, node, [node.identifier]);
         }
       }
       return super.visitFunctionTypedFormalParameter(node);
     } finally {
       _isInFunctionTypedFormalParameter = old;
     }
@@ skipping 1360 matching lines @@
             : StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR);
         _errorReporter.reportErrorForNode(errorCode, redirectedConstructor,
             [constructorStrName, redirectedType.displayName]);
       }
       return;
     }
     FunctionType redirectedType = redirectedElement.type;
     DartType redirectedReturnType = redirectedType.returnType;
 
     // Report specific problem when return type is incompatible
-    FunctionType constructorType = declaration.element.type;
+    FunctionType constructorType =
+        elementForConstructorDeclaration(declaration).type;
     DartType constructorReturnType = constructorType.returnType;
     if (!_typeSystem.isAssignableTo(
         redirectedReturnType, constructorReturnType)) {
       _errorReporter.reportErrorForNode(
           StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE,
           redirectedConstructor,
           [redirectedReturnType, constructorReturnType]);
       return;
     } else if (!_typeSystem.isSubtypeOf(redirectedType, constructorType)) {
       // Check parameters.
@@ skipping 634 matching lines @@
         bool isMethod = !isGetter && !isSetter && !isOperator;
         // Do lookups in the enclosing class (and the inherited member) if the
         // member is a method or a setter for
         // StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER warning.
         if (isMethod) {
           String setterName = "${name.name}=";
           Element enclosingElementOfSetter = null;
           ClassMember conflictingSetter = memberHashMap[setterName];
           if (conflictingSetter != null) {
             enclosingElementOfSetter =
-                conflictingSetter.element.enclosingElement;
+                elementForDeclaration(conflictingSetter).enclosingElement;
           } else {
             ExecutableElement elementFromInheritance = _inheritanceManager
                 .lookupInheritance(_enclosingClass, setterName);
             if (elementFromInheritance != null) {
               enclosingElementOfSetter =
                   elementFromInheritance.enclosingElement;
             }
           }
           if (enclosingElementOfSetter != null) {
             _errorReporter.reportErrorForNode(
@@ skipping 1819 matching lines @@
         _errorReporter.reportErrorForOffset(
             StaticWarningCode.MISSING_ENUM_CONSTANT_IN_SWITCH,
             offset,
             end - offset,
             [constantNames[i]]);
       }
     }
   }
 
   void _checkForMissingJSLibAnnotation(Annotation node) {
-    if (node.elementAnnotation?.isJS ?? false) {
+    if (elementAnnotationForAnnotation(node)?.isJS ?? false) {
       if (_currentLibrary.isJS != true) {
         _errorReporter.reportErrorForNode(
             HintCode.MISSING_JS_LIB_ANNOTATION, node);
       }
     }
   }
 
   /**
    * Verify that the given function [body] does not contain return statements
    * that both have and do not have return values.
@@ skipping 2144 matching lines @@
     _checkForMissingRequiredParam(
         node.staticInvokeType, node.argumentList, node);
     return super.visitFunctionExpressionInvocation(node);
   }
 
   @override
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     DartType type = node.constructorName.type.type;
     if (type is InterfaceType) {
       _checkForMissingRequiredParam(
-          node.staticElement?.type, node.argumentList, node.constructorName);
+          staticElementForConstructorReference(node)?.type,
+          node.argumentList,
+          node.constructorName);
     }
     return super.visitInstanceCreationExpression(node);
   }
 
   @override
   Object visitMethodInvocation(MethodInvocation node) {
     _checkForMissingRequiredParam(
         node.staticInvokeType, node.argumentList, node.methodName);
     return super.visitMethodInvocation(node);
   }
 
   @override
   Object visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
-    DartType type = node.staticElement?.type;
+    DartType type = staticElementForConstructorReference(node)?.type;
     if (type != null) {
       _checkForMissingRequiredParam(type, node.argumentList, node);
     }
     return super.visitRedirectingConstructorInvocation(node);
   }
 
   @override
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
-    DartType type = node.staticElement?.type;
+    DartType type = staticElementForConstructorReference(node)?.type;
     if (type != null) {
       _checkForMissingRequiredParam(type, node.argumentList, node);
     }
     return super.visitSuperConstructorInvocation(node);
   }
 
   void _checkForMissingRequiredParam(
       DartType type, ArgumentList argumentList, AstNode node) {
     if (type is FunctionType) {
       for (ParameterElement parameter in type.parameters) {
@@ skipping 36 matching lines @@
 class _InvocationCollector extends RecursiveAstVisitor {
   final List<String> superCalls = <String>[];
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     if (node.target is SuperExpression) {
       superCalls.add(node.methodName.name);
     }
   }
 }