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.
-    if (!classElement.typeVariables.isEmpty()) {
-      List<HInstruction> rtiInputs = <HInstruction>[];
+    // Create the runtime type information, if needed.
+    if (needsRuntimeTypeInfo(classElement)) {
+      List<HInstruction> inputs = <HInstruction>[];
       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 1368 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 (!needsRuntimeTypeInfo(type.element)) return;
     List<HInstruction> inputs = <HInstruction>[];
     type.arguments.forEach((DartType argument) {
       inputs.add(analyzeTypeArgument(argument, currentNode));
     });
     callSetRuntimeTypeInfo(type.element, inputs, newObject);
   }
 
+  // Runtime type information is required if the type has type
+  // variables or if the program calls [runtimeType].
+  // TODO(karlklose): it is unnecessary for type variables that
+  // can never match an is-Check.
+  bool needsRuntimeTypeInfo(ClassElement element) {
+    bool classHasTypeVariables = !element.typeVariables.isEmpty();
+    bool runtimeTypeIsUsed = compiler.enabledRuntimeType;
+    return (classHasTypeVariables || runtimeTypeIsUsed);
+  }
+
   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);
+    // Construct the runtime type information.
+    HInstruction runtimeType;
+    HInstruction typeInfo;

[kasperl, 2012/09/14 12:35:37]

Isn't this typeInfo variable unused (shadowed)?

[karlklose, 2012/09/17 14:50:37]

Done, removed.

+    StringBuffer runtimeCode = new StringBuffer();
+    List<HInstruction> runtimeCodeInputs = <HInstruction>[];
+    if (runtimeTypeIsUsed) {
+      String runtimeTypeString =
+          RuntimeTypeInformation.generateRuntimeTypeString(element,
+                                                           rtiInputs.length);
+      runtimeType =

[kasperl, 2012/09/14 12:35:37]

Can't you declare runtimeType here?

[karlklose, 2012/09/17 14:50:37]

Done.

+          new HForeign(new LiteralDartString(runtimeTypeString),
+                       new LiteralDartString('String'),
+                       rtiInputs);
+      add(runtimeType);
+      runtimeCodeInputs.add(runtimeType);
+      runtimeCode.add('runtimeType: #');
+    }
+    if (classHasTypeVariables) {
+      if (runtimeTypeIsUsed) runtimeCode.add(', ');
+      String typeVariablesString =
+          RuntimeTypeInformation.generateTypeVariableString(element,
+                                                            rtiInputs.length);
+      HInstruction typeInfo =

[kasperl, 2012/09/14 12:35:37]

Add a helper for this creation of a new foreign string thing? Seems like it
could be used in three cases (if you parameterize it with code, type, and
inputs). Maybe it would actually be useful in other places too?

[karlklose, 2012/09/17 14:50:37]

Done.

+          new HForeign(new LiteralDartString(typeVariablesString),
+                       new LiteralDartString('String'),
+                       rtiInputs);
+      add(typeInfo);
+      runtimeCodeInputs.add(typeInfo);
+      runtimeCode.add('#');
+    }
+    HInstruction runtimeInfo =
+        new HForeign(new LiteralDartString("{$runtimeCode}"),
+                     new LiteralDartString('Object'),
+                     runtimeCodeInputs);
+    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 1512 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;
   }
 }