Remove element from DynamicType.

sdk/lib/_internal/compiler/implementation/ssa/codegen.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 ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 1701 matching lines @@
 
   visitLocalSet(HLocalSet node) {
     use(node.value);
     assignVariable(variableNames.getName(node.receiver), pop());
   }
 
   void registerForeignTypes(HForeign node) {
     native.NativeBehavior nativeBehavior = node.nativeBehavior;
     if (nativeBehavior == null) return;
     nativeBehavior.typesReturned.forEach((type) {
-      if (type is DartType) {
+      if (type is InterfaceType) {
         registry.registerInstantiatedType(type);
       }
     });
   }
 
   visitForeign(HForeign node) {
     List<HInstruction> inputs = node.inputs;
     if (node.isJsStatement()) {
       List<js.Expression> interpolatedExpressions = <js.Expression>[];
       for (int i = 0; i < inputs.length; i++) {
@@ skipping 670 matching lines @@
         attachLocationToLast(node);
       } else if (Elements.isStringOnlySupertype(element, compiler)) {
         handleStringSupertypeCheck(
             input, interceptor, type, negative: negative);
         attachLocationToLast(node);
       } else if (identical(element, compiler.listClass)
                  || Elements.isListSupertype(element, compiler)) {
         handleListOrSupertypeCheck(
             input, interceptor, type, negative: negative);
         attachLocationToLast(node);
-      } else if (type.kind == TypeKind.FUNCTION) {
+      } else if (type.isFunctionType) {
         checkType(input, interceptor, type, negative: negative);
         attachLocationToLast(node);
       } else if ((input.canBePrimitive(compiler)
                   && !input.canBePrimitiveArray(compiler))
                  || input.canBeNull()) {
         checkObject(input, relation);
         js.Expression objectTest = pop();
         checkType(input, interceptor, type, negative: negative);
         push(new js.Binary(negative ? '||' : '&&', objectTest, pop()), node);
       } else {
@@ skipping 121 matching lines @@
       }
       currentContainer = oldContainer;
       body = unwrapStatement(body);
       pushStatement(new js.If.noElse(test, body), node);
       return;
     }
 
     assert(node.isCheckedModeCheck || node.isCastTypeCheck);
     DartType type = node.typeExpression;
     assert(type.kind != TypeKind.TYPEDEF);
-    if (type.kind == TypeKind.FUNCTION) {
+    if (type.isFunctionType) {
       // TODO(5022): We currently generate $isFunction checks for
       // function types.
       registry.registerIsCheck(compiler.functionClass.rawType);
     }
     registry.registerIsCheck(type);
 
     CheckedModeHelper helper;
     if (node.isBooleanConversionCheck) {
       helper =
           const CheckedModeHelper('boolConversionCheck');
     } else {
       helper =
           backend.getCheckedModeHelper(type, typeCast: node.isCastTypeCheck);
     }
 
     if (helper == null) {
-      assert(type.kind == TypeKind.FUNCTION);
+      assert(type.isFunctionType);
       use(node.inputs[0]);
     } else {
       push(helper.generateCall(this, node));
     }
   }
 
   void visitTypeKnown(HTypeKnown node) {
     // [HTypeKnown] instructions are removed before generating code.
     assert(false);
   }
@@ skipping 94 matching lines @@
   js.PropertyAccess accessHelper(String name) {
     Element helper = compiler.findHelper(name);
     if (helper == null) {
       // For mocked-up tests.
       return js.js('(void 0).$name');
     }
     registry.registerStaticUse(helper);
     return backend.namer.elementAccess(helper);
   }
 }