Canonicalize raw type

sdk/lib/_internal/compiler/implementation/resolution/members.dart

Index: sdk/lib/_internal/compiler/implementation/resolution/members.dart
diff --git a/sdk/lib/_internal/compiler/implementation/resolution/members.dart b/sdk/lib/_internal/compiler/implementation/resolution/members.dart
index 713a03c693cb06790cdc2635bc36374a88781c5a..74bef5dc2b3588eafea04306ed65641cdeec537e 100644
--- a/sdk/lib/_internal/compiler/implementation/resolution/members.dart
+++ b/sdk/lib/_internal/compiler/implementation/resolution/members.dart
@@ -1128,6 +1128,7 @@ class TypeResolver {
       } else if (element.isClass()) {
         ClassElement cls = element;
         cls.ensureResolved(compiler);
+        cls.computeType(compiler);

[karlklose, 2012/11/28 08:02:32]

Before this change, the type was computed lazily when calling computeType. Now,
we have the invariant that computeType must be called before rawType can be
accessed.

Perhaps we should always call compute type when we resolve a class?

[Johnni Winther, 2012/11/28 08:18:38]

We do. The call to computeType is not currently needed when we call
ensureResolved.

         Link<DartType> arguments =
             resolveTypeArguments(node, cls.typeVariables,
                                  inStaticContext, scope,
@@ -1142,7 +1143,12 @@ class TypeResolver {
             type = new MalformedType(
                 new MalformedTypeElement(node, element));
           } else {
-            type = new InterfaceType(cls.declaration, arguments);
+            if (arguments.isEmpty) {
+              // Use the canonical raw type if the class is generic.
+              type = cls.rawType;
+            } else {
+              type = new InterfaceType(cls.declaration, arguments);
+            }
           }
         }
       } else if (element.isTypedef()) {
@@ -1157,7 +1163,11 @@ class TypeResolver {
           // Return the canonical type if it has no type parameters.
           type = typdef.computeType(compiler);
         } else {
-          type = new TypedefType(typdef, arguments);
+          if (arguments.isEmpty) {
+            type = typdef.rawType;
+          } else {
+           type = new TypedefType(typdef, arguments);
+          }
         }
       } else if (element.isTypeVariable()) {
         if (inStaticContext) {
@@ -1961,7 +1971,7 @@ class ResolverVisitor extends CommonResolverVisitor<Element> {
   void handleRedirectingFactoryBody(Return node) {
     Element redirectionTarget = resolveRedirectingFactory(node);
     var type = mapping.getType(node.expression);
-    if (type is InterfaceType && !type.typeArguments.isEmpty) {
+    if (type is InterfaceType && !type.isRaw) {
       unimplemented(node.expression, 'type arguments on redirecting factory');
     }
     useElement(node.expression, redirectionTarget);
@@ -2549,8 +2559,7 @@ class ClassResolverVisitor extends TypeDefinitionVisitor {
       } else {
         objectElement.ensureResolved(compiler);
       }
-      // TODO(ahe): This should be objectElement.computeType(...).
-      element.supertype = new InterfaceType(objectElement);
+      element.supertype = objectElement.computeType(compiler);
     }
     assert(element.interfaces == null);
     Link<DartType> interfaces = const Link<DartType>();