Canonicalize raw type

sdk/lib/_internal/compiler/implementation/resolution/members.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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 1124 matching lines @@
         if (cls.typeVariables.isEmpty && arguments.isEmpty) {
           // Use the canonical type if it has no type parameters.
           type = cls.computeType(compiler);
         } else {
           // In checked mode malformed-ness of the type argument bubbles up.
           if (anyMalformedTypesInThere(arguments) &&
               compiler.enableTypeAssertions) {
             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;

[ahe, 2012/11/29 10:09:08]

cls.declaration.rawType?

+            } else {
+              type = new InterfaceType(cls.declaration, arguments);
+            }
           }
         }
       } else if (element.isTypedef()) {
         TypedefElement typdef = element;
         // TODO(ahe): Should be [ensureResolved].
         compiler.resolveTypedef(typdef);
-        typdef.computeType(compiler);
         Link<DartType> arguments = resolveTypeArguments(
             node, typdef.typeVariables, inStaticContext,
             scope, onFailure, whenResolved);
         if (typdef.typeVariables.isEmpty && arguments.isEmpty) {
           // 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) {
           compiler.reportWarning(node,
               MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER.message(
                   [element]));
           type = new MalformedType(new MalformedTypeElement(node, element));
         } else {
           type = element.computeType(compiler);
         }
@@ skipping 789 matching lines @@
     if (node.isRedirectingFactoryBody) {
       handleRedirectingFactoryBody(node);
     } else {
       visit(node.expression);
     }
   }
 
   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);
     assert(invariant(node, enclosingElement.isFactoryConstructor()));
     FunctionElement constructor = enclosingElement;
     if (constructor.modifiers.isConst() &&
         !redirectionTarget.modifiers.isConst()) {
       error(node, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
     }
     // TODO(ahe): Check that this doesn't lead to a cycle.  For now,
@@ skipping 569 matching lines @@
       error(node.superclass, MessageKind.TYPE_NAME_EXPECTED);
     }
     final objectElement = compiler.objectClass;
     if (!identical(element, objectElement) && element.supertype == null) {
       if (objectElement == null) {
         compiler.internalError("Internal error: cannot resolve Object",
                                node: node);
       } 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>();
     for (Link<Node> link = node.interfaces.nodes;
          !link.isEmpty;
          link = link.tail) {
       DartType interfaceType = visit(link.head);
       if (interfaceType != null && interfaceType.element.isExtendable()) {
         interfaces = interfaces.prepend(interfaceType);
         if (isBlackListed(interfaceType)) {
@@ skipping 580 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }