Add runtimeType() to Object which returns canonicalized instances of Type.

lib/compiler/implementation/ssa/builder.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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 1224 matching lines @@
         includeBackendMembers: true,
         includeSuperMembers: true,
         f: (ClassElement enclosingClass, Element member) {
       constructorArguments.add(
           potentiallyCheckType(fieldValues[member], member));
     });
 
     HForeignNew newObject = new HForeignNew(classElement, constructorArguments);
     add(newObject);
 
-    // If the class has type variables, create the runtime type
-    // information with the type parameters provided.
+    // Create the runtime type information, if needed.
     InterfaceType type = classElement.computeType(compiler);
-    if (compiler.world.needsRti(type.element)) {
-      List<HInstruction> rtiInputs = <HInstruction>[];
+      List<HInstruction> inputs = <HInstruction>[];
+      if (compiler.world.needsRti(classElement)) {
       classElement.typeVariables.forEach((TypeVariableType typeVariable) {
-        rtiInputs.add(localsHandler.directLocals[typeVariable.element]);
+        inputs.add(localsHandler.directLocals[typeVariable.element]);
       });
-      callSetRuntimeTypeInfo(classElement, rtiInputs, newObject);
+      callSetRuntimeTypeInfo(classElement, inputs, newObject);
     }
 
     // Generate calls to the constructor bodies.
     for (int index = constructors.length - 1; index >= 0; index--) {
       FunctionElement constructor = constructors[index];
       ConstructorBodyElement body = getConstructorBody(constructor);
       if (body === null) continue;
       List bodyCallInputs = <HInstruction>[];
       bodyCallInputs.add(newObject);
       int arity = body.functionSignature.parameterCount;
@@ skipping 1367 matching lines @@
     } else {
       // The type variable is a type (e.g. int).
       return graph.addConstantString(
           new LiteralDartString('$argument'), currentNode, constantSystem);
     }
   }
 
   void handleListConstructor(InterfaceType type,
                              Node currentNode,
                              HInstruction newObject) {
-    if (type.arguments.isEmpty()) return;
+    if (!compiler.world.needsRti(type.element)) return;
     List<HInstruction> inputs = <HInstruction>[];
     type.arguments.forEach((DartType argument) {
       inputs.add(analyzeTypeArgument(argument, currentNode));
     });
     callSetRuntimeTypeInfo(type.element, inputs, newObject);
   }
 
   void callSetRuntimeTypeInfo(ClassElement element,
-                              List<HInstruction> inputs,
+                              List<HInstruction> rtiInputs,
                               HInstruction newObject) {
-    List<String> typeVariables = <String>[];
-    element.typeVariables.forEach((TypeVariableType typeVariable) {
-      typeVariables.add("'$typeVariable': #");
-    });
+    bool classHasTypeVariables = !element.typeVariables.isEmpty();
+    bool runtimeTypeIsUsed = compiler.enabledRuntimeType;
 
-    String jsCode = '{ ${Strings.join(typeVariables, ', ')} }';
-    HInstruction typeInfo = new HForeign(new LiteralDartString(jsCode),
-                                         new LiteralDartString('Object'),
-                                         inputs);
-    add(typeInfo);
+    HInstruction createForeign(String template,
+                               List<HInstruction> arguments,
+                               [String type = 'String']) {
+      return new HForeign(new LiteralDartString(template),
+                          new LiteralDartString(type),
+                          arguments);
+    }
+
+    // Construct the runtime type information.
+    StringBuffer runtimeCode = new StringBuffer();
+    List<HInstruction> runtimeCodeInputs = <HInstruction>[];
+    if (runtimeTypeIsUsed) {
+      String runtimeTypeString =
+          RuntimeTypeInformation.generateRuntimeTypeString(element,
+                                                           rtiInputs.length);
+      HInstruction runtimeType = createForeign(runtimeTypeString, rtiInputs);
+      add(runtimeType);
+      runtimeCodeInputs.add(runtimeType);
+      runtimeCode.add('runtimeType: #');
+    }
+    if (classHasTypeVariables) {
+      if (runtimeTypeIsUsed) runtimeCode.add(', ');
+      String typeVariablesString =
+          RuntimeTypeInformation.generateTypeVariableString(element,
+                                                            rtiInputs.length);
+      HInstruction typeInfo = createForeign(typeVariablesString, rtiInputs);
+      add(typeInfo);
+      runtimeCodeInputs.add(typeInfo);
+      runtimeCode.add('#');
+    }
+    HInstruction runtimeInfo =
+        createForeign("{$runtimeCode}", runtimeCodeInputs, 'Object');
+    add(runtimeInfo);
+
+    // Set the runtime type information on the object.
     Element typeInfoSetterElement = interceptors.getSetRuntimeTypeInfo();
     HInstruction typeInfoSetter = new HStatic(typeInfoSetterElement);
     add(typeInfoSetter);
-    add(new HInvokeStatic(<HInstruction>[typeInfoSetter, newObject, typeInfo]));
+    add(new HInvokeStatic(
+        <HInstruction>[typeInfoSetter, newObject, runtimeInfo]));
   }
 
   visitNewSend(Send node) {
     bool isListConstructor = false;
     computeType(element) {
       Element originalElement = elements[node];
       if (originalElement.getEnclosingClass() === compiler.listClass) {
         isListConstructor = true;
         if (node.arguments.isEmpty()) {
           return HType.EXTENDABLE_ARRAY;
@@ skipping 1514 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }