Prepare for decoupling analyzer ASTs from element model.

pkg/analyzer/lib/src/task/strong/checker.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.
 
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/resolution_accessors.dart';
 import 'package:analyzer/dart/ast/token.dart' show TokenType;
 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/src/dart/element/type.dart';
 import 'package:analyzer/src/error/codes.dart' show StrongModeCode;
 import 'package:analyzer/src/generated/engine.dart' show AnalysisOptionsImpl;
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/type_system.dart';
@@ skipping 574 matching lines @@
   }
 
   @override
   void visitPropertyAccess(PropertyAccess node) {
     _checkFieldAccess(node, node.realTarget, node.propertyName);
   }
 
   @override
   void visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
-    var type = node.staticElement?.type;
+    var type = staticElementForConstructorReference(node)?.type;
     // TODO(leafp): There's a TODO in visitRedirectingConstructorInvocation
     // in the element_resolver to handle the case that the element is null
     // and emit an error.  In the meantime, just be defensive here.
     if (type != null) {
       checkArgumentList(node.argumentList, type);
     }
     node.visitChildren(this);
   }
 
   @override
   void visitReturnStatement(ReturnStatement node) {
     _checkReturnOrYield(node.expression, node);
     node.visitChildren(this);
   }
 
   @override
   void visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     var element = node.staticElement;
     if (element != null) {
-      var type = node.staticElement.type;
+      var type = staticElementForConstructorReference(node).type;
       checkArgumentList(node.argumentList, type);
     }
     node.visitChildren(this);
   }
 
   @override
   void visitSwitchStatement(SwitchStatement node) {
     // SwitchStatement defines a boolean conversion to check the result of the
     // case value == the switch value, but in dev_compiler we require a boolean
     // return type from an overridden == operator (because Object.==), so
     // checking in SwitchStatement shouldn't be necessary.
     node.visitChildren(this);
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
+    VariableElement variableElement =
+        node == null ? null : elementForVariableDeclaration(node);
     if (!node.isConst &&
         !node.isFinal &&
         node.initializer == null &&
-        rules.isNonNullableType(node?.element?.type)) {
+        rules.isNonNullableType(variableElement?.type)) {
       _recordMessage(
           node,
           StaticTypeWarningCode.NON_NULLABLE_FIELD_NOT_INITIALIZED,
-          [node.name, node?.element?.type]);
+          [node.name, variableElement?.type]);
     }
     return super.visitVariableDeclaration(node);
   }
 
   @override
   void visitVariableDeclarationList(VariableDeclarationList node) {
     TypeName type = node.type;
     if (type == null) {
       // No checks are needed when the type is var. Although internally the
       // typing rules may have inferred a more precise type for the variable
@@ skipping 17 matching lines @@
 
   @override
   void visitYieldStatement(YieldStatement node) {
     _checkReturnOrYield(node.expression, node, yieldStar: node.star != null);
     node.visitChildren(this);
   }
 
   void _checkCompoundAssignment(AssignmentExpression expr) {
     var op = expr.operator.type;
     assert(op.isAssignmentOperator && op != TokenType.EQ);
-    var methodElement = expr.staticElement;
+    var methodElement = staticElementForMethodReference(expr);
     if (methodElement == null) {
       // Dynamic invocation.
       _recordDynamicInvoke(expr, expr.leftHandSide);
     } else {
       // Sanity check the operator.
       assert(methodElement.isOperator);
       var functionType = methodElement.type;
       var paramTypes = functionType.normalParameterTypes;
       assert(paramTypes.length == 1);
       assert(functionType.namedParameterTypes.isEmpty);
@@ skipping 14 matching lines @@
       // back to it. So these two implicit casts are equivalent:
       //
       //     y = /*implicit cast*/(y + 42);
       //     /*implicit assignment cast*/y += 42;
       //
       _checkImplicitCast(expr.leftHandSide, lhsType,
           from: returnType, opAssign: true);
     }
   }
 
-  /// Returns true if we need an implicit cast of [expr] from [from] type to
-  /// [to] type, otherwise returns false.
-  ///
-  /// If [from] is omitted, uses the static type of [expr].
-  bool _needsImplicitCast(Expression expr, DartType to, {DartType from}) {
-    from ??= _getDefiniteType(expr);
-
-    if (!_checkNonNullAssignment(expr, to, from)) return false;
-
-    // We can use anything as void.
-    if (to.isVoid) return false;
-
-    // fromT <: toT, no coercion needed.
-    if (rules.isSubtypeOf(from, to)) return false;
-
-    // Note: a function type is never assignable to a class per the Dart
-    // spec - even if it has a compatible call method.  We disallow as
-    // well for consistency.
-    if (from is FunctionType && rules.getCallMethodType(to) != null) {
-      return false;
-    }
-
-    // Downcast if toT <: fromT
-    if (rules.isSubtypeOf(to, from)) {
-      return true;
-    }
-
-    // Anything else is an illegal sideways cast.
-    // However, these will have been reported already in error_verifier, so we
-    // don't need to report them again.
-    return false;
-  }
-
-  /// Checks if an implicit cast of [expr] from [from] type to [to] type is
-  /// needed, and if so records it.
-  ///
-  /// If [from] is omitted, uses the static type of [expr].
-  ///
-  /// If [expr] does not require an implicit cast because it is not related to
-  /// [to] or is already a subtype of it, does nothing.
-  void _checkImplicitCast(Expression expr, DartType to,
-      {DartType from, bool opAssign: false}) {
-    from ??= _getDefiniteType(expr);
-
-    if (_needsImplicitCast(expr, to, from: from)) {
-      _recordImplicitCast(expr, to, from: from, opAssign: opAssign);
-    }
-  }
-
   void _checkFieldAccess(AstNode node, AstNode target, SimpleIdentifier field) {
     if (field.staticElement == null &&
         !typeProvider.isObjectMember(field.name)) {
       _recordDynamicInvoke(node, target);
     }
     node.visitChildren(this);
   }
 
   /**
    * Check if the closure [node] is unsafe due to dartbug.com/26947.  If so,
    * issue a warning.
    *
    * TODO(paulberry): eliminate this once dartbug.com/26947 is fixed.
    */
   void _checkForUnsafeBlockClosureInference(FunctionExpression node) {
     if (node.body is! BlockFunctionBody) {
       return;
     }
-    if (node.element.returnType.isDynamic) {
+    if (elementForFunctionExpression(node).returnType.isDynamic) {
       return;
     }
     // Find the enclosing variable declaration whose inferred type might depend
     // on the inferred return type of the block closure (if any).
     AstNode prevAncestor = node;
     AstNode ancestor = node.parent;
     while (ancestor != null && ancestor is! VariableDeclaration) {
       if (ancestor is BlockFunctionBody) {
         // node is inside another block function body; if that block
         // function body is unsafe, we've already warned about it.
@@ skipping 68 matching lines @@
       return;
     }
     if (declElement.enclosingElement is ExecutableElement) {
       // Variable declaration is inside a function or method, so it's safe.
       return;
     }
     _recordMessage(node, StrongModeCode.UNSAFE_BLOCK_CLOSURE_INFERENCE,
         [declElement.name]);
   }
 
+  /// Checks if an implicit cast of [expr] from [from] type to [to] type is
+  /// needed, and if so records it.
+  ///
+  /// If [from] is omitted, uses the static type of [expr].
+  ///
+  /// If [expr] does not require an implicit cast because it is not related to
+  /// [to] or is already a subtype of it, does nothing.
+  void _checkImplicitCast(Expression expr, DartType to,
+      {DartType from, bool opAssign: false}) {
+    from ??= _getDefiniteType(expr);
+
+    if (_needsImplicitCast(expr, to, from: from)) {
+      _recordImplicitCast(expr, to, from: from, opAssign: opAssign);
+    }
+  }
+
   /// Checks if the assignment is valid with respect to non-nullable types.
   /// Returns `false` if a nullable expression is assigned to a variable of
   /// non-nullable type and `true` otherwise.
   bool _checkNonNullAssignment(
       Expression expression, DartType to, DartType from) {
     if (rules.isNonNullableType(to) && rules.isNullableType(from)) {
       _recordMessage(
           expression, StaticTypeWarningCode.INVALID_ASSIGNMENT, [from, to]);
       return false;
     }
@@ skipping 139 matching lines @@
     // Dynamic as the parameter type is treated as bottom.  A function with
     // a dynamic parameter type requires a dynamic call in general.
     // However, as an optimization, if we have an original definition, we know
     // dynamic is reified as Object - in this case a regular call is fine.
     if (_hasStrictArrow(call.function)) {
       return false;
     }
     return rules.anyParameterType(ft, (pt) => pt.isDynamic);
   }
 
+  /// Returns true if we need an implicit cast of [expr] from [from] type to
+  /// [to] type, otherwise returns false.
+  ///
+  /// If [from] is omitted, uses the static type of [expr].
+  bool _needsImplicitCast(Expression expr, DartType to, {DartType from}) {
+    from ??= _getDefiniteType(expr);
+
+    if (!_checkNonNullAssignment(expr, to, from)) return false;
+
+    // We can use anything as void.
+    if (to.isVoid) return false;
+
+    // fromT <: toT, no coercion needed.
+    if (rules.isSubtypeOf(from, to)) return false;
+
+    // Note: a function type is never assignable to a class per the Dart
+    // spec - even if it has a compatible call method.  We disallow as
+    // well for consistency.
+    if (from is FunctionType && rules.getCallMethodType(to) != null) {
+      return false;
+    }
+
+    // Downcast if toT <: fromT
+    if (rules.isSubtypeOf(to, from)) {
+      return true;
+    }
+
+    // Anything else is an illegal sideways cast.
+    // However, these will have been reported already in error_verifier, so we
+    // don't need to report them again.
+    return false;
+  }
+
   void _recordDynamicInvoke(AstNode node, Expression target) {
     _recordMessage(node, StrongModeCode.DYNAMIC_INVOKE, [node]);
     // TODO(jmesserly): we may eventually want to record if the whole operation
     // (node) was dynamic, rather than the target, but this is an easier fit
     // with what we used to do.
     if (target != null) setIsDynamicInvoke(target, true);
   }
 
   /// Records an implicit cast for the [expr] from [from] to [to].
   ///
@@ skipping 87 matching lines @@
   }
 
   void _recordMessage(AstNode node, ErrorCode errorCode, List arguments) {
     var severity = errorCode.errorSeverity;
     if (severity == ErrorSeverity.ERROR) _failure = true;
     if (severity != ErrorSeverity.INFO || _options.strongModeHints) {
       int begin = node is AnnotatedNode
           ? node.firstTokenAfterCommentAndMetadata.offset
           : node.offset;
       int length = node.end - begin;
-      var source = (node.root as CompilationUnit).element.source;
+      var source =
+          elementForCompilationUnit(node.root as CompilationUnit).source;
       var error =
           new AnalysisError(source, begin, length, errorCode, arguments);
       reporter.onError(error);
     }
   }
 }
 
 /// Checks for overriding declarations of fields and methods. This is used to
 /// check overrides between classes and superclasses, interfaces, and mixin
 /// applications.
 class _OverrideChecker {
   final StrongTypeSystemImpl rules;
   final CodeChecker _checker;
 
   _OverrideChecker(CodeChecker checker)
       : _checker = checker,
         rules = checker.rules;
 
   void check(ClassDeclaration node) {
-    if (node.element.type.isObject) return;
+    if (elementForClassDeclaration(node).type.isObject) return;
     _checkSuperOverrides(node);
     _checkMixinApplicationOverrides(node);
     _checkAllInterfaceOverrides(node);
   }
 
   /// Checks that implementations correctly override all reachable interfaces.
   /// In particular, we need to check these overrides for the definitions in
   /// the class itself and each its superclasses. If a superclass is not
   /// abstract, then we can skip its transitive interfaces. For example, in:
   ///
@@ skipping 15 matching lines @@
       if (result.contains(interfaceType)) return;
       result.add(interfaceType);
       find(interfaceType.superclass, result);
       interfaceType.mixins.forEach((i) => find(i, result));
       interfaceType.interfaces.forEach((i) => find(i, result));
     }
 
     // Check all interfaces reachable from the `implements` clause in the
     // current class against definitions here and in superclasses.
     var localInterfaces = new Set<InterfaceType>();
-    var type = node.element.type;
+    var type = elementForClassDeclaration(node).type;
     type.interfaces.forEach((i) => find(i, localInterfaces));
     _checkInterfacesOverrides(node, localInterfaces, seen,
         includeParents: true);
 
     // Check also how we override locally the interfaces from parent classes if
     // the parent class is abstract. Otherwise, these will be checked as
     // overrides on the concrete superclass.
     var superInterfaces = new Set<InterfaceType>();
     var parent = type.superclass;
     // TODO(sigmund): we don't seem to be reporting the analyzer error that a
@@ skipping 36 matching lines @@
             found = true;
           }
           if (found) {
             seen.add(name);
           }
         }
       } else if (member is MethodDeclaration) {
         if (member.isStatic) {
           continue;
         }
-        var method = member.element;
+        var method = elementForMethodDeclaration(member);
         if (seen.contains(method.name)) {
           continue;
         }
         if (_checkSingleOverride(
             method, baseType, member.name, member, isSubclass)) {
           seen.add(method.name);
         }
       } else {
         assert(member is ConstructorDeclaration);
       }
