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

lib/compiler/implementation/ssa/ssa.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.
 
 #library('ssa');
 
 #import('../closure.dart');
 #import('../js/js.dart', prefix: 'js');
 #import('../leg.dart');
 #import('../source_file.dart');
@@ skipping 15 matching lines @@
 #source('nodes.dart');
 #source('optimize.dart');
 #source('types.dart');
 #source('types_propagation.dart');
 #source('validate.dart');
 #source('variable_allocator.dart');
 #source('value_set.dart');
 
 class RuntimeTypeInformation {
   bool hasTypeArguments(DartType type) {
     if (type is InterfaceType) {

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

Can this be a method call on type?

       InterfaceType interfaceType = type;
       return !interfaceType.arguments.isEmpty();
     }
     return false;
   }
+
+  static void foreach(Link collection,

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

forEach?

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

Changed the name.

+                      int numberOfInputs,
+                      f(bool isFirst, bool hasValue,
+                        TypeVariableType variable)) {
+    int currentVariable = 0;
+    bool isFirst = true;
+    collection.forEach((TypeVariableType variable) {
+      f(isFirst, currentVariable < numberOfInputs, variable);
+      isFirst = false;
+      currentVariable++;
+    });
+  }
+
+  /**
+   * Generate a string representation template for this element, using '#' to
+   * denote the place for the type argument input. If there are more type
+   * variables than [numberOfInputs], 'Dynamic' is used as the value for these
+   * arguments.
+   */
+  static String generateRuntimeTypeString(ClassElement element,
+                                          int numberOfInputs) {
+    StringBuffer buffer = new StringBuffer(element.name.slowToString());
+    foreach(element.typeVariables, numberOfInputs,
+            (bool isFirst, bool hasValue, _) {
+      String value = hasValue ? "' + # + '" : "Dynamic";
+      buffer.add(isFirst ? "<$value" : ", $value");

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

If you remove the < here and move it out so you do something like this:

   String elementName = element.name.slowToString();
   if (element.typeVariables.isEmpty()) return elementName;
   StringBuffer buffer = new StringBuffer();
   forEach(.., (..) {
     
   });
   return "'$elementName<$buffer>'";

That also opens up for dealing with the isFirst thing in a consistent way. Maybe
forEach could be changed to do something like this:

  static String forEach(
       Link collection,
       int numberOfInputs,
       String stringify(TypeVariableType variable, bool hasValue)) {
     int currentVariable = 0;
     bool isFirst = true;
     StringBuffer buffer = new StringBuffer();
     collection.forEach((TypeVariableType variable) {
       if (!isFirst) buffer.add(", ");
       bool hasValue = currentVariable < numberOfInputs;
       buffer.add(stringify(variable, hasValue));
       isFirst = false;
       currentVariable++;
     });
     return buffer.toString();
   }

which would simplify generateRuntimeTypeString to look something like this:

  static generateRuntimeTypeString(...) {
    String elementName = element.name.slowToString();
    if (element.typeVariables.isEmpty()) return elementName;
    String stringify(_, hasValue) 
        => hasValue ? "' + # + '" : "Dynamic";
    String arguments = forEach(element.typeVariables,
                               numberOfInputs,
                               stringify);
    return "'$elementName<$arguments>'";
  }

Makes sense? You may want to change the name of forEach if you go this route.

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

Done.

+    });
+    if (!element.typeVariables.isEmpty()) {
+      buffer.add(">");
+    }
+    return "'${buffer}'";
+  }
+
+  /**
+   * Generate a string template for the runtime type fields that contain the
+   * type descriptions of the reified type arguments, using '#' to denote the
+   * place for the type argument value, or [:null:] if there are more than
+   * [numberOfInputs] type variables.
+   */
+  static String generateTypeVariableString(ClassElement element,
+                                           int numberOfInputs) {
+    int currentVariable = 0;

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

Unused?

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

Done.

+    StringBuffer buffer = new StringBuffer();
+    foreach(element.typeVariables, numberOfInputs,
+            (bool isFirst, bool hasValue, variable) {
+      if (!isFirst) {
+        buffer.add(', ');
+      }
+      String value = hasValue ? "#" : "null";
+      buffer.add("'${variable.name.slowToString()}': $value");
+    });
+    return buffer.toString();
+  }
 }