Remove element from DynamicType.

sdk/lib/_internal/compiler/implementation/ssa/builder.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;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to implement [TypedElement.type] because our
  * optimizers may look at its declared type.
@@ skipping 2182 matching lines @@
   /// Build a [HTypeConversion] for convertion [original] to type [type].
   ///
   /// Invariant: [type] must be valid in the context.
   /// See [LocalsHandler.substInContext].
   HInstruction buildTypeConversion(HInstruction original,
                                    DartType type,
                                    int kind) {
     if (type == null) return original;
     type = type.unalias(compiler);
     assert(assertTypeInContext(type, original));
-    if (type.kind == TypeKind.INTERFACE && !type.treatAsRaw) {
+    if (type.isInterfaceType && !type.treatAsRaw) {
       TypeMask subtype = new TypeMask.subtype(type.element);
       HInstruction representations = buildTypeArgumentRepresentations(type);
       add(representations);
       return new HTypeConversion.withTypeRepresentation(type, kind, subtype,
           original, representations);
-    } else if (type.kind == TypeKind.TYPE_VARIABLE) {
+    } else if (type.isTypeVariable) {
       TypeMask subtype = original.instructionType;
       HInstruction typeVariable = addTypeVariableReference(type);
       return new HTypeConversion.withTypeRepresentation(type, kind, subtype,
           original, typeVariable);
-    } else if (type.kind == TypeKind.FUNCTION) {
+    } else if (type.isFunctionType) {
       String name = kind == HTypeConversion.CAST_TYPE_CHECK
           ? '_asCheck' : '_assertCheck';
 
       List arguments = [buildFunctionType(type), original];
       pushInvokeDynamic(
           null,
           new Selector.call(name, compiler.jsHelperLibrary, 1),
           arguments);
 
       return new HTypeConversion(type, kind, original.instructionType, pop());
@@ skipping 910 matching lines @@
 
   HLiteralList buildLiteralList(List<HInstruction> inputs) {
     return new HLiteralList(inputs, backend.extendableArrayType);
   }
 
   // TODO(karlklose): change construction of the representations to be GVN'able
   // (dartbug.com/7182).
   HInstruction buildTypeArgumentRepresentations(DartType type) {
     // Compute the representation of the type arguments, including access
     // to the runtime type information for type variables as instructions.
-    if (type.kind == TypeKind.TYPE_VARIABLE) {
+    if (type.isTypeVariable) {
       return buildLiteralList(<HInstruction>[addTypeVariableReference(type)]);
     } else {
       assert(type.element.isClass);
       InterfaceType interface = type;
       List<HInstruction> inputs = <HInstruction>[];
       bool first = true;
       List<String> templates = <String>[];
       for (DartType argument in interface.typeArguments) {
         templates.add(rti.getTypeRepresentationWithHashes(argument, (variable) {
           HInstruction runtimeType = addTypeVariableReference(variable);
@@ skipping 20 matching lines @@
     } else if ("!" == op.source) {
       visitLogicalNot(node);
     } else if (node.argumentsNode is ast.Prefix) {
       visitUnary(node, op);
     } else if ("is" == op.source) {
       visitIsSend(node);
     } else if ("as" == op.source) {
       visit(node.receiver);
       HInstruction expression = pop();
       DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast);
-      if (type.kind == TypeKind.MALFORMED_TYPE) {
+      if (type.isMalformed) {
         ErroneousElement element = type.element;
         generateTypeError(node, element.message);
       } else {
         HInstruction converted = buildTypeConversion(
             expression,
             localsHandler.substInContext(type),
             HTypeConversion.CAST_TYPE_CHECK);
         if (converted != expression) add(converted);
         stack.add(converted);
       }
@@ skipping 16 matching lines @@
       add(instruction);
       instruction = new HNot(instruction, backend.boolType);
     }
     push(instruction);
   }
 
   HInstruction buildIsNode(ast.Node node,
                            DartType type,
                            HInstruction expression) {
     type = localsHandler.substInContext(type).unalias(compiler);
-    if (type.kind == TypeKind.FUNCTION) {
+    if (type.isFunctionType) {
       List arguments = [buildFunctionType(type), expression];
       pushInvokeDynamic(
           node, new Selector.call('_isTest', compiler.jsHelperLibrary, 1),
           arguments);
       return new HIs.compound(type, expression, pop(), backend.boolType);
-    } else if (type.kind == TypeKind.TYPE_VARIABLE) {
+    } else if (type.isTypeVariable) {
       HInstruction runtimeType = addTypeVariableReference(type);
       Element helper = backend.getCheckSubtypeOfRuntimeType();
       List<HInstruction> inputs = <HInstruction>[expression, runtimeType];
       pushInvokeStatic(null, helper, inputs, backend.boolType);
       HInstruction call = pop();
       return new HIs.variable(type, expression, call, backend.boolType);
     } else if (RuntimeTypes.hasTypeArguments(type)) {
       ClassElement element = type.element;
       Element helper = backend.getCheckSubtype();
       HInstruction representations =
           buildTypeArgumentRepresentations(type);
       add(representations);
       String operator = backend.namer.operatorIs(element);
       HInstruction isFieldName = addConstantString(operator);
       HInstruction asFieldName = compiler.world.hasAnySubtype(element)
           ? addConstantString(backend.namer.substitutionName(element))
           : graph.addConstantNull(compiler);
       List<HInstruction> inputs = <HInstruction>[expression,
                                                  isFieldName,
                                                  representations,
                                                  asFieldName];
       pushInvokeStatic(node, helper, inputs, backend.boolType);
       HInstruction call = pop();
       return new HIs.compound(type, expression, call, backend.boolType);
-    } else if (type.kind == TypeKind.MALFORMED_TYPE) {
+    } else if (type.isMalformed) {
       ErroneousElement element = type.element;
       generateTypeError(node, element.message);
       HInstruction call = pop();
       return new HIs.compound(type, expression, call, backend.boolType);
     } else {
       if (backend.hasDirectCheckFor(type)) {
         return new HIs.direct(type, expression, backend.boolType);
       }
       // TODO(johnniwinther): Avoid interceptor if unneeded.
       return new HIs.raw(
@@ skipping 657 matching lines @@
     }
   }
 
   HInstruction analyzeTypeArgument(DartType argument) {
     assert(assertTypeInContext(argument));
     if (argument.treatAsDynamic) {
       // Represent [dynamic] as [null].
       return graph.addConstantNull(compiler);
     }
 
-    if (argument.kind == TypeKind.TYPE_VARIABLE) {
+    if (argument.isTypeVariable) {
       return addTypeVariableReference(argument);
     }
 
     List<HInstruction> inputs = <HInstruction>[];
 
     String template = rti.getTypeRepresentationWithHashes(argument, (variable) {
       inputs.add(addTypeVariableReference(variable));
     });
 
     js.Template code = js.js.uncachedExpressionTemplate(template);
@@ skipping 2375 matching lines @@
       namedParameterTypes.head.accept(this, builder);
       inputs.add(builder.pop());
       namedParameterTypes = namedParameterTypes.tail;
     }
 
     ClassElement cls = builder.compiler.findHelper('RuntimeFunctionType');
     builder.push(new HFunctionType(inputs, type, new TypeMask.exact(cls)));
   }
 
   void visitMalformedType(MalformedType type, SsaBuilder builder) {
-    visitDynamicType(builder.compiler.types.dynamicType, builder);
+    visitDynamicType(const DynamicType(), builder);
   }
 
   void visitStatementType(StatementType type, SsaBuilder builder) {
     throw 'not implemented visitStatementType($type)';
   }
 
   void visitGenericType(GenericType type, SsaBuilder builder) {
     throw 'not implemented visitGenericType($type)';
   }
 
@@ skipping 16 matching lines @@
     DartType unaliased = type.unalias(builder.compiler);
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     ClassElement cls = builder.compiler.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls)));
   }
 }