@@ skipping 35 matching lines @@
   ///
   /// [cls] can be either a [ClassDeclaration] or a [InterfaceType]. For
   /// [ClassDeclaration]s errors are reported on the member that contains the
   /// invalid override, for [InterfaceType]s we use [errorLocation] instead.
   void _checkInterfacesOverrides(
       cls, Iterable<InterfaceType> interfaces, Set<String> seen,
       {Set<InterfaceType> visited,
       bool includeParents: true,
       AstNode errorLocation}) {
     var node = cls is ClassDeclaration ? cls : null;
-    var type = cls is InterfaceType ? cls : node.element.type;
+    var type =
+        cls is InterfaceType ? cls : elementForClassDeclaration(node).type;
 
     if (visited == null) {
       visited = new Set<InterfaceType>();
     } else if (visited.contains(type)) {
       // Malformed type.
       return;
     } else {
       visited.add(type);
     }
 
@@ skipping 34 matching lines @@
 
   /// Check overrides from mixin applications themselves. For example, in:
   ///
   ///      A extends B with E, F
   ///
   ///  we check:
   ///
   ///      B & E against B (equivalently how E overrides B)
   ///      B & E & F against B & E (equivalently how F overrides both B and E)
   void _checkMixinApplicationOverrides(ClassDeclaration node) {
-    var type = node.element.type;
+    var type = elementForClassDeclaration(node).type;
     var parent = type.superclass;
     var mixins = type.mixins;
 
     // Check overrides from applying mixins
     for (int i = 0; i < mixins.length; i++) {
       var seen = new Set<String>();
       var current = mixins[i];
       var errorLocation = node.withClause.mixinTypes[i];
       for (int j = i - 1; j >= 0; j--) {
         _checkIndividualOverridesFromType(
@@ skipping 98 matching lines @@
   ///         m(A a) {}
   ///     }
   ///     class Parent extends Grandparent {
   ///         m(A a) {}
   ///     }
   ///     class Test extends Parent {
   ///         m(B a) {} // invalid override
   ///     }
   void _checkSuperOverrides(ClassDeclaration node) {
     var seen = new Set<String>();
-    var current = node.element.type;
+    var current = elementForClassDeclaration(node).type;
     var visited = new Set<InterfaceType>();
     do {
       visited.add(current);
       current.mixins.reversed.forEach(
           (m) => _checkIndividualOverridesFromClass(node, m, seen, true));
       _checkIndividualOverridesFromClass(node, current.superclass, seen, true);
       current = current.superclass;
     } while (!current.isObject && !visited.contains(current));
   }
 }