Typecheck const classes in the context of the constructor call.

pkg/compiler/lib/src/compile_time_constants.dart

 // Copyright (c) 2012, 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 dart2js.compile_time_constant_evaluator;
 
 import 'constant_system_dart.dart';
 import 'constants/constant_system.dart';
 import 'constants/expressions.dart';
 import 'constants/values.dart';
@@ skipping 135 matching lines @@
   @override
   ConstantValue getConstantValueForVariable(VariableElement element) {
     return getConstantValue(initialVariableValues[element.declaration]);
   }
 
   @override
   ConstantExpression getConstantForVariable(VariableElement element) {
     return initialVariableValues[element.declaration];
   }
 
-  ConstantExpression compileConstant(VariableElement element) {
-    return compileVariable(element, isConst: true);
+  ConstantExpression compileConstant(VariableElement element,
+                                     {bool checkType: true}) {

[Johnni Winther, 2015/06/17 06:56:29]

This method overrides ConstantCompiler.compileConstant; add [checkType] to it,
or create a new internal variant of compileConstant.

Document [checkType].

[Harry Terkelsen, 2015/08/10 23:49:34]

Done.

+    return compileVariable(element, isConst: true, checkType: checkType);
   }
 
   ConstantExpression compileVariable(VariableElement element,
-                                     {bool isConst: false}) {
+                                     {bool isConst: false,
+                                      bool checkType: true}) {

[Johnni Winther, 2015/06/17 06:56:29]

Ditto.

[Harry Terkelsen, 2015/08/10 23:49:34]

Done.

 
     if (initialVariableValues.containsKey(element.declaration)) {
       ConstantExpression result = initialVariableValues[element.declaration];
       return result;
     }
     AstElement currentElement = element.analyzableElement;
     return compiler.withCurrentElement(currentElement, () {
       // TODO(johnniwinther): Avoid this eager analysis.
       _analyzeElementEagerly(compiler, currentElement);
 
       ConstantExpression constant = compileVariableWithDefinitions(
-          element, currentElement.resolvedAst.elements, isConst: isConst);
+          element, currentElement.resolvedAst.elements, isConst: isConst,
+          checkType: checkType);
       return constant;
     });
   }
 
   /**
    * Returns the a compile-time constant if the variable could be compiled
    * eagerly. If the variable needs to be initialized lazily returns `null`.
    * If the variable is `const` but cannot be compiled eagerly reports an
    * error.
    */
   ConstantExpression compileVariableWithDefinitions(VariableElement element,
                                                     TreeElements definitions,
-                                                    {bool isConst: false}) {
+                                                    {bool isConst: false,
+                                                     bool checkType: true}) {
     Node node = element.node;
     if (pendingVariables.contains(element)) {
       if (isConst) {
         compiler.reportError(
             node, MessageKind.CYCLIC_COMPILE_TIME_CONSTANTS);
         ConstantExpression expression = new ErroneousConstantExpression();
         constantValueMap[expression] = constantSystem.createNull();
         return expression;
       }
       return null;
     }
     pendingVariables.add(element);
 
     Expression initializer = element.initializer;
     ConstantExpression expression;
     if (initializer == null) {
       // No initial value.
       expression = new NullConstantExpression();
       constantValueMap[expression] = constantSystem.createNull();
     } else {
       expression = compileNodeWithDefinitions(
           initializer, definitions, isConst: isConst);
       if (compiler.enableTypeAssertions &&
+          checkType &&
           expression != null &&
           element.isField) {
         DartType elementType = element.type;
         ConstantValue value = getConstantValue(expression);
         if (elementType.isMalformed && !value.isNull) {
           if (isConst) {
             ErroneousElement element = elementType.element;
             compiler.reportError(
                 node, element.messageKind, element.messageArguments);
           } else {
@@ skipping 894 matching lines @@
     if (Elements.isLocal(element)) {
       AstConstant constant = definitions[element];
       if (constant == null) {
         compiler.internalError(send, "Local variable without value.");
       }
       return constant;
     }
     return super.visitSend(send);
   }
 
-  void potentiallyCheckType(Node node,
-                            TypedElement element,
+  void potentiallyCheckType(TypedElement element,
                             AstConstant constant) {
     if (compiler.enableTypeAssertions) {
       DartType elementType = element.type.substByContext(constructedType);
       DartType constantType = constant.value.getType(compiler.coreTypes);
       if (!constantSystem.isSubtype(compiler.types,
                                     constantType, elementType)) {
         compiler.withCurrentElement(constant.element, () {
           compiler.reportError(
               constant.node, MessageKind.NOT_ASSIGNABLE,
               {'fromType': constantType, 'toType': elementType});
         });
       }
     }
   }
 
   void updateFieldValue(Node node,
                         TypedElement element,
                         AstConstant constant) {
-    potentiallyCheckType(node, element, constant);
+    potentiallyCheckType(element, constant);
     fieldValues[element] = constant;
   }
 
   /**
    * Given the arguments (a list of constants) assigns them to the parameters,
    * updating the definitions map. If the constructor has field-initializer
    * parameters (like [:this.x:]), also updates the [fieldValues] map.
    */
   void assignArgumentsToParameters(List<AstConstant> arguments) {
     if (constructor.isErroneous) return;
     // Assign arguments to parameters.
     FunctionSignature signature = constructor.functionSignature;
     int index = 0;
     signature.orderedForEachParameter((ParameterElement parameter) {
       AstConstant argument = arguments[index++];
       Node node = parameter.node;
       if (parameter.isInitializingFormal) {
         InitializingFormalElement initializingFormal = parameter;
         updateFieldValue(node, initializingFormal.fieldElement, argument);
       } else {
-        potentiallyCheckType(node, parameter, argument);
+        potentiallyCheckType(parameter, argument);
         definitions[parameter] = argument;
       }
     });
   }
 
   void evaluateSuperOrRedirectSend(List<AstConstant> compiledArguments,
                                    FunctionElement targetConstructor) {
     ConstructorEvaluator evaluator = new ConstructorEvaluator(
         constructedType.asInstanceOf(targetConstructor.enclosingClass),
         targetConstructor, handler, compiler);
@@ skipping 96 matching lines @@
   /// inheritance chain of [classElement].
   Map<FieldElement, AstConstant> buildFieldConstants(
       ClassElement classElement) {
     Map<FieldElement, AstConstant> fieldConstants =
         <FieldElement, AstConstant>{};
     classElement.implementation.forEachInstanceField(
         (ClassElement enclosing, FieldElement field) {
           AstConstant fieldValue = fieldValues[field];
           if (fieldValue == null) {
             // Use the default value.
-            ConstantExpression fieldExpression = handler.compileConstant(field);
+            ConstantExpression fieldExpression =
+                handler.compileConstant(field, checkType: false);
             fieldValue = new AstConstant.fromDefaultValue(
                 field,
                 fieldExpression,
                 handler.getConstantValue(fieldExpression));
+            potentiallyCheckType(field, fieldValue);
           }
           fieldConstants[field] = fieldValue;
         },
         includeSuperAndInjectedMembers: true);
     return fieldConstants;
   }
 }
 
 /// A constant created from the front-end AST.
 ///
@@ skipping 33 matching lines @@
           // TODO(johnniwinther): Return a [NonConstantValue] instead.
           new ErroneousConstantExpression(), new NullConstantValue());
 }
 
 // TODO(johnniwinther): Avoid the need for this hack.
 TreeElements _analyzeElementEagerly(Compiler compiler, AstElement element) {
   WorldImpact worldImpact = compiler.analyzeElement(element.declaration);
   compiler.enqueuer.resolution.applyImpact(element.declaration, worldImpact);
   return element.resolvedAst.elements;
 }