Handle fuzzy optional parameters correctly.

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/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/src/dart/ast/token.dart';
 import 'package:analyzer/src/dart/ast/utilities.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';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element_resolver.dart';
+import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk, SdkLibrary;
 import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:analyzer/src/task/strong/info.dart' show StaticInfo;
 
 /**
  * A visitor used to traverse an AST structure looking for additional errors and
  * warnings not covered by the parser and resolver.
  */
 class ErrorVerifier extends RecursiveAstVisitor<Object> {
   /**
    * Static final string with value `"getter "` used in the construction of the
    * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE], and
    * similar, error code messages.
@@ skipping 25 matching lines @@
    * The type representing the type 'bool'.
    */
   InterfaceType _boolType;
 
   /**
    * The type representing the type 'int'.
    */
   InterfaceType _intType;
 
   /**
+   * The options for verification.
+   */
+  AnalysisOptions _options;
+
+  /**
    * The object providing access to the types defined by the language.
    */
   final TypeProvider _typeProvider;
 
   /**
    * The type system primitives
    */
   TypeSystem _typeSystem;
 
   /**
@@ skipping 209 matching lines @@
     _isInCatchClause = false;
     _isInStaticVariableDeclaration = false;
     _isInInstanceVariableDeclaration = false;
     _isInInstanceVariableInitializer = false;
     _isInConstructorInitializer = false;
     _isInStaticMethod = false;
     _boolType = _typeProvider.boolType;
     _intType = _typeProvider.intType;
     _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT = _typeProvider.nonSubtypableTypes;
     _typeSystem = _currentLibrary.context.typeSystem;
+    _options = _currentLibrary.context.analysisOptions;
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     _checkForInvalidAnnotationFromDeferredLibrary(node);
     _checkForMissingJSLibAnnotation(node);
     return super.visitAnnotation(node);
   }
 
   @override
@@ skipping 1687 matching lines @@
    * [CompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE], and
    * [StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE].
    */
   void _checkForArgumentTypeNotAssignable(
       Expression expression,
       DartType expectedStaticType,
       DartType actualStaticType,
       ErrorCode errorCode) {
     // Warning case: test static type information
-    if (actualStaticType != null &&
-        expectedStaticType != null &&
-        !_typeSystem.isAssignableTo(actualStaticType, expectedStaticType)) {
-      _errorReporter.reportTypeErrorForNode(
-          errorCode, expression, [actualStaticType, expectedStaticType]);
+    if (actualStaticType != null && expectedStaticType != null) {
+      _checkForAssignableExpressionAtType(
+          expression, actualStaticType, expectedStaticType, errorCode);
     }
   }
 
   /**
    * Verify that the given [argument] can be assigned to its corresponding
    * parameter.
    *
    * This method corresponds to
    * [BestPracticesVerifier.checkForArgumentTypeNotAssignableForArgument].
    *
@@ skipping 59 matching lines @@
    */
   void _checkForAssignability(Expression expression, InterfaceType type,
       ErrorCode errorCode, List<Object> arguments) {
     if (expression == null) {
       return;
     }
     DartType expressionType = expression.staticType;
     if (expressionType == null) {
       return;
     }
-    if (_typeSystem.isAssignableTo(expressionType, type)) {
+    if (_expressionIsAssignableAtType(expression, expressionType, type)) {
       return;
     }
     _errorReporter.reportErrorForNode(errorCode, expression, arguments);
   }
 
+  bool _checkForAssignableExpression(
+      Expression expression, DartType expectedStaticType, ErrorCode errorCode) {
+    DartType actualStaticType = getStaticType(expression);
+    return actualStaticType != null &&
+        _checkForAssignableExpressionAtType(
+            expression, actualStaticType, expectedStaticType, errorCode);
+  }
+
+  bool _checkForAssignableExpressionAtType(
+      Expression expression,
+      DartType actualStaticType,
+      DartType expectedStaticType,
+      ErrorCode errorCode) {
+    // TODO(leafp): Move the Downcast functionality here.
+    // TODO(leafp): Support strict downcasts
+    if (!_expressionIsAssignableAtType(
+        expression, actualStaticType, expectedStaticType)) {
+      _errorReporter.reportTypeErrorForNode(
+          errorCode, expression, [actualStaticType, expectedStaticType]);
+      return false;
+    }
+    return true;
+  }
+
   /**
    * Verify that the given [expression] is not final.
    *
    * See [StaticWarningCode.ASSIGNMENT_TO_CONST],
    * [StaticWarningCode.ASSIGNMENT_TO_FINAL], and
    * [StaticWarningCode.ASSIGNMENT_TO_METHOD].
    */
   void _checkForAssignmentToFinal(Expression expression) {
     // prepare element
     Element element = null;
@@ skipping 1166 matching lines @@
     // prepare expression type
     Expression expression = initializer.expression;
     if (expression == null) {
       return;
     }
     // test the static type of the expression
     DartType staticType = getStaticType(expression);
     if (staticType == null) {
       return;
     }
-    if (_typeSystem.isAssignableTo(staticType, fieldType)) {
+    if (_expressionIsAssignableAtType(expression, staticType, fieldType)) {
       return;
     }
     // report problem
     if (_isEnclosingConstructorConst) {
       // TODO(paulberry): this error should be based on the actual type of the
       // constant, not the static type.  See dartbug.com/21119.
       _errorReporter.reportTypeErrorForNode(
           CheckedModeCompileTimeErrorCode
               .CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE,
           expression,
@@ skipping 547 matching lines @@
    * See [StaticTypeWarningCode.INVALID_ASSIGNMENT].
    */
   void _checkForInvalidAssignment(Expression lhs, Expression rhs) {
     if (lhs == null || rhs == null) {
       return;
     }
     VariableElement leftVariableElement = getVariableElement(lhs);
     DartType leftType = (leftVariableElement == null)
         ? getStaticType(lhs)
         : leftVariableElement.type;
-    DartType staticRightType = getStaticType(rhs);
-    if (!_typeSystem.isAssignableTo(staticRightType, leftType)) {
-      _errorReporter.reportTypeErrorForNode(
-          StaticTypeWarningCode.INVALID_ASSIGNMENT,
-          rhs,
-          [staticRightType, leftType]);
-    }
+    _checkForAssignableExpression(
+        rhs, leftType, StaticTypeWarningCode.INVALID_ASSIGNMENT);
   }
 
   /**
    * Given an [assignment] using a compound assignment operator, this verifies
    * that the given assignment is valid. The [lhs] is the left hand side
    * expression. The [rhs] is the right hand side expression.
    *
    * See [StaticTypeWarningCode.INVALID_ASSIGNMENT].
    */
   void _checkForInvalidCompoundAssignment(
@@ skipping 1181 matching lines @@
         return;
       }
       _errorReporter.reportTypeErrorForNode(
           StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [
         staticReturnType,
         expectedReturnType,
         _enclosingFunction.displayName
       ]);
       return;
     }
-    if (_typeSystem.isAssignableTo(staticReturnType, expectedReturnType)) {
+    if (_expressionIsAssignableAtType(
+        returnExpression, staticReturnType, expectedReturnType)) {
       return;
     }
     _errorReporter.reportTypeErrorForNode(
         StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
         returnExpression,
         [staticReturnType, expectedReturnType, _enclosingFunction.displayName]);
 
     // TODO(brianwilkerson) Define a hint corresponding to the warning and
     // report it if appropriate.
 //        Type propagatedReturnType = returnExpression.getPropagatedType();
@@ skipping 57 matching lines @@
 
     // compare with type of the first non-default 'case'
     SwitchCase switchCase = statement.members
         .firstWhere((member) => member is SwitchCase, orElse: () => null);
     if (switchCase == null) {
       return;
     }
 
     Expression caseExpression = switchCase.expression;
     DartType caseType = getStaticType(caseExpression);
+
     // check types
-    if (!_typeSystem.isAssignableTo(expressionType, caseType)) {
+    if (!_expressionIsAssignableAtType(expression, expressionType, caseType)) {
       _errorReporter.reportErrorForNode(
           StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE,
           expression,
           [expressionType, caseType]);
     }
   }
 
   /**
    * Verify that the given function type [alias] does not reference itself
    * directly.
@@ skipping 385 matching lines @@
     DartType impliedReturnType;
     if (isYieldEach) {
       impliedReturnType = staticYieldedType;
     } else if (_enclosingFunction.isAsynchronous) {
       impliedReturnType =
           _typeProvider.streamType.instantiate(<DartType>[staticYieldedType]);
     } else {
       impliedReturnType =
           _typeProvider.iterableType.instantiate(<DartType>[staticYieldedType]);
     }
-    if (!_typeSystem.isAssignableTo(impliedReturnType, declaredReturnType)) {
-      _errorReporter.reportTypeErrorForNode(
-          StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
-          yieldExpression,
-          [impliedReturnType, declaredReturnType]);
+    if (!_checkForAssignableExpressionAtType(yieldExpression, impliedReturnType,
+        declaredReturnType, StaticTypeWarningCode.YIELD_OF_INVALID_TYPE)) {
       return;
     }
     if (isYieldEach) {
       // Since the declared return type might have been "dynamic", we need to
       // also check that the implied return type is assignable to generic
       // Stream/Iterable.
       DartType requiredReturnType;
       if (_enclosingFunction.isAsynchronous) {
         requiredReturnType = _typeProvider.streamDynamicType;
       } else {
@@ skipping 93 matching lines @@
     for (Expression expression in args.arguments) {
       if (expression is NamedExpression) {
         if (expression.name.label.name == name) {
           return true;
         }
       }
     }
     return false;
   }
 
+  bool _expressionIsAssignable(
+      Expression expression, DartType expectedStaticType) {
+    return _expressionIsAssignableAtType(
+        expression, getStaticType(expression), expectedStaticType);
+  }
+
+  bool _expressionIsAssignableAtType(Expression expression,
+      DartType actualStaticType, DartType expectedStaticType) {
+    bool concrete =
+        _options.strongMode && StaticInfo.isKnownFunction(expression);
+    if (concrete) {
+      actualStaticType =
+          _typeSystem.typeToConcreteType(_typeProvider, actualStaticType);
+      // TODO(leafp): Move the Downcast functionality here.
+      // TODO(leafp): Support strict downcasts
+    }
+    return _typeSystem.isAssignableTo(actualStaticType, expectedStaticType);
+  }
+
   MethodElement _findOverriddenMemberThatMustCallSuper(MethodDeclaration node) {
     ExecutableElement overriddenMember = _getOverriddenMember(node.element);
     List<ExecutableElement> seen = <ExecutableElement>[];
     while (
         overriddenMember is MethodElement && !seen.contains(overriddenMember)) {
       for (ElementAnnotation annotation in overriddenMember.metadata) {
         if (annotation.isMustCallSuper) {
           return overriddenMember;
         }
       }
@@ skipping 439 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);
     }
   }
 }