Register type for literal list/map.

sdk/lib/_internal/compiler/implementation/elements/modelx.dart

 // Copyright (c) 2013, 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.modelx;
 
 import 'dart:uri';
 import 'dart:collection' show LinkedHashMap;
 
 import 'elements.dart';
@@ skipping 1346 matching lines @@
    * 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].
    */
-  InterfaceType rawType;
+  InterfaceType rawTypeCache;
   DartType supertype;
   DartType defaultClass;
   Link<DartType> interfaces;
   SourceString nativeTagInfo;
   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>();
@@ skipping 15 matching lines @@
   ClassElement get implementation => super.implementation;
 
   bool get hasBackendMembers => !backendMembers.isEmpty;
 
   InterfaceType computeType(Compiler compiler) {
     if (thisType == null) {
       if (origin == null) {
         Link<DartType> parameters = computeTypeParameters(compiler);
         thisType = new InterfaceType(this, parameters);
         if (parameters.isEmpty) {
-          rawType = thisType;
+          rawTypeCache = thisType;
         } else {
           var dynamicParameters = const Link<DartType>();
           parameters.forEach((_) {
             dynamicParameters =
                 dynamicParameters.prepend(compiler.types.dynamicType);
           });
-          rawType = new InterfaceType(this, dynamicParameters);
+          rawTypeCache = new InterfaceType(this, dynamicParameters);
         }
       } else {
         thisType = origin.computeType(compiler);
-        rawType = origin.rawType;
+        rawTypeCache = origin.rawType;
       }
     }
     return thisType;
   }
 
+  InterfaceType get rawType {
+    assert(invariant(this, rawTypeCache != null,
+                     message: 'Raw type has not been computed for $this'));
+    return rawTypeCache;
+  }
+
   Link<DartType> computeTypeParameters(Compiler compiler);
 
   /**
    * Return [:true:] if this element is the [:Object:] class for the [compiler].
    */
   bool isObject(Compiler compiler) =>
       identical(declaration, compiler.objectClass);
 
   Link<DartType> get typeVariables => thisType.typeArguments;
 
@@ skipping 589 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }