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) {

[ngeoffray, 2012/09/14 07:30:21]

I believe you could move the creation of the strings out of the builder right?
Like in RuntimeTypeInformation? Then the builder would just need to create the
HForeign and the logic for rti would be elsewhere.

-    List<String> typeVariables = <String>[];
-    element.typeVariables.forEach((TypeVariableType typeVariable) {
-      typeVariables.add("'$typeVariable': #");
+    bool classHasTypeVariables = !element.typeVariables.isEmpty();
+    bool runtimeTypeIsUsed = compiler.enabledRuntimeType;
+
+    // Prepare the format strings for the reified type variables and the
+    // runtime type, if necessary.
+    String runtimeTypeString = "'${element.name.slowToString()}";

[kasperl, 2012/09/14 07:26:48]

Move the computation of the runtimeTypeString into its own method. Consider
using a string buffer for building it instead and then do something like:

   StringBuffer buffer = new StringBuffer();
   ...
   return "'$buffer'";

to make it clear that the single quotes match up. Maybe you can even use the
same method for computing the typeVariablesString if you use a closure for
computing what to add to the buffer?

+    String typeVariablesString = '';
+    bool firstVariable = true;
+    int numberOfVariables = 0;
+    element.typeVariables.forEach((TypeVariableType variable) {
+      String name = variable.name.slowToString();
+      String value = (numberOfVariables < rtiInputs.length) ? '#' : "'Dynamic'";
+      if (runtimeTypeIsUsed) {
+        if (firstVariable) {
+          runtimeTypeString = "$runtimeTypeString<' + $value";
+        } else {
+          runtimeTypeString = "$runtimeTypeString + ', ' + $value";
+        }
+      }
+      if (!firstVariable) {
+        typeVariablesString = '$typeVariablesString, ';
+      }
+      typeVariablesString = "$typeVariablesString'$name': $value";
+      firstVariable = false;
+      numberOfVariables++;
     });
+    if (classHasTypeVariables) {
+      runtimeTypeString = "$runtimeTypeString + '>";
+    }
+    runtimeTypeString = "$runtimeTypeString'";
 
-    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;
+    String runtimeCode = '{';

[kasperl, 2012/09/14 07:26:48]

Use StringBuffer.

+    List<HInstruction> runtimeCodeInputs = <HInstruction>[];
+    if (runtimeTypeIsUsed) {
+      runtimeType =
+          new HForeign(new LiteralDartString(runtimeTypeString),
+                       new LiteralDartString('String'),
+                       rtiInputs);
+      add(runtimeType);
+      runtimeCodeInputs.add(runtimeType);
+      runtimeCode = runtimeCode.concat('runtimeType: #');
+    }
+    if (classHasTypeVariables) {
+      if (runtimeTypeIsUsed) runtimeCode = runtimeCode.concat(', ');
+      HInstruction typeInfo =
+          new HForeign(new LiteralDartString(typeVariablesString),
+                       new LiteralDartString('String'),
+                       rtiInputs);
+      add(typeInfo);
+      runtimeCodeInputs.add(typeInfo);
+      runtimeCode = runtimeCode.concat('#');
+    }
+    runtimeCode = runtimeCode.concat('}');
+    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;
   }
 }