Report errors for the new top-level inference rules.

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/standard_resolution_map.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/element.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';
+import 'package:analyzer/src/summary/idl.dart';
 
 import 'ast_properties.dart';
 
 /// Given an [expression] and a corresponding [typeSystem] and [typeProvider],
 /// gets the known static type of the expression.
 ///
 /// Normally when we ask for an expression's type, we get the type of the
 /// storage slot that would contain it. For function types, this is necessarily
 /// a "fuzzy arrow" that treats `dynamic` as bottom. However, if we're
 /// interested in the expression's own type, it can often be a "strict arrow"
 /// because we know it evaluates to a specific, concrete function, and we can
 /// treat "dynamic" as top for that case, which is more permissive.
 DartType getDefiniteType(
     Expression expression, TypeSystem typeSystem, TypeProvider typeProvider) {
   DartType type = expression.staticType ?? DynamicTypeImpl.instance;
   if (typeSystem is StrongTypeSystemImpl &&
       type is FunctionType &&
       hasStrictArrow(expression)) {
     // Remove fuzzy arrow if possible.
     return typeSystem.functionTypeToConcreteType(type);
   }
   return type;
 }
 
+bool hasStrictArrow(Expression expression) {
+  var element = _getKnownElement(expression);
+  return element is FunctionElement || element is MethodElement;
+}
+
 DartType _elementType(Element e) {
   if (e == null) {
     // Malformed code - just return dynamic.
     return DynamicTypeImpl.instance;
   }
   return (e as dynamic).type;
 }
 
 Element _getKnownElement(Expression expression) {
   if (expression is ParenthesizedExpression) {
@@ skipping 35 matching lines @@
   }
   if (field.isSynthetic) return null;
   return field;
 }
 
 /// Looks up the declaration that matches [member] in [type] and returns it's
 /// declared type.
 FunctionType _getMemberType(InterfaceType type, ExecutableElement member) =>
     _memberTypeGetter(member)(type);
 
