Handle type checking of generic compile time constants.

sdk/lib/_internal/compiler/implementation/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.
 
 part of dart2js;
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
@@ skipping 703 matching lines @@
     compiler.resolver.resolveRedirectionChain(constructor, node);
     InterfaceType constructedType = constructor.computeTargetType(type);
     constructor = constructor.redirectionTarget;
     ClassElement classElement = constructor.getEnclosingClass();
     // The constructor must be an implementation to ensure that field
     // initializers are handled correctly.
     constructor = constructor.implementation;
     assert(invariant(node, constructor.isImplementation));
 
     List<Constant> arguments = getArguments(constructor);
-    ConstructorEvaluator evaluator =
-        new ConstructorEvaluator(constructor, handler, compiler);
+    ConstructorEvaluator evaluator = new ConstructorEvaluator(
+        constructedType, constructor, handler, compiler);
     evaluator.evaluateConstructorFieldValues(arguments);
     List<Constant> jsNewArguments = evaluator.buildJsNewArguments(classElement);
 
     return new ConstructedConstant(constructedType, jsNewArguments);
   }
 
   Constant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
 
@@ skipping 25 matching lines @@
 
   error(Node node) {
     // Just fail without reporting it anywhere.
     throw new CompileTimeConstantError(
         MessageKind.NOT_A_COMPILE_TIME_CONSTANT, const {},
         compiler.terseDiagnostics);
   }
 }
 
 class ConstructorEvaluator extends CompileTimeConstantEvaluator {
+  final InterfaceType constructedType;
   final FunctionElement constructor;
   final Map<Element, Constant> definitions;
   final Map<Element, Constant> fieldValues;
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [constructor] must be an implementation element.
    */
-  ConstructorEvaluator(FunctionElement constructor,
+  ConstructorEvaluator(InterfaceType this.constructedType,
+                       FunctionElement constructor,
                        ConstantHandler handler,
                        Compiler compiler)
       : this.constructor = constructor,
         this.definitions = new Map<Element, Constant>(),
         this.fieldValues = new Map<Element, Constant>(),
         super(handler,
               compiler.resolver.resolveMethodElement(constructor.declaration),
               compiler,
               isConst: true) {
     assert(invariant(constructor, constructor.isImplementation));
   }
 
   Constant visitSend(Send send) {
     Element element = elements[send];
     if (Elements.isLocal(element)) {
       Constant constant = definitions[element];
       if (constant == null) {
         compiler.internalError("Local variable without value", node: send);
       }
       return constant;
     }
     return super.visitSend(send);
   }
 
-  void potentiallyCheckType(Node node, Element element, Constant constant) {
+  void potentiallyCheckType(Node node,

[karlklose, 2014/01/29 10:44:23]

'elementType' -> 'type'?

I think the name of the local included 'element' because that was the source of
the type, but there is no such relation for the parameter.

As a bonus the parameter list may fit into one line.

[Johnni Winther, 2014/01/30 08:25:23]

Done.

+                            DartType elementType,
+                            Constant constant) {
     if (compiler.enableTypeAssertions) {
-      DartType elementType = element.computeType(compiler);
       DartType constantType = constant.computeType(compiler);
-      // TODO(ngeoffray): Handle type parameters.
-      if (elementType.element.isTypeVariable()) return;
-      if (!constantSystem.isSubtype(compiler, constantType, elementType)) {
+      if (!compiler.types.isSubtype(constantType, elementType)) {
         compiler.reportFatalError(
             node, MessageKind.NOT_ASSIGNABLE.error,
-            {'fromType': elementType, 'toType': constantType});
+            {'fromType': constantType, 'toType': elementType});
       }
     }
   }
 
-  void updateFieldValue(Node node, Element element, Constant constant) {
-    potentiallyCheckType(node, element, constant);
+  void updateFieldValue(Node node,

[karlklose, 2014/01/29 10:44:23]

Still fits on one line.

[Johnni Winther, 2014/01/30 08:25:23]

Done.

+                        Element element,
+                        Constant constant) {
+    DartType elementType =
+        element.computeType(compiler).substByContext(constructedType);
+    potentiallyCheckType(node, elementType, 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<Constant> arguments) {
     // Assign arguments to parameters.
-    FunctionSignature parameters = constructor.computeSignature(compiler);
+    FunctionSignature signature = constructor.computeSignature(compiler);
     int index = 0;
-    parameters.orderedForEachParameter((Element parameter) {
+    signature.orderedForEachParameter((Element parameter) {
+      DartType parameterType =
+          parameter.computeType(compiler).substByContext(constructedType);
       Constant argument = arguments[index++];
       Node node = parameter.parseNode(compiler);
-      potentiallyCheckType(node, parameter, argument);
+      potentiallyCheckType(node, parameterType, argument);
       definitions[parameter] = argument;
       if (parameter.kind == ElementKind.FIELD_PARAMETER) {
         FieldParameterElement fieldParameterElement = parameter;
         updateFieldValue(node, fieldParameterElement.fieldElement, argument);
       }
     });
   }
 
   void evaluateSuperOrRedirectSend(List<Constant> compiledArguments,
                                    FunctionElement targetConstructor) {
     ConstructorEvaluator evaluator = new ConstructorEvaluator(
+        constructedType.asInstanceOf(targetConstructor.getEnclosingClass()),
         targetConstructor, handler, compiler);
     evaluator.evaluateConstructorFieldValues(compiledArguments);
     // Copy over the fieldValues from the super/redirect-constructor.
     // No need to go through [updateFieldValue] because the
     // assignments have already been checked in checked mode.
     evaluator.fieldValues.forEach((key, value) => fieldValues[key] = value);
   }
 
   /**
    * Runs through the initializers of the given [constructor] and updates
@@ skipping 89 matching lines @@
           if (fieldValue == null) {
             // Use the default value.
             fieldValue = handler.compileConstant(field);
           }
           jsNewArguments.add(fieldValue);
         },
         includeSuperAndInjectedMembers: true);
     return jsNewArguments;
   }
 }