Represent runtime type information as nested lists.

sdk/lib/_internal/compiler/implementation/lib/js_helper.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 _js_helper;
 
 import 'dart:collection';
 
 part 'constant_map.dart';
 part 'native_helper.dart';
@@ skipping 1613 matching lines @@
   bool operator ==(other) {
     if (other is !TypeImpl) return false;
     return typeName == other.typeName;
   }
 }
 
 String getClassName(var object) {
   return JS('String', r'#.constructor.builtin$cls', object);
 }
 
+String getTypeArgumentAsString(List runtimeType) {
+  String className = runtimeTypeToString(runtimeType[0]);
+  if (runtimeType.length = 1) return className;
+  return '$className<${joinArguments(runtimeType, 1)}>';
+}
+
+String runtimeTypeToString(type) {
+  if (type == null) {
+    return 'dynamic';
+  } else if (type is String) {
+    // A native class.  The string is the unique name.
+    return type;
+  } else if (isJsArray(type)) {
+    // A list representing a type with arguments.
+    return getTypeArgumentAsString(type);
+  } else {
+    // A reference to the constructor.
+    return JS('String', r'#.builtin$cls', type);
+  }
+}
+
+String joinArguments(var types, int startIndex) {
+  bool firstArgument = true;
+  StringBuffer buffer = new StringBuffer();
+  for (int index = startIndex; index < types.length; index++) {
+    if (firstArgument) {
+      firstArgument = false;
+    } else {
+      buffer. add(', ');
+    }
+    var argument = types[index];
+    buffer.add(runtimeTypeToString(argument));
+  }
+  return buffer.toString();
+}
+
 String getRuntimeTypeString(var object) {
   String className = isJsArray(object) ? 'List' : getClassName(object);
   var typeInfo = JS('var', r'#.builtin$typeInfo', object);
   if (typeInfo == null) return className;
-  StringBuffer arguments = new StringBuffer();
-  for (var i = 0; i < typeInfo.length; i++) {
-    if (i > 0) {
-      arguments.add(', ');
+  return "$className<${joinArguments(typeInfo, 0)}>";
+}
+
+bool isSubtype(var s, var t) {
+  // TODO(karlklose): support suptyping.

[kasperl, 2012/12/06 09:51:04]

suptyping -> subtyping. Maybe extend the comment to explain what's missing?

[karlklose, 2012/12/06 13:30:03]

Done.

+  if (s == null || t == null) return true;
+  if (!isJsArray(s)) return s == t;
+  if (JS('var', '#[0]', s) != JS('var', '#[0]', t)) return false;
+  int len = JS('int', '#.length', s);
+  for (int i = 1; i < len; i++) {
+    if (!isSubtype(JS('var', '#[0]', s), JS('var', '#[0]', s))) {
+      return false;
     }
-    var argument = typeInfo[i];
-    if (argument == null) {
-      argument = 'dynamic';
-    }
-    arguments.add(argument);
   }
-  return '$className<$arguments>';
+  return true;
 }
 
 createRuntimeType(String name) => new TypeImpl(name);