Remove element from DynamicType.

sdk/lib/_internal/compiler/implementation/compile_time_constants.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 dart2js;
 
 /// A [ConstantEnvironment] provides access for constants compiled for variable
 /// initializers.
 abstract class ConstantEnvironment {
   /// Returns the constant for the initializer of [element].
@@ skipping 133 matching lines @@
     if (initializer == null) {
       // No initial value.
       value = new NullConstant();
     } else {
       value = compileNodeWithDefinitions(
           initializer, definitions, isConst: isConst);
       if (compiler.enableTypeAssertions &&
           value != null &&
           element.isField) {
         DartType elementType = element.type;
-        if (elementType.kind == TypeKind.MALFORMED_TYPE && !value.isNull) {
+        if (elementType.isMalformed && !value.isNull) {
           if (isConst) {
             ErroneousElement element = elementType.element;
             compiler.reportFatalError(
                 node, element.messageKind, element.messageArguments);
           } else {
             // We need to throw an exception at runtime.
             value = null;
           }
         } else {
           DartType constantType = value.computeType(compiler);
@@ skipping 235 matching lines @@
   Constant visitLiteralSymbol(LiteralSymbol node) {
     InterfaceType type = compiler.symbolClass.rawType;
     List<Constant> createArguments(_) {
       return [constantSystem.createString(
         new DartString.literal(node.slowNameString))];
     }
     return makeConstructedConstant(
         node, type, compiler.symbolConstructor, createArguments);
   }
 
-  Constant makeTypeConstant(TypeDeclarationElement element) {
-    DartType elementType = element.rawType;
+  Constant makeTypeConstant(DartType elementType) {
     DartType constantType =
         compiler.backend.typeImplementation.computeType(compiler);
     return new TypeConstant(elementType, constantType);
   }
 
   /// Returns true if the prefix of the send resolves to a deferred import
   /// prefix.
   bool isDeferredUse(Send send) {
     if (send == null) return false;
     return compiler.deferredLoadTask
         .deferredPrefixElement(send, elements) != null;
   }
 
   Constant visitIdentifier(Identifier node) {
     Element element = elements[node];
     if (Elements.isClass(element) || Elements.isTypedef(element)) {
-      return makeTypeConstant(element);
+      TypeDeclarationElement typeDeclarationElement = element;
+      return makeTypeConstant(typeDeclarationElement.rawType);
     }
     return signalNotCompileTimeConstant(node);
   }
 
   // TODO(floitsch): provide better error-messages.
   Constant visitSend(Send send) {
     Element element = elements[send];
     if (send.isPropertyAccess) {
       if (isDeferredUse(send)) {
         return signalNotCompileTimeConstant(send,
             message: MessageKind.DEFERRED_COMPILE_TIME_CONSTANT);
       }
       if (Elements.isStaticOrTopLevelFunction(element)) {
         return new FunctionConstant(element);
       } else if (Elements.isStaticOrTopLevelField(element)) {
         Constant result;
         if (element.isConst) {
           result = handler.compileConstant(element);
         } else if (element.isFinal && !isEvaluatingConstant) {
           result = handler.compileVariable(element);
         }
         if (result != null) return result;
       } else if (Elements.isClass(element) || Elements.isTypedef(element)) {
         assert(elements.isTypeLiteral(send));
-        return makeTypeConstant(element);
+        return makeTypeConstant(elements.getTypeLiteralType(send));
       } else if (send.receiver != null) {
         // Fall through to error handling.
       } else if (!Elements.isUnresolved(element)
                  && element.isVariable
                  && element.isConst) {
         Constant result = handler.compileConstant(element);
         if (result != null) return result;
       }
       return signalNotCompileTimeConstant(send);
     } else if (send.isCall) {
@@ skipping 504 matching lines @@
           if (fieldValue == null) {
             // Use the default value.
             fieldValue = handler.compileConstant(field);
           }
           jsNewArguments.add(fieldValue);
         },
         includeSuperAndInjectedMembers: true);
     return jsNewArguments;
   }
 }