Remove element from DynamicType.

sdk/lib/_internal/compiler/implementation/js_backend/backend.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 js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 657 matching lines @@
 
     if (constant.isFunction) {
       FunctionConstant function = constant;
       compiler.enqueuer.codegen.registerGetOfStaticFunction(function.element);
     } else if (constant.isInterceptor) {
       // An interceptor constant references the class's prototype chain.
       InterceptorConstant interceptor = constant;
       registerInstantiatedConstantType(interceptor.dispatchedType, registry);
     } else if (constant.isType) {
       TypeConstant typeConstant = constant;
-      registerTypeLiteral(typeConstant.representedType.element,
+      registerTypeLiteral(typeConstant.representedType,
           compiler.enqueuer.codegen, registry);
     }
   }
 
   void registerInstantiatedConstantType(DartType type, Registry registry) {
     Enqueuer enqueuer = compiler.enqueuer.codegen;
     DartType instantiatedType =
-        type.kind == TypeKind.FUNCTION ? compiler.functionClass.rawType : type;
-    enqueuer.registerInstantiatedType(instantiatedType, registry);
-    if (type is InterfaceType && !type.treatAsRaw &&
-        classNeedsRti(type.element)) {
-      enqueuer.registerStaticUse(getSetRuntimeTypeInfo());
-    }
-    if (type.element == typeImplementation) {
-      // If we use a type literal in a constant, the compile time
-      // constant emitter will generate a call to the createRuntimeType
-      // helper so we register a use of that.
-      enqueuer.registerStaticUse(getCreateRuntimeType());
+        type.isFunctionType ? compiler.functionClass.rawType : type;
+    if (type is InterfaceType) {
+      enqueuer.registerInstantiatedType(instantiatedType, registry);
+      if (!type.treatAsRaw && classNeedsRti(type.element)) {
+        enqueuer.registerStaticUse(getSetRuntimeTypeInfo());
+      }
+      if (type.element == typeImplementation) {
+        // If we use a type literal in a constant, the compile time
+        // constant emitter will generate a call to the createRuntimeType
+        // helper so we register a use of that.
+        enqueuer.registerStaticUse(getCreateRuntimeType());
+      }
     }
   }
 
   void registerMetadataConstant(Constant constant, Registry registry) {
     if (mustRetainMetadata) {
       registerCompileTimeConstant(constant, registry);
     } else {
       metadataConstants.add(new Dependency(constant, registry));
     }
   }
@@ skipping 178 matching lines @@
     // statement context or an expression context, so we register both
     // here, even though we may not need the throwExpression helper.
     enqueueInResolution(getWrapExceptionHelper(), registry);
     enqueueInResolution(getThrowExpressionHelper(), registry);
   }
 
   void registerLazyField(Registry registry) {
     enqueueInResolution(getCyclicThrowHelper(), registry);
   }
 
-  void registerTypeLiteral(Element element,
+  void registerTypeLiteral(DartType type,
                            Enqueuer enqueuer,
                            Registry registry) {
     enqueuer.registerInstantiatedClass(typeImplementation, registry);
     enqueueInResolution(getCreateRuntimeType(), registry);
     // TODO(ahe): Might want to register [element] as an instantiated class
     // when reflection is used.  However, as long as we disable tree-shaking
     // eagerly it doesn't matter.
-    if (element.isTypedef) {
-      typedefTypeLiterals.add(element);
+    if (type.isTypedef) {
+      typedefTypeLiterals.add(type.element);
     }
-    customElementsAnalysis.registerTypeLiteral(element, enqueuer);
+    customElementsAnalysis.registerTypeLiteral(type, enqueuer);
   }
 
   void registerStackTraceInCatch(Registry registry) {
     enqueueInResolution(getTraceFromException(), registry);
   }
 
   void registerGetRuntimeTypeArgument(Registry registry) {
     enqueueInResolution(getGetRuntimeTypeArgument(), registry);
     enqueueInResolution(getGetTypeArgumentByIndex(), registry);
     enqueueInResolution(getCopyTypeArguments(), registry);
@@ skipping 58 matching lines @@
         if (helper != null) {
           enqueue(world, helper.getElement(compiler), registry);
         }
         // We also need the native variant of the check (for DOM types).
         helper = getNativeCheckedModeHelper(type, typeCast: false);
         if (helper != null) {
           enqueue(world, helper.getElement(compiler), registry);
         }
       }
     }
-    bool isTypeVariable = type.kind == TypeKind.TYPE_VARIABLE;
-    if (type.kind == TypeKind.MALFORMED_TYPE) {
+    bool isTypeVariable = type.isTypeVariable;
+    if (type.isMalformed) {
       enqueueInResolution(getThrowTypeError(), registry);
     }
     if (!type.treatAsRaw || type.containsTypeVariables) {
       enqueueInResolution(getSetRuntimeTypeInfo(), registry);
       enqueueInResolution(getGetRuntimeTypeInfo(), registry);
       registerGetRuntimeTypeArgument(registry);
       if (inCheckedMode) {
         enqueueInResolution(getAssertSubtype(), registry);
       }
       enqueueInResolution(getCheckSubtype(), registry);
@@ skipping 303 matching lines @@
     if (name == null) return null;
     CheckedModeHelper helper = checkedModeHelperByName[name];
     assert(helper != null);
     return helper;
   }
 
   String getCheckedModeHelperNameInternal(DartType type,
                                           {bool typeCast,
                                            bool nativeCheckOnly}) {
     assert(type.kind != TypeKind.TYPEDEF);
-    if (type.kind == TypeKind.MALFORMED_TYPE) {
+    if (type.isMalformed) {
       // The same error is thrown for type test and type cast of a malformed
       // type so we only need one check method.
       return 'checkMalformedType';
     }
     Element element = type.element;
     bool nativeCheck = nativeCheckOnly ||
         emitter.nativeEmitter.requiresNativeIsCheck(element);
 
     // TODO(13955), TODO(9731).  The test for non-primitive types should use an
     // interceptor.  The interceptor should be an argument to HTypeConversion so
@@ skipping 62 matching lines @@
         if (nativeCheck) {
           return typeCast
               ? 'listSuperNativeTypeCast'
               : 'listSuperNativeTypeCheck';
         } else {
           return typeCast
               ? 'listSuperTypeCast'
               : 'listSuperTypeCheck';
         }
       } else {
-        if (type.kind == TypeKind.INTERFACE && !type.treatAsRaw) {
+        if (type.isInterfaceType && !type.treatAsRaw) {
           return typeCast
               ? 'subtypeCast'
               : 'assertSubtype';
-        } else if (type.kind == TypeKind.TYPE_VARIABLE) {
+        } else if (type.isTypeVariable) {
           return typeCast
               ? 'subtypeOfRuntimeTypeCast'
               : 'assertSubtypeOfRuntimeType';
-        } else if (type.kind == TypeKind.FUNCTION) {
+        } else if (type.isFunctionType) {
           return null;
         } else {
           if (nativeCheck) {
             // TODO(karlklose): can we get rid of this branch when we use
             // interceptors?
             return typeCast
                 ? 'interceptedTypeCast'
                 : 'interceptedTypeCheck';
           } else {
             return typeCast
@@ skipping 497 matching lines @@
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final Constant constant;
   // TODO(johnniwinther): Change to [Element] when dependency nodes are added.
   final Registry registry;
 
   const Dependency(this.constant, this.registry);
 }