-bool hasStrictArrow(Expression expression) {
-  var element = _getKnownElement(expression);
-  return element is FunctionElement || element is MethodElement;
-}
-
 _MemberTypeGetter _memberTypeGetter(ExecutableElement member) {
   String memberName = member.name;
   final isGetter = member is PropertyAccessorElement && member.isGetter;
   final isSetter = member is PropertyAccessorElement && member.isSetter;
 
   FunctionType f(InterfaceType type) {
     ExecutableElement baseMethod;
 
     if (member.isPrivate) {
       var subtypeLibrary = member.library;
@@ skipping 305 matching lines @@
 
   @override
   void visitForStatement(ForStatement node) {
     if (node.condition != null) {
       checkBoolean(node.condition);
     }
     node.visitChildren(this);
   }
 
   @override
-  void visitFunctionExpression(FunctionExpression node) {
-    _checkForUnsafeBlockClosureInference(node);
-    super.visitFunctionExpression(node);
-  }
-
-  @override
   void visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     checkFunctionApplication(node);
     node.visitChildren(this);
   }
 
   @override
   void visitIfStatement(IfStatement node) {
     checkBoolean(node.condition);
     node.visitChildren(this);
   }
@@ skipping 191 matching lines @@
         : resolutionMap.elementDeclaredByVariableDeclaration(node);
     if (!node.isConst &&
         !node.isFinal &&
         node.initializer == null &&
         rules.isNonNullableType(variableElement?.type)) {
       _recordMessage(
           node,
           StaticTypeWarningCode.NON_NULLABLE_FIELD_NOT_INITIALIZED,
           [node.name, variableElement?.type]);
     }
+    AstNode parent = node.parent;
+    if (variableElement != null &&
+        parent is VariableDeclarationList &&
+        parent.type == null &&
+        node.initializer != null) {
+      if (variableElement.kind == ElementKind.TOP_LEVEL_VARIABLE ||
+          variableElement.kind == ElementKind.FIELD) {
+        _validateTopLevelInitializer(variableElement.name, node.initializer);
+      }
+    }
     return super.visitVariableDeclaration(node);
   }
 
   @override
   void visitVariableDeclarationList(VariableDeclarationList node) {
     TypeAnnotation 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
       // based on the initializer.
@@ skipping 59 matching lines @@
   }
 
   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 (resolutionMap
-        .elementDeclaredByFunctionExpression(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.
-        return;
-      }
-      if (ancestor is InstanceCreationExpression) {
-        // node appears inside an instance creation expression; we may be safe
-        // if the type of the instance creation expression requires no
-        // inference.
-        TypeName typeName = ancestor.constructorName.type;
-        if (typeName.typeArguments != null) {
-          // Type arguments were explicitly specified.  We are safe.
-          return;
-        }
-        DartType type = typeName.type;
-        if (!(type is ParameterizedType && type.typeParameters.isNotEmpty)) {
-          // Type is not generic.  We are safe.
-          return;
-        }
-      }
-      if (ancestor is MethodInvocation) {
-        // node appears inside a method or function invocation; we may be safe
-        // if the type of the method or function requires no inference.
-        if (ancestor.typeArguments != null) {
-          // Type arguments were explicitly specified.  We are safe.
-          return;
-        }
-        Element methodElement = ancestor.methodName.staticElement;
-        if (!(methodElement is ExecutableElement &&
-            methodElement.typeParameters.isNotEmpty)) {
-          // Method is not generic.  We are safe.
-          return;
-        }
-      }
-      if (ancestor is FunctionExpressionInvocation &&
-          !identical(prevAncestor, ancestor.function)) {
-        // node appears inside an argument to a function expression invocation;
-        // we may be safe if the type of the function expression requires no
-        // inference.
-        if (ancestor.typeArguments != null) {
-          // Type arguments were explicitly specified.  We are safe.
-          return;
-        }
-        DartType type = ancestor.function.staticType;
-        if (!(type is FunctionTypeImpl && type.typeFormals.isNotEmpty)) {
-          // Type is not generic or has had its type parameters instantiated.
-          // We are safe.
-          return;
-        }
-      }
-      if ((ancestor is ListLiteral && ancestor.typeArguments != null) ||
-          (ancestor is MapLiteral && ancestor.typeArguments != null)) {
-        // node appears inside a list or map literal with an explicit type.  We
-        // are safe because no type inference is required.
-        return;
-      }
-      prevAncestor = ancestor;
-      ancestor = ancestor.parent;
-    }
-    if (ancestor == null) {
-      // node is not inside a variable declaration, so it is safe.
-      return;
-    }
-    VariableDeclaration decl = ancestor;
-    VariableElement declElement = decl.element;
-    if (!declElement.hasImplicitType) {
-      // Variable declaration has an explicit type, so it's safe.
-      return;
-    }
-    if (declElement.type.isDynamic) {
-      // No type was successfully inferred for this variable, so it's safe.
-      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);
@@ skipping 303 matching lines @@
           : node.offset;
       int length = node.end - begin;
       var source = resolutionMap
           .elementDeclaredByCompilationUnit(node.root as CompilationUnit)
           .source;
       var error =
           new AnalysisError(source, begin, length, errorCode, arguments);
       reporter.onError(error);
     }
   }
+
+  void _validateTopLevelInitializer(String name, Expression n) {
+    void validateHasType(PropertyAccessorElement e) {
+      if (e.hasImplicitReturnType) {
+        var variable = e.variable as VariableElementImpl;
+        TopLevelInferenceError error = variable.typeInferenceError;
+        if (error != null) {
+          if (error.kind == TopLevelInferenceErrorKind.dependencyCycle) {
+            _recordMessage(
+                n, StrongModeCode.TOP_LEVEL_CYCLE, [name, error.arguments]);
+          } else {
+            _recordMessage(
+                n, StrongModeCode.TOP_LEVEL_IDENTIFIER_NO_TYPE, [name, e.name]);
+          }
+        }
+      }
+    }
+
+    void validateIdentifierElement(AstNode n, Element e) {
+      if (e == null) {
+        return;
+      }
+
+      Element enclosing = e.enclosingElement;
+      if (enclosing is CompilationUnitElement) {
+        if (e is PropertyAccessorElement) {
+          validateHasType(e);
+        }
+      } else if (enclosing is ClassElement) {
+        if (e is PropertyAccessorElement) {
+          if (e.isStatic) {
+            validateHasType(e);
+          } else {
+            _recordMessage(
+                n, StrongModeCode.TOP_LEVEL_INSTANCE_GETTER, [name, e.name]);
+          }
+        }
+      }
+    }
+
+    if (n == null ||
+        n is NullLiteral ||
+        n is BooleanLiteral ||
+        n is DoubleLiteral ||
+        n is IntegerLiteral ||
+        n is StringLiteral ||
+        n is SymbolLiteral) {
+      // Nothing to validate.
+    } else if (n is AwaitExpression) {
+      _validateTopLevelInitializer(name, n.expression);
+    } else if (n is ThrowExpression) {
+      // Nothing to validate.
+    } else if (n is ParenthesizedExpression) {
+      _validateTopLevelInitializer(name, n.expression);
+    } else if (n is ConditionalExpression) {
+      _validateTopLevelInitializer(name, n.thenExpression);
+      _validateTopLevelInitializer(name, n.elseExpression);
+    } else if (n is BinaryExpression) {
+      TokenType operator = n.operator.type;
+      if (operator == TokenType.AMPERSAND_AMPERSAND ||
+          operator == TokenType.BAR_BAR ||
+          operator == TokenType.EQ_EQ ||
+          operator == TokenType.BANG_EQ) {
+        // These operators give 'bool', no need to validate operands.
+      } else if (operator == TokenType.QUESTION_QUESTION) {
+        _recordMessage(n, StrongModeCode.TOP_LEVEL_UNSUPPORTED,
+            [name, n.runtimeType.toString()]);
+      } else {
+        _validateTopLevelInitializer(name, n.leftOperand);
+      }
+    } else if (n is PrefixExpression) {
+      TokenType operator = n.operator.type;
+      if (operator == TokenType.BANG) {
+        // This operator gives 'bool', no need to validate operands.
+      } else {
+        _validateTopLevelInitializer(name, n.operand);
+      }
+    } else if (n is PostfixExpression) {
+      _validateTopLevelInitializer(name, n.operand);
+    } else if (n is ListLiteral) {
+      if (n.typeArguments == null) {
+        for (Expression element in n.elements) {
+          _validateTopLevelInitializer(name, element);
+        }
+      }
+    } else if (n is MapLiteral) {
+      if (n.typeArguments == null) {
+        for (MapLiteralEntry entry in n.entries) {
+          _validateTopLevelInitializer(name, entry.key);
+          _validateTopLevelInitializer(name, entry.value);
+        }
+      }
+    } else if (n is FunctionExpression) {
+      for (FormalParameter p in n.parameters.parameters) {
+        if (p is DefaultFormalParameter) {
+          p = (p as DefaultFormalParameter).parameter;
+        }
+        if (p is SimpleFormalParameter) {
+          if (p.type == null) {
+            _recordMessage(
+                p,
+                StrongModeCode.TOP_LEVEL_FUNCTION_LITERAL_PARAMETER,
+                [name, p.element?.name]);
+          }
+        }
+      }
+
+      FunctionBody body = n.body;
+      if (body is ExpressionFunctionBody) {
+        _validateTopLevelInitializer(name, body.expression);
+      } else {
+        _recordMessage(n, StrongModeCode.TOP_LEVEL_FUNCTION_LITERAL_BLOCK, []);
+      }
+    } else if (n is InstanceCreationExpression) {
+      ConstructorElement constructor = n.staticElement;
+      ClassElement clazz = constructor?.enclosingElement;
+      if (clazz != null && clazz.typeParameters.isNotEmpty) {
+        TypeName type = n.constructorName.type;
+        if (type.typeArguments == null) {
+          _recordMessage(type, StrongModeCode.TOP_LEVEL_TYPE_ARGUMENTS,
+              [name, clazz.name]);
+        }
+      }
+    } else if (n is AsExpression) {
+      // Nothing to validate.
+    } else if (n is IsExpression) {
+      // Nothing to validate.
+    } else if (n is Identifier) {
+      validateIdentifierElement(n, n.staticElement);
+    } else if (n is PropertyAccess) {
+      Element element = n.propertyName.staticElement;
+      validateIdentifierElement(n.propertyName, element);
+    } else if (n is FunctionExpressionInvocation) {
+      _validateTopLevelInitializer(name, n.function);
+      // TODO(scheglov) type arguments
+    } else if (n is MethodInvocation) {
+      _validateTopLevelInitializer(name, n.target);
+      SimpleIdentifier methodName = n.methodName;
+      Element element = methodName.staticElement;
+      if (element is ExecutableElement && element.typeParameters.isNotEmpty) {
+        if (n.typeArguments == null) {
+          _recordMessage(methodName, StrongModeCode.TOP_LEVEL_TYPE_ARGUMENTS,
+              [name, methodName.name]);
+        }
+      }
+    } else if (n is CascadeExpression) {
+      _validateTopLevelInitializer(name, n.target);
+    } else {
+      _recordMessage(n, StrongModeCode.TOP_LEVEL_UNSUPPORTED,
+          [name, n.runtimeType.toString()]);
+    }
+  }
 }
 
 /// 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)
@@ skipping 331 matching lines @@
     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));
   }
 }