Check parameter types when evaluating constants.

pkg/analyzer/lib/src/generated/constant.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.constant;
 
 import 'dart:collection';
@@ skipping 488 matching lines @@
     if (!identical(argumentValues[0].type, typeProvider.stringType)) {
       return false;
     }
     if (argumentCount == 2) {
       if (arguments[1] is! NamedExpression) {
         return false;
       }
       if (!((arguments[1] as NamedExpression).name.label.name == _DEFAULT_VALUE_PARAM)) {
         return false;
       }
-      InterfaceType defaultValueType = namedArgumentValues[_DEFAULT_VALUE_PARAM].type;
+      ParameterizedType defaultValueType = namedArgumentValues[_DEFAULT_VALUE_PARAM].type;
       if (!(identical(defaultValueType, expectedDefaultValueType) || identical(defaultValueType, typeProvider.nullType))) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * Check that the arguments to a call to Symbol() are correct.
    *
@@ skipping 96 matching lines @@
         // because it's likely to lead to cascading errors.  So just leave [value] in the unknown
         // state.
       }
     }
     return value;
   }
 
   DartObjectImpl _evaluateConstructorCall(AstNode node, NodeList<Expression> arguments, ConstructorElement constructor, ConstantVisitor constantVisitor, ErrorReporter errorReporter) {
     int argumentCount = arguments.length;
     List<DartObjectImpl> argumentValues = new List<DartObjectImpl>(argumentCount);
+    List<Expression> argumentNodes = new List<Expression>(argumentCount);
     HashMap<String, DartObjectImpl> namedArgumentValues = new HashMap<String, DartObjectImpl>();
+    HashMap<String, NamedExpression> namedArgumentNodes =
+        new HashMap<String, NamedExpression>();
     for (int i = 0; i < argumentCount; i++) {
       Expression argument = arguments[i];
       if (argument is NamedExpression) {
-        NamedExpression namedExpression = argument;
-        String name = namedExpression.name.label.name;
-        namedArgumentValues[name] = constantVisitor._valueOf(namedExpression.expression);
+        String name = argument.name.label.name;
+        namedArgumentValues[name] = constantVisitor._valueOf(argument.expression);
+        namedArgumentNodes[name] = argument;
         argumentValues[i] = constantVisitor.null2;
       } else {
         argumentValues[i] = constantVisitor._valueOf(argument);
+        argumentNodes[i] = argument;
       }
     }
     constructor = _followConstantRedirectionChain(constructor);
     InterfaceType definingClass = constructor.returnType as InterfaceType;
     if (constructor.isFactory) {
       // We couldn't find a non-factory constructor.  See if it's because we reached an external
       // const factory constructor that we can emulate.
       if (constructor.name == "fromEnvironment") {
         if (!_checkFromEnvironmentArguments(arguments, argumentValues, namedArgumentValues, definingClass)) {
           errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION, node, []);
@@ skipping 33 matching lines @@
     List<ConstructorInitializer> initializers = constructorBase.constantInitializers;
     if (initializers == null) {
       // This can happen in some cases where there are compile errors in the code being analyzed
       // (for example if the code is trying to create a const instance using a non-const
       // constructor, or the node we're visiting is involved in a cycle).  The error has already
       // been reported, so consider it an unknown value to suppress further errors.
       return constantVisitor._validWithUnknownValue(definingClass);
     }
     HashMap<String, DartObjectImpl> fieldMap = new HashMap<String, DartObjectImpl>();
     HashMap<String, DartObjectImpl> parameterMap = new HashMap<String, DartObjectImpl>();
-    List<ParameterElement> parameters = constructorBase.parameters;
+    List<ParameterElement> parameters = constructor.parameters;
     int parameterCount = parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       ParameterElement parameter = parameters[i];
-      while (parameter is ParameterMember) {
-        parameter = (parameter as ParameterMember).baseElement;
+      ParameterElement baseParameter = parameter;
+      while (baseParameter is ParameterMember) {
+        baseParameter = (baseParameter as ParameterMember).baseElement;
       }
       DartObjectImpl argumentValue = null;
-      if (parameter.parameterKind == ParameterKind.NAMED) {
-        argumentValue = namedArgumentValues[parameter.name];
+      AstNode errorTarget = null;
+      if (baseParameter.parameterKind == ParameterKind.NAMED) {
+        argumentValue = namedArgumentValues[baseParameter.name];
+        errorTarget = namedArgumentNodes[baseParameter.name];
       } else if (i < argumentCount) {
         argumentValue = argumentValues[i];
+        errorTarget = argumentNodes[i];
       }
-      if (argumentValue == null && parameter is ParameterElementImpl) {
+      if (errorTarget == null) {
+        // No argument node that we can direct error messages to, because we
+        // are handling an optional parameter that wasn't specified.  So just
+        // direct error messages to the constructor call.
+        errorTarget = node;
+      }
+      if (argumentValue == null && baseParameter is ParameterElementImpl) {
         // The parameter is an optional positional parameter for which no value was provided, so
         // use the default value.
-        beforeGetParameterDefault(parameter);
-        EvaluationResultImpl evaluationResult = (parameter as ParameterElementImpl).evaluationResult;
+        beforeGetParameterDefault(baseParameter);
+        EvaluationResultImpl evaluationResult = (baseParameter as ParameterElementImpl).evaluationResult;
         if (evaluationResult == null) {
           // No default was provided, so the default value is null.
           argumentValue = constantVisitor.null2;
         } else if (evaluationResult.value != null) {
           argumentValue = evaluationResult.value;
         }
       }
       if (argumentValue != null) {
-        if (parameter.isInitializingFormal) {
-          FieldElement field = (parameter as FieldFormalParameterElement).field;
+        if (!argumentValue.isNull && !argumentValue.type.isSubtypeOf(parameter.type)) {

[Brian Wilkerson, 2014/10/07 16:30:48]

We should perform this test before we access the default value, otherwise an
invalid default value will (I think) cause an error to be reported at every call
site.

[Paul Berry, 2014/10/07 17:03:34]

The difficulty with that is that it doesn't have correct semantics according to
the spec.  For better or worse, the spec defines this as correct code (no
errors, no warnings):

  class A {
    const A();
  }
  class B extends A {
    const B();
  }
  class C {
    const C([B b = const A()]); // *
  }
  main() {
    new C(const B()); // **
  }

But if the line marked "// **" is replaced with "new C()", then that's a checked
mode compile time error.

I would be ok with adding a hint at the line marked "// *", though, to let the
user know that a checked mode compile time error will occur if the default isn't
overridden.

+          errorReporter.reportErrorForNode(
+              CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
+              errorTarget,
+              [argumentValue.type, parameter.type]);
+        }
+        if (baseParameter.isInitializingFormal) {
+          FieldElement field = (baseParameter as FieldFormalParameterElement).field;
           if (field != null) {
             String fieldName = field.name;
             fieldMap[fieldName] = argumentValue;
           }
         } else {
-          String name = parameter.name;
+          String name = baseParameter.name;
           parameterMap[name] = argumentValue;
         }
       }
     }
     ConstantVisitor initializerVisitor = new ConstantVisitor.con2(typeProvider, parameterMap, errorReporter);
     String superName = null;
     NodeList<Expression> superArguments = null;
     for (ConstructorInitializer initializer in initializers) {
       if (initializer is ConstructorFieldInitializer) {
         ConstructorFieldInitializer constructorFieldInitializer = initializer;
@@ skipping 307 matching lines @@
     }
     conditionResult = _dartObjectComputer.applyBooleanConversion(condition, conditionResult);
     if (conditionResult == null) {
       return conditionResult;
     }
     if (conditionResult.isTrue) {
       return thenResult;
     } else if (conditionResult.isFalse) {
       return elseResult;
     }
-    InterfaceType thenType = thenResult.type;
-    InterfaceType elseType = elseResult.type;
+    ParameterizedType thenType = thenResult.type;
+    ParameterizedType elseType = elseResult.type;
     return _validWithUnknownValue(thenType.getLeastUpperBound(elseType) as InterfaceType);
   }
 
   @override
   DartObjectImpl visitDoubleLiteral(DoubleLiteral node) => new DartObjectImpl(_typeProvider.doubleType, new DoubleState(node.value));
 
   @override
   DartObjectImpl visitInstanceCreationExpression(InstanceCreationExpression node) {
     if (!node.isConst) {
       // TODO(brianwilkerson) Figure out which error to report.
@@ skipping 280 matching lines @@
     if (element is VariableElementImpl) {
       VariableElementImpl variableElementImpl = element;
       beforeGetEvaluationResult(node);
       EvaluationResultImpl value = variableElementImpl.evaluationResult;
       if (variableElementImpl.isConst && value != null) {
         return value.value;
       }
     } else if (element is ExecutableElement) {
       ExecutableElement function = element;
       if (function.isStatic) {
-        return new DartObjectImpl(_typeProvider.functionType, new FunctionState(function));
+        ParameterizedType functionType = function.type;
+        if (functionType == null) {
+          functionType = _typeProvider.functionType;
+        }
+        return new DartObjectImpl(functionType, new FunctionState(function));
       }
     } else if (element is ClassElement || element is FunctionTypeAliasElement) {
       return new DartObjectImpl(_typeProvider.typeType, new TypeState(element));
     }
     // TODO(brianwilkerson) Figure out which error to report.
     _error(node, null);
     return null;
   }
 
   /**
@@ skipping 50 matching lines @@
    *
    * @return the string value of this object
    */
   String get stringValue;
 
   /**
    * Return the run-time type of this object.
    *
    * @return the run-time type of this object
    */
-  InterfaceType get type;
+  ParameterizedType get type;
 
   /**
    * Return this object's value if it can be represented exactly, or `null` if either the
    * value cannot be represented exactly or if the value is `null`. Clients should use
    * [hasExactValue] to distinguish between these two cases.
    *
    * @return this object's value
    */
   Object get value;
 
@@ skipping 344 matching lines @@
   }
 }
 
 /**
  * Instances of the class `DartObjectImpl` represent an instance of a Dart class.
  */
 class DartObjectImpl implements DartObject {
   /**
    * The run-time type of this object.
    */
-  final InterfaceType type;
+  final ParameterizedType type;
 
   /**
    * The state of the object.
    */
   final InstanceState _state;
 
   /**
    * Initialize a newly created object to have the given type and state.
    *
    * @param type the run-time type of this object
@@ skipping 2769 matching lines @@
 
   @override
   String get typeName => "Type";
 
   @override
   int get hashCode => _element == null ? 0 : _element.hashCode;
 
   @override
   String toString() => _element == null ? "-unknown-" : _element.name;
 }