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 1110 matching lines @@
       onFailure(node, ambiguous.messageKind, ambiguous.messageArguments);
     } else if (!element.impliesType()) {
       onFailure(node, MessageKind.NOT_A_TYPE, [node.typeName]);
     } else {
       if (identical(element, compiler.types.voidType.element) ||
           identical(element, compiler.types.dynamicType.element)) {
         type = element.computeType(compiler);
       } 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,
                                  onFailure, whenResolved);
         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;
+            } 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);

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

Not needed either since we call [resolveTypedef].

         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 783 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 567 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 576 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }