Canonicalize raw type

sdk/lib/_internal/compiler/implementation/elements/elements.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 elements;
 
 import 'dart:uri';
 
 // TODO(ahe): Rename prefix to 'api' when VM bug is fixed.
 import '../../compiler.dart' as api_e;
@@ skipping 820 matching lines @@
   lookupLocalMember(SourceString memberName) => imported[memberName];
 
   DartType computeType(Compiler compiler) => compiler.types.dynamicType;
 
   Token position() => firstPosition;
 }
 
 class TypedefElement extends Element implements TypeDeclarationElement {
   Typedef cachedNode;
   TypedefType cachedType;
+
+  /**
+   * Canonicalize raw version of [cachedType].
+   *
+   * See [ClassElement.rawType] for motivation.
+   *
+   * The [rawType] is computed together with [cachedType] in [computeType].
+   */
+  TypedefType rawType;
+
+  /**
+   * The type annotation which defines this typedef.
+   */
   DartType alias;
 
   bool isResolved = false;
   bool isBeingResolved = false;
 
   TypedefElement(SourceString name, Element enclosing)
       : super(name, ElementKind.TYPEDEF, enclosing);
 
   /**
    * Function signature for a typedef of a function type. The signature is
    * kept to provide full information about parameter names through the mirror
    * system.
    *
    * The [functionSignature] is not available until the typedef element has been
    * resolved.
    */
   FunctionSignature functionSignature;
 
   TypedefType computeType(Compiler compiler) {
     if (cachedType != null) return cachedType;
     Typedef node = parseNode(compiler);
     Link<DartType> parameters =
         TypeDeclarationElement.createTypeVariables(this, node.typeParameters);
     cachedType = new TypedefType(this, parameters);
+    if (parameters.isEmpty) {
+      rawType = cachedType;
+    } else {
+      var dynamicParameters = const Link<DartType>();
+      parameters.forEach((_) {
+        dynamicParameters =
+            dynamicParameters.prepend(compiler.types.dynamicType);
+      });
+      rawType = new TypedefType(this, dynamicParameters);
+    }
     compiler.resolveTypedef(this);
     return cachedType;
   }
 
   Link<DartType> get typeVariables => cachedType.typeArguments;
 
   Scope buildScope() {
     return new TypeDeclarationScope(enclosingElement.buildScope(), this);
   }
 }
@@ skipping 501 matching lines @@
       variableElement.type = variableType;
       arguments.addLast(variableType);
     }
     return arguments.toLink();
   }
 }
 
 abstract class ClassElement extends ScopeContainerElement
     implements TypeDeclarationElement {
   final int id;
-  InterfaceType type;
+  /**
+   * The type of [:this:] for this class declaration.
+   *
+   * The type of [:this:] is the interface type based on this element in which
+   * the type arguments are the declared type variables. For instance,
+   * [:List<E>:] for [:List:] and [:Map<K,V>:] for [:Map:].
+   *
+   * This type is computed in [computeType].
+   */
+  InterfaceType thisType;
+
+  /**
+   * The raw type for this class declaration.
+   *
+   * The raw type is the interface type base on this element in which the type
+   * arguments are all [dynamic]. For instance [:List<dynamic>:] for [:List:]
+   * and [:Map<dynamic,dynamic>:] for [:Map:]. For non-generic classes [rawType]
+   * is the same as [thisType].
+   *
+   * The [rawType] field is a canonicalization of the raw type and should be
+   * used to distinguish explicit and implicit uses of the [dynamic]
+   * type arguments. For instance should [:List:] be the [rawType] of the
+   * [:List:] class element whereas [:List<dynamic>:] should be its own
+   * instantiation of [InterfaceType] with [:dynamic:] as type argument. Using
+   * this distinction, we can print the raw type with type arguments only when
+   * the input source has used explicit type arguments.
+   *
+   * This type is computed together with [thisType] in [computeType].

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

Awesome comments.

+   */
+  InterfaceType rawType;
   DartType supertype;
   DartType defaultClass;
   Link<DartType> interfaces;
   SourceString nativeName;
   int supertypeLoadState;
   int resolutionState;
 
   // backendMembers are members that have been added by the backend to simplify
   // compilation. They don't have any user-side counter-part.
   Link<Element> backendMembers = const Link<Element>();
 
   Link<DartType> allSupertypes;
 
   // Lazily applied patch of class members.
   ClassElement patch = null;
   ClassElement origin = null;
 
   ClassElement(SourceString name, Element enclosing, this.id, int initialState)
     : supertypeLoadState = initialState,
       resolutionState = initialState,
       super(name, ElementKind.CLASS, enclosing);
 
   ClassNode parseNode(Compiler compiler);
 
   InterfaceType computeType(compiler) {
-    if (type == null) {
+    if (thisType == null) {
       if (origin == null) {
         ClassNode node = parseNode(compiler);
         Link<DartType> parameters =
             TypeDeclarationElement.createTypeVariables(this,
                                                        node.typeParameters);
-        type = new InterfaceType(this, parameters);
+        thisType = new InterfaceType(this, parameters);
+        if (parameters.isEmpty) {
+          rawType = thisType;
+        } else {
+          var dynamicParameters = const Link<DartType>();
+          parameters.forEach((_) {
+            dynamicParameters =
+                dynamicParameters.prepend(compiler.types.dynamicType);
+          });

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

Code duplication detected. This loop can be shared with typedef element.

+          rawType = new InterfaceType(this, dynamicParameters);
+        }
       } else {
-        type = origin.computeType(compiler);
+        thisType = origin.computeType(compiler);
+        rawType = origin.rawType;
       }
     }
-    return type;
+    return thisType;
   }
 
   bool get isPatched => patch != null;
   bool get isPatch => origin != null;
 
   ClassElement get declaration => super.declaration;
   ClassElement get implementation => super.implementation;
 
   /**
    * Return [:true:] if this element is the [:Object:] class for the [compiler].
    */
   bool isObject(Compiler compiler) =>
       identical(declaration, compiler.objectClass);
 
-  Link<DartType> get typeVariables => type.typeArguments;
+  Link<DartType> get typeVariables => thisType.typeArguments;
 
   ClassElement ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveClass(this);
     }
     return this;
   }
 
   /**
    * Lookup local members in the class. This will ignore constructors.
@@ skipping 273 matching lines @@
     }
     return false;
   }
 
   bool isInterface() => false;
   bool isNative() => nativeName != null;
   int get hashCode => id;
 
   Scope buildScope() => new ClassScope(enclosingElement.buildScope(), this);
 
-  Link<DartType> get allSupertypesAndSelf {
-    return allSupertypes.prepend(new InterfaceType(this));
-  }
-
   String toString() {
     if (origin != null) {
       return 'patch ${super.toString()}';
     } else if (patch != null) {
       return 'origin ${super.toString()}';
     } else {
       return super.toString();
     }
   }
 }
@@ skipping 329 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }