Add type arguments to 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 14 matching lines @@
 
   /** The set of variable elements that are in the process of being computed. */
   final Set<VariableElement> pendingVariables;
 
   /** Caches the statics where the initial value cannot be eagerly compiled. */
   final Set<VariableElement> lazyStatics;
 
   /** Caches the createRuntimeType function if registered. */
   Element createRuntimeTypeFunction = null;
 
+  /** Caches the setRuntimeTypeInfo function if registered. */
+  Element setRuntimeTypeInfoFunction = null;
+
   ConstantHandler(Compiler compiler, this.constantSystem,
                   { bool this.isMetadata: false })
       : initialVariableValues = new Map<VariableElement, dynamic>(),
         compiledConstants = new Set<Constant>(),
         pendingVariables = new Set<VariableElement>(),
         lazyStatics = new Set<VariableElement>(),
         super(compiler);
 
   String get name => 'ConstantHandler';
 
   void registerCompileTimeConstant(Constant constant, TreeElements elements) {
-    registerInstantiatedClass(constant.computeType(compiler).element, elements);
+    registerInstantiatedType(constant.computeType(compiler), elements);
     if (constant.isFunction()) {
       FunctionConstant function = constant;
       registerGetOfStaticFunction(function.element);
     } else if (constant.isInterceptor()) {
       // An interceptor constant references the class's prototype chain.
       InterceptorConstant interceptor = constant;
-      registerInstantiatedClass(interceptor.dispatchedType.element, elements);
+      registerInstantiatedType(interceptor.dispatchedType, elements);
     }
     compiledConstants.add(constant);
   }
 
-  void registerInstantiatedClass(ClassElement element, TreeElements elements) {
+  void registerInstantiatedType(DartType type, TreeElements elements) {
     if (isMetadata) return;
-    compiler.enqueuer.codegen.registerInstantiatedClass(element, elements);
+    compiler.enqueuer.codegen.registerInstantiatedType(type, elements);
   }
 
   void registerStaticUse(Element element) {
     if (isMetadata) return;
     compiler.analyzeElement(element.declaration);
     compiler.enqueuer.codegen.registerStaticUse(element);
   }
 
   void registerGetOfStaticFunction(FunctionElement element) {
     if (isMetadata) return;
     compiler.analyzeElement(element.declaration);
     compiler.enqueuer.codegen.registerGetOfStaticFunction(element);
   }
 
   void registerStringInstance(TreeElements elements) {
-    registerInstantiatedClass(compiler.stringClass, elements);
+    registerInstantiatedType(compiler.stringClass.rawType, elements);
+  }
+
+  void registerSetRuntimeTypeInfoFunction() {
+    if (setRuntimeTypeInfoFunction != null) return;

[ngeoffray, 2013/06/17 09:15:03]

In non-checked mode, how do you make sure this helper is not emitted if not
needed? It looks like you're unconditionally adding it, but don't you need to
check if there are is checks that require it?

[karlklose, 2013/06/19 15:29:05]

Added a check.

+    SourceString helperName = const SourceString('setRuntimeTypeInfo');
+    setRuntimeTypeInfoFunction = compiler.findHelper(helperName);
+    registerStaticUse(setRuntimeTypeInfoFunction);
   }
 
   void registerCreateRuntimeTypeFunction() {
     if (createRuntimeTypeFunction != null) return;
     SourceString helperName = const SourceString('createRuntimeType');
     createRuntimeTypeFunction = compiler.findHelper(helperName);
     registerStaticUse(createRuntimeTypeFunction);
   }
 
   /**
@@ skipping 224 matching lines @@
     isEvaluatingConstant = oldIsEvaluatingConstant;
     assert(result != null);
     return result;
   }
 
   Constant visitNode(Node node) {
     return signalNotCompileTimeConstant(node);
   }
 
   Constant visitLiteralBool(LiteralBool node) {
-    handler.registerInstantiatedClass(compiler.boolClass, elements);
+    handler.registerInstantiatedType(compiler.boolClass.rawType, elements);
     return constantSystem.createBool(node.value);
   }
 
   Constant visitLiteralDouble(LiteralDouble node) {
-    handler.registerInstantiatedClass(compiler.doubleClass, elements);
+    handler.registerInstantiatedType(compiler.doubleClass.rawType, elements);
     return constantSystem.createDouble(node.value);
   }
 
   Constant visitLiteralInt(LiteralInt node) {
-    handler.registerInstantiatedClass(compiler.intClass, elements);
+    handler.registerInstantiatedType(compiler.intClass.rawType, elements);
     return constantSystem.createInt(node.value);
   }
 
   Constant visitLiteralList(LiteralList node) {
     if (!node.isConst())  {
       return signalNotCompileTimeConstant(node);
     }
     List<Constant> arguments = <Constant>[];
     for (Link<Node> link = node.elements.nodes;
          !link.isEmpty;
          link = link.tail) {
       arguments.add(evaluateConstant(link.head));
     }
-    // TODO(9476): get type parameters.
-    compiler.listClass.computeType(compiler);
-    DartType type = compiler.listClass.rawType;
+    DartType type = elements.getType(node);
+    handler.registerInstantiatedType(type, elements);
+    if (!type.isRaw) {
+      handler.registerSetRuntimeTypeInfoFunction();

[ngeoffray, 2013/06/17 09:15:03]

Move this check to [registerInstantiatedType]?

[karlklose, 2013/06/19 15:29:05]

Done.

+    }
     Constant constant = new ListConstant(type, arguments);
     handler.registerCompileTimeConstant(constant, elements);
     return constant;
   }
 
   Constant visitLiteralMap(LiteralMap node) {
     if (!node.isConst()) {
       return signalNotCompileTimeConstant(node);
     }
     List<StringConstant> keys = <StringConstant>[];
@@ skipping 14 matching lines @@
     List<Constant> values = <Constant>[];
     Constant protoValue = null;
     for (StringConstant key in keys) {
       if (key.value == MapConstant.PROTO_PROPERTY) {
         protoValue = map[key];
       } else {
         values.add(map[key]);
       }
     }
     bool hasProtoKey = (protoValue != null);
-    // TODO(9476): this should be a List<String> type.
-    compiler.listClass.computeType(compiler);
-    DartType keysType = compiler.listClass.rawType;
+    InterfaceType sourceType = elements.getType(node);
+    Link<DartType> arguments =
+        new Link<DartType>.fromList([compiler.stringClass.rawType]);
+    DartType keysType = new InterfaceType(compiler.listClass, arguments);
     ListConstant keysList = new ListConstant(keysType, keys);
     handler.registerCompileTimeConstant(keysList, elements);
     SourceString className = hasProtoKey
                              ? MapConstant.DART_PROTO_CLASS
                              : MapConstant.DART_CLASS;
     ClassElement classElement = compiler.jsHelperLibrary.find(className);
     classElement.ensureResolved(compiler);
-    // TODO(9476): copy over the generic type.
-    DartType type = classElement.rawType;
-    handler.registerInstantiatedClass(classElement, elements);
+    Link<DartType> typeArgument = sourceType.typeArguments.tail;
+    InterfaceType type = new InterfaceType(classElement, typeArgument);
+    handler.registerInstantiatedType(type, elements);
+    if (!type.isRaw) {

[ngeoffray, 2013/06/17 09:15:03]

Ditto.

[karlklose, 2013/06/19 15:29:05]

Done.

+      handler.registerSetRuntimeTypeInfoFunction();
+    }
     Constant constant = new MapConstant(type, keysList, values, protoValue);
     handler.registerCompileTimeConstant(constant, elements);
     return constant;
   }
 
   Constant visitLiteralNull(LiteralNull node) {
     return constantSystem.createNull();
   }
 
   Constant visitLiteralString(LiteralString node) {
@@ skipping 33 matching lines @@
       if (partString == null) return null;
       accumulator = new DartString.concat(accumulator, partString.value);
     };
     handler.registerStringInstance(elements);
     return constantSystem.createString(accumulator, node);
   }
 
   Constant makeTypeConstant(Element element) {
     DartType elementType = element.computeType(compiler).asRaw();
     if (compiler.mirrorsEnabled) {
-      handler.registerInstantiatedClass(element, elements);
+      handler.registerInstantiatedType(elementType, elements);
     }
     DartType constantType =
         compiler.backend.typeImplementation.computeType(compiler);
     Constant constant = new TypeConstant(elementType, constantType);
     // If we use a type literal in a constant, the compile time
     // constant emitter will generate a call to the createRuntimeType
     // helper so we register a use of that.
     handler.registerCreateRuntimeTypeFunction();
     handler.registerCompileTimeConstant(constant, elements);
     return constant;
@@ skipping 183 matching lines @@
     }
     return compiledArguments;
   }
 
   Constant visitNewExpression(NewExpression node) {
     if (!node.isConst()) {
       return signalNotCompileTimeConstant(node);
     }
 
     Send send = node.send;
-    FunctionElement constructor = elements[send];
+    FunctionElement functionElement = elements[send];
+    FunctionElement constructor = functionElement;

[ngeoffray, 2013/06/17 09:15:03]

What is this double assignment for? If line 678 changes the constructor, it
should not matter right?

[karlklose, 2013/06/19 15:29:05]

Yes, this is left-over code. Removed.

     // TODO(ahe): This is nasty: we must eagerly analyze the
     // constructor to ensure the redirectionTarget has been computed
     // correctly.  Find a way to avoid this.
     compiler.analyzeElement(constructor.declaration);
     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));
 
     Selector selector = elements.getSelector(send);
     List<Constant> arguments = evaluateArgumentsToConstructor(
         node, selector, send.arguments, constructor);
     ConstructorEvaluator evaluator =
         new ConstructorEvaluator(node, constructor, handler, compiler);
     evaluator.evaluateConstructorFieldValues(arguments);
     List<Constant> jsNewArguments = evaluator.buildJsNewArguments(classElement);
 
-    handler.registerInstantiatedClass(classElement, elements);
-    // TODO(9476): take generic types into account.
-    classElement.computeType(compiler);
-    DartType type = classElement.rawType;
+    InterfaceType type = elements.getType(node);
+    bool isRedirected = functionElement.isRedirectingFactory;
+    if (isRedirected) {
+      type = functionElement.computeTargetType(compiler, type);
+    }
+
+    handler.registerInstantiatedType(type, elements);
+    if (type is InterfaceType && !type.isRaw) {
+      handler.registerSetRuntimeTypeInfoFunction();
+    }
     Constant constant = new ConstructedConstant(type, jsNewArguments);
     handler.registerCompileTimeConstant(constant, elements);
     return constant;
   }
 
   Constant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
 
   error(Node node) {
@@ skipping 204 matching lines @@
           if (fieldValue == null) {
             // Use the default value.
             fieldValue = handler.compileConstant(field);
           }
           jsNewArguments.add(fieldValue);
         },
         includeSuperAndInjectedMembers: true);
     return jsNewArguments;
   }
 }