Further reduce use of Element in codegen.

pkg/compiler/lib/src/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.
 
 import 'dart:math' as math;
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../core_types.dart' show CommonElements;
 import '../dart_types.dart';
-import '../elements/elements.dart';
+import '../elements/elements.dart'
+    show
+        Entity,
+        JumpTarget,
+        LabelDefinition,
+        Local,
+        Name,
+        AsyncMarker,
+        ResolvedAst,
+        FunctionElement;
 import '../elements/entities.dart';
 import '../io/source_information.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart';
 import '../js_emitter/js_emitter.dart' show NativeEmitter;
 import '../native/native.dart' as native;
 import '../types/types.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
@@ skipping 762 matching lines @@
 
   bool visitAndOrInfo(HAndOrBlockInformation info) {
     return false;
   }
 
   bool visitTryInfo(HTryBlockInformation info) {
     js.Block body = generateStatementsInNewBlock(info.body);
     js.Catch catchPart = null;
     js.Block finallyPart = null;
     if (info.catchBlock != null) {
-      void register(ClassElement classElement) {
+      void register(ClassEntity classElement) {
         if (classElement != null) {
           registry.registerInstantiatedClass(classElement);
         }
       }
 
       register(helpers.jsPlainJavaScriptObjectClass);
       register(helpers.jsUnknownJavaScriptObjectClass);
 
       HLocalValue exception = info.catchVariable;
       String name = variableNames.getName(exception);
@@ skipping 826 matching lines @@
           .withSourceInformation(node.sourceInformation));
       registry.registerUseInterceptor();
     }
   }
 
   visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     use(node.receiver);
     js.Expression object = pop();
     String methodName;
     List<js.Expression> arguments = visitArguments(node.inputs);
-    MemberElement target = node.element;
+    MemberEntity target = node.element;
 
     // TODO(herhut): The namer should return the appropriate backendname here.
     if (target != null && !node.isInterceptedCall) {
       if (target == helpers.jsArrayAdd) {
         methodName = 'push';
       } else if (target == helpers.jsArrayRemoveLast) {
         methodName = 'pop';
       } else if (target == helpers.jsStringSplit) {
         methodName = 'split';
         // Split returns a List, so we make sure the backend knows the
@@ skipping 52 matching lines @@
     registry.registerUseInterceptor();
   }
 
   TypeMask getOptimizedSelectorFor(
       HInvokeDynamic node, Selector selector, TypeMask mask) {
     if (node.element != null) {
       // Create an artificial type mask to make sure only
       // [node.element] will be enqueued. We're not using the receiver
       // type because our optimizations might end up in a state where the
       // invoke dynamic knows more than the receiver.
-      ClassElement enclosing = node.element.enclosingClass;
+      ClassEntity enclosing = node.element.enclosingClass;
       if (closedWorld.isInstantiated(enclosing)) {
-        return new TypeMask.nonNullExact(enclosing.declaration, closedWorld);
+        return closedWorld.commonMasks.createNonNullExact(enclosing);
       } else {
         // The element is mixed in so a non-null subtype mask is the most
         // precise we have.
         assert(invariant(node, closedWorld.isUsedAsMixin(enclosing),
             message: "Element ${node.element} from $enclosing expected "
                 "to be mixed in."));
-        return new TypeMask.nonNullSubtype(enclosing.declaration, closedWorld);
+        return closedWorld.commonMasks.createNonNullSubtype(enclosing);
       }
     }
     // If [JSInvocationMirror._invokeOn] is enabled, and this call
     // might hit a `noSuchMethod`, we register an untyped selector.
     return closedWorld.extendMaskIfReachesAll(selector, mask);
   }
 
   void registerMethodInvoke(HInvokeDynamic node) {
     Selector selector = node.selector;
 
     // If we don't know what we're calling or if we are calling a getter,
     // we need to register that fact that we may be calling a closure
     // with the same arguments.
-    MemberElement target = node.element;
+    MemberEntity target = node.element;
     if (target == null || target.isGetter) {
       // TODO(kasperl): If we have a typed selector for the call, we
       // may know something about the types of closures that need
       // the specific closure call method.
       Selector call = new Selector.callClosureFrom(selector);
       registry.registerDynamicUse(new DynamicUse(call, null));
     }
     if (target != null) {
       // This is a dynamic invocation which we have found to have a single
       // target but for some reason haven't inlined. We are _still_ accessing
@@ skipping 61 matching lines @@
     Selector call = new Selector.callClosureFrom(node.selector);
     use(node.receiver);
     push(js
         .propertyCall(pop(), backend.namer.invocationName(call),
             visitArguments(node.inputs))
         .withSourceInformation(node.sourceInformation));
     registry.registerDynamicUse(new DynamicUse(call, null));
   }
 
   visitInvokeStatic(HInvokeStatic node) {
-    MemberElement element = node.element;
+    MemberEntity element = node.element;
     List<DartType> instantiatedTypes = node.instantiatedTypes;
 
     if (instantiatedTypes != null && !instantiatedTypes.isEmpty) {
       instantiatedTypes.forEach((type) {
         registry.registerInstantiation(type);
       });
     }
 
     List<js.Expression> arguments = visitArguments(node.inputs, start: 0);
 
     if (element == backend.helpers.checkConcurrentModificationError) {
       // Manually inline the [checkConcurrentModificationError] function.  This
       // function is only called from a for-loop update.  Ideally we would just
       // generate the conditionalcontrol flow in the builder but it adds basic
       // blocks in the loop update that interfere with other optimizations and
       // confuses loop recognition.
 
       assert(arguments.length == 2);
-      Element throwFunction = backend.helpers.throwConcurrentModificationError;
+      FunctionEntity throwFunction =
+          backend.helpers.throwConcurrentModificationError;
       registry.registerStaticUse(
           new StaticUse.staticInvoke(throwFunction, CallStructure.ONE_ARG));
 
       // Calling using `(0, #)(#)` instead of `#(#)` separates the property load
       // of the static function access from the call.  For some reason this
       // helps V8 see that the call never happens so V8 makes the call a
       // deoptimization. This removes the call from the optimized loop, making
       // more optimizations available to the loop.  This form is 50% faster on
       // some small loop, almost as fast as loops with no concurrent
       // modification check.
       push(js.js('# || (0, #)(#)', [
         arguments[0],
         backend.emitter.staticFunctionAccess(throwFunction),
         arguments[1]
       ]));
     } else {
       CallStructure callStructure = new CallStructure.unnamed(arguments.length);
       registry.registerStaticUse(element.isConstructor
           ? new StaticUse.constructorInvoke(element, callStructure)
           : new StaticUse.staticInvoke(element, callStructure));
       push(backend.emitter.staticFunctionAccess(element));
       push(new js.Call(pop(), arguments,
           sourceInformation: node.sourceInformation));
     }
   }
 
   visitInvokeSuper(HInvokeSuper node) {
-    MemberElement superElement = node.element;
-    ClassElement superClass = superElement.enclosingClass;
+    MemberEntity superElement = node.element;
+    ClassEntity superClass = superElement.enclosingClass;
     if (superElement.isField) {
       js.Name fieldName = backend.namer.instanceFieldPropertyName(superElement);
       use(node.inputs[0]);
       js.PropertyAccess access = new js.PropertyAccess(pop(), fieldName)
           .withSourceInformation(node.sourceInformation);
       if (node.isSetter) {
         registry.registerStaticUse(superElement.isSetter
             ? new StaticUse.superSetterSet(superElement)
             : new StaticUse.superFieldSet(superElement));
         use(node.value);
         push(new js.Assignment(access, pop())
             .withSourceInformation(node.sourceInformation));
       } else {
         registry.registerStaticUse(new StaticUse.superGet(superElement));
         push(access);
       }
     } else {
       Selector selector = node.selector;
       if (!backend.maybeRegisterAliasedSuperMember(superElement, selector)) {
         js.Name methodName;
         if (selector.isGetter && !superElement.isGetter) {
           // If this is a tear-off, register the fact that a tear-off closure
           // will be created, and that this tear-off must bypass ordinary
           // dispatch to ensure the super method is invoked.
-          FunctionElement helper = backend.helpers.closureFromTearOff;
+          FunctionEntity helper = backend.helpers.closureFromTearOff;
           registry.registerStaticUse(new StaticUse.staticInvoke(
-              helper, new CallStructure.unnamed(helper.parameters.length)));
+              helper, compiler.codegenWorld.getCallStructureFor(helper)));
           registry.registerStaticUse(new StaticUse.superTearOff(node.element));
           methodName = backend.namer.invocationName(selector);
         } else {
           methodName = backend.namer.instanceMethodName(superElement);
         }
         registry.registerStaticUse(new StaticUse.superInvoke(
             superElement, new CallStructure.unnamed(node.inputs.length)));
         push(js.js('#.#.call(#)', [
           backend.emitter
               .prototypeAccess(superClass, hasBeenInstantiated: true),
           methodName,
           visitArguments(node.inputs, start: 0)
         ]).withSourceInformation(node.sourceInformation));
       } else {
         use(node.receiver);
         registry.registerStaticUse(new StaticUse.superInvoke(
             superElement, new CallStructure.unnamed(node.inputs.length - 1)));
         push(js.js('#.#(#)', [
           pop(),
           backend.namer.aliasedSuperMemberPropertyName(superElement),
           visitArguments(node.inputs, start: 1)
         ]) // Skip receiver argument.
             .withSourceInformation(node.sourceInformation));
       }
     }
   }
 
   visitFieldGet(HFieldGet node) {
     use(node.receiver);
-    MemberElement element = node.element;
+    MemberEntity element = node.element;
     if (node.isNullCheck) {
       // We access a JavaScript member we know all objects besides
       // null and undefined have: V8 does not like accessing a member
       // that does not exist.
       push(new js.PropertyAccess.field(pop(), 'toString')
           .withSourceInformation(node.sourceInformation));
     } else if (element == helpers.jsIndexableLength) {
       // We're accessing a native JavaScript property called 'length'
       // on a JS String or a JS array. Therefore, the name of that
       // property should not be mangled.
       push(new js.PropertyAccess.field(pop(), 'length')
           .withSourceInformation(node.sourceInformation));
     } else {
-      js.Name name = backend.namer.instanceFieldPropertyName(element);
+      FieldEntity field = element;
+      js.Name name = backend.namer.instanceFieldPropertyName(field);
       push(new js.PropertyAccess(pop(), name)
           .withSourceInformation(node.sourceInformation));
-      registry.registerStaticUse(new StaticUse.fieldGet(element));
+      registry.registerStaticUse(new StaticUse.fieldGet(field));
     }
   }
 
   visitFieldSet(HFieldSet node) {
-    MemberElement element = node.element;
+    MemberEntity element = node.element;
     registry.registerStaticUse(new StaticUse.fieldSet(element));
     js.Name name = backend.namer.instanceFieldPropertyName(element);
     use(node.receiver);
     js.Expression receiver = pop();
     use(node.value);
     push(new js.Assignment(new js.PropertyAccess(receiver, name), pop())
         .withSourceInformation(node.sourceInformation));
   }
 
   visitReadModifyWrite(HReadModifyWrite node) {
-    FieldElement element = node.element;
+    FieldEntity element = node.element;
     registry.registerStaticUse(new StaticUse.fieldGet(element));
     registry.registerStaticUse(new StaticUse.fieldSet(element));
     js.Name name = backend.namer.instanceFieldPropertyName(element);
     use(node.receiver);
     js.Expression fieldReference = new js.PropertyAccess(pop(), name);
     if (node.isPreOp) {
       push(new js.Prefix(node.jsOp, fieldReference)
           .withSourceInformation(node.sourceInformation));
     } else if (node.isPostOp) {
       push(new js.Postfix(node.jsOp, fieldReference)
@@ skipping 77 matching lines @@
   void generateConstant(
       ConstantValue constant, SourceInformation sourceInformation) {
     if (constant.isFunction) {
       FunctionConstantValue function = constant;
       registry.registerStaticUse(new StaticUse.staticTearOff(function.element));
     }
     if (constant.isType) {
       // If the type is a web component, we need to ensure the constructors are
       // available to 'upgrade' the native object.
       TypeConstantValue type = constant;
-      Element element = type.representedType.element;
-      if (element != null && element.isClass) {
-        registry.registerTypeConstant(element);
+      if (type.representedType.isInterfaceType) {
+        registry.registerTypeConstant(type.representedType.element);
       }
     }
     js.Expression expression = backend.emitter.constantReference(constant);
     if (!constant.isDummy) {
       // TODO(johnniwinther): Support source information on synthetic constants.
       expression = expression.withSourceInformation(sourceInformation);
     }
     push(expression);
   }
 
@@ skipping 203 matching lines @@
       currentContainer = oldContainer;
       thenBody = unwrapStatement(thenBody);
       pushStatement(new js.If.noElse(underOver, thenBody)
           .withSourceInformation(node.sourceInformation));
     } else {
       generateThrowWithHelper(
           helpers.throwIndexOutOfRangeException, [node.array, node.index]);
     }
   }
 
-  void generateThrowWithHelper(Element helper, argument,
+  void generateThrowWithHelper(FunctionEntity helper, argument,
       {SourceInformation sourceInformation}) {
     js.Expression jsHelper = backend.emitter.staticFunctionAccess(helper);
     List arguments = [];
     if (argument is List) {
       argument.forEach((instruction) {
         use(instruction);
         arguments.add(pop());
       });
     } else {
       use(argument);
       arguments.add(pop());
     }
     registry.registerStaticUse(new StaticUse.staticInvoke(
         helper, new CallStructure.unnamed(arguments.length)));
     js.Call value = new js.Call(jsHelper, arguments.toList(growable: false),
         sourceInformation: sourceInformation);
     // BUG(4906): Using throw/return here adds to the size of the generated code
     // but it has the advantage of explicitly telling the JS engine that
     // this code path will terminate abruptly. Needs more work.
     if (helper == helpers.wrapExceptionHelper) {
       pushStatement(
           new js.Throw(value).withSourceInformation(sourceInformation));
     } else {
-      Element element = work.element;
+      Entity element = work.element;
       if (element is FunctionElement && element.asyncMarker.isYielding) {
         // `return <expr>;` is illegal in a sync* or async* function.
         // To have the async-translator working, we avoid introducing
         // `return` nodes.
         pushStatement(new js.ExpressionStatement(value)
             .withSourceInformation(sourceInformation));
       } else {
         pushStatement(
             new js.Return(value).withSourceInformation(sourceInformation));
       }
     }
   }
 
   visitThrowExpression(HThrowExpression node) {
     HInstruction argument = node.inputs[0];
     use(argument);
 
-    Element helper = helpers.throwExpressionHelper;
+    FunctionEntity helper = helpers.throwExpressionHelper;
     registry.registerStaticUse(
         new StaticUse.staticInvoke(helper, CallStructure.ONE_ARG));
 
     js.Expression jsHelper = backend.emitter.staticFunctionAccess(helper);
     js.Call value = new js.Call(jsHelper, [pop()])
         .withSourceInformation(node.sourceInformation);
     push(value);
   }
 
   void visitSwitch(HSwitch node) {
@@ skipping 53 matching lines @@
       if (node.usedBy.length == 1 &&
           node.usedBy[0] is HStringConcat &&
           node.usedBy[0].inputs[1] == node) {
         // The context is already <string> + value.
       } else {
         // Force an empty string for the first operand.
         push(new js.Binary('+', js.string(""), pop())
             .withSourceInformation(node.sourceInformation));
       }
     } else {
-      Element convertToString = backend.helpers.stringInterpolationHelper;
+      FunctionEntity convertToString =
+          backend.helpers.stringInterpolationHelper;
       registry.registerStaticUse(
           new StaticUse.staticInvoke(convertToString, CallStructure.ONE_ARG));
       js.Expression jsHelper =
           backend.emitter.staticFunctionAccess(convertToString);
       use(input);
       push(new js.Call(jsHelper, <js.Expression>[pop()],
           sourceInformation: node.sourceInformation));
     }
   }
 
@@ skipping 138 matching lines @@
   }
 
   void checkNonNull(HInstruction input) {
     use(input);
     push(new js.Binary('!=', pop(), new js.LiteralNull()));
   }
 
   void checkType(HInstruction input, HInstruction interceptor, DartType type,
       SourceInformation sourceInformation,
       {bool negative: false}) {
-    Element element = type.element;
-    if (element == helpers.jsArrayClass) {
-      checkArray(input, negative ? '!==' : '===');
-      return;
-    } else if (element == helpers.jsMutableArrayClass) {
-      if (negative) {
-        checkImmutableArray(input);
-      } else {
-        checkMutableArray(input);
+    if (type.isInterfaceType) {
+      InterfaceType interfaceType = type;
+      ClassEntity element = interfaceType.element;
+      if (element == helpers.jsArrayClass) {
+        checkArray(input, negative ? '!==' : '===');
+        return;
+      } else if (element == helpers.jsMutableArrayClass) {
+        if (negative) {
+          checkImmutableArray(input);
+        } else {
+          checkMutableArray(input);
+        }
+        return;
+      } else if (element == helpers.jsExtendableArrayClass) {
+        if (negative) {
+          checkFixedArray(input);
+        } else {
+          checkExtendableArray(input);
+        }
+        return;
+      } else if (element == helpers.jsFixedArrayClass) {
+        if (negative) {
+          checkExtendableArray(input);
+        } else {
+          checkFixedArray(input);
+        }
+        return;
+      } else if (element == helpers.jsUnmodifiableArrayClass) {
+        if (negative) {
+          checkMutableArray(input);
+        } else {
+          checkImmutableArray(input);
+        }
+        return;
       }
-      return;
-    } else if (element == helpers.jsExtendableArrayClass) {
-      if (negative) {
-        checkFixedArray(input);
-      } else {
-        checkExtendableArray(input);
-      }
-      return;
-    } else if (element == helpers.jsFixedArrayClass) {
-      if (negative) {
-        checkExtendableArray(input);
-      } else {
-        checkFixedArray(input);
-      }
-      return;
-    } else if (element == helpers.jsUnmodifiableArrayClass) {
-      if (negative) {
-        checkMutableArray(input);
-      } else {
-        checkImmutableArray(input);
-      }
-      return;
     }
     if (interceptor != null) {
       checkTypeViaProperty(interceptor, type, sourceInformation,
           negative: negative);
     } else {
       checkTypeViaProperty(input, type, sourceInformation, negative: negative);
     }
   }
 
   void checkTypeViaProperty(
@@ skipping 31 matching lines @@
     registry.registerInstantiation(type);
   }
 
   void handleNumberOrStringSupertypeCheck(
       HInstruction input,
       HInstruction interceptor,
       DartType type,
       SourceInformation sourceInformation,
       {bool negative: false}) {
     assert(!identical(type.element, commonElements.listClass) &&
-        !Elements.isListSupertype(type.element, commonElements) &&
-        !Elements.isStringOnlySupertype(type.element, commonElements));
+        !commonElements.isListSupertype(type.element) &&
+        !commonElements.isStringOnlySupertype(type.element));
     String relation = negative ? '!==' : '===';
     checkNum(input, relation, sourceInformation);
     js.Expression numberTest = pop();
     checkString(input, relation, sourceInformation);
     js.Expression stringTest = pop();
     checkObject(input, relation, sourceInformation);
     js.Expression objectTest = pop();
     checkType(input, interceptor, type, sourceInformation, negative: negative);
     String combiner = negative ? '&&' : '||';
     String combiner2 = negative ? '||' : '&&';
     push(new js.Binary(
             combiner,
             new js.Binary(combiner, numberTest, stringTest)
                 .withSourceInformation(sourceInformation),
             new js.Binary(combiner2, objectTest, pop())
                 .withSourceInformation(sourceInformation))
         .withSourceInformation(sourceInformation));
   }
 
   void handleStringSupertypeCheck(HInstruction input, HInstruction interceptor,
       DartType type, SourceInformation sourceInformation,
       {bool negative: false}) {
     assert(!identical(type.element, commonElements.listClass) &&
-        !Elements.isListSupertype(type.element, commonElements) &&
-        !Elements.isNumberOrStringSupertype(type.element, commonElements));
+        !commonElements.isListSupertype(type.element) &&
+        !commonElements.isNumberOrStringSupertype(type.element));
     String relation = negative ? '!==' : '===';
     checkString(input, relation, sourceInformation);
     js.Expression stringTest = pop();
     checkObject(input, relation, sourceInformation);
     js.Expression objectTest = pop();
     checkType(input, interceptor, type, sourceInformation, negative: negative);
     String combiner = negative ? '||' : '&&';
     push(new js.Binary(negative ? '&&' : '||', stringTest,
         new js.Binary(combiner, objectTest, pop())));
   }
 
   void handleListOrSupertypeCheck(HInstruction input, HInstruction interceptor,
       DartType type, SourceInformation sourceInformation,
       {bool negative: false}) {
     assert(!identical(type.element, commonElements.stringClass) &&
-        !Elements.isStringOnlySupertype(type.element, commonElements) &&
-        !Elements.isNumberOrStringSupertype(type.element, commonElements));
+        !commonElements.isStringOnlySupertype(type.element) &&
+        !commonElements.isNumberOrStringSupertype(type.element));
     String relation = negative ? '!==' : '===';
     checkObject(input, relation, sourceInformation);
     js.Expression objectTest = pop();
     checkArray(input, relation);
     js.Expression arrayTest = pop();
     checkType(input, interceptor, type, sourceInformation, negative: negative);
     String combiner = negative ? '&&' : '||';
     push(new js.Binary(negative ? '||' : '&&', objectTest,
             new js.Binary(combiner, arrayTest, pop()))
         .withSourceInformation(sourceInformation));
@@ skipping 16 matching lines @@
     // be changed to match.
     assert(relation == '===' || relation == '!==');
     bool negative = relation == '!==';
 
     if (node.isVariableCheck || node.isCompoundCheck) {
       use(node.checkCall);
       if (negative) push(new js.Prefix('!', pop()));
     } else {
       assert(node.isRawCheck);
       HInstruction interceptor = node.interceptor;
-      ClassElement objectClass = commonElements.objectClass;
-      Element element = type.element;
+      InterfaceType interfaceType = type;
+      ClassEntity element = interfaceType.element;
       if (element == commonElements.nullClass) {
         if (negative) {
           checkNonNull(input);
         } else {
           checkNull(input);
         }
-      } else if (identical(element, objectClass) || type.treatAsDynamic) {
+      } else if (element ==
+          commonElements.objectClass /* || type.treatAsDynamic*/) {
         // The constant folder also does this optimization, but we make
         // it safe by assuming it may have not run.
         push(newLiteralBool(!negative, sourceInformation));
       } else if (element == commonElements.stringClass) {
         checkString(input, relation, sourceInformation);
       } else if (element == commonElements.doubleClass) {
         checkDouble(input, relation, sourceInformation);
       } else if (element == commonElements.numClass) {
         checkNum(input, relation, sourceInformation);
       } else if (element == commonElements.boolClass) {
         checkBool(input, relation, sourceInformation);
       } else if (element == commonElements.intClass) {
         // The is check in the code tells us that it might not be an
         // int. So we do a typeof first to avoid possible
         // deoptimizations on the JS engine due to the Math.floor check.
         checkNum(input, relation, sourceInformation);
         js.Expression numTest = pop();
         checkBigInt(input, relation, sourceInformation);
         push(new js.Binary(negative ? '||' : '&&', numTest, pop())
             .withSourceInformation(sourceInformation));
       } else if (node.useInstanceOf) {
         assert(interceptor == null);
         checkTypeViaInstanceof(input, type, sourceInformation,
             negative: negative);
-      } else if (Elements.isNumberOrStringSupertype(element, commonElements)) {
+      } else if (commonElements.isNumberOrStringSupertype(element)) {
         handleNumberOrStringSupertypeCheck(
             input, interceptor, type, sourceInformation,
             negative: negative);
-      } else if (Elements.isStringOnlySupertype(element, commonElements)) {
+      } else if (commonElements.isStringOnlySupertype(element)) {
         handleStringSupertypeCheck(input, interceptor, type, sourceInformation,
             negative: negative);
-      } else if (identical(element, commonElements.listClass) ||
-          Elements.isListSupertype(element, commonElements)) {
+      } else if (element == commonElements.listClass ||
+          commonElements.isListSupertype(element)) {
         handleListOrSupertypeCheck(input, interceptor, type, sourceInformation,
             negative: negative);
       } else if (type.isFunctionType) {
         checkType(input, interceptor, type, sourceInformation,
             negative: negative);
       } else if ((input.canBePrimitive(closedWorld) &&
               !input.canBePrimitiveArray(closedWorld)) ||
           input.canBeNull()) {
         checkObject(input, relation, node.sourceInformation);
         js.Expression objectTest = pop();
@@ skipping 80 matching lines @@
       }
       currentContainer = oldContainer;
       body = unwrapStatement(body);
       pushStatement(new js.If.noElse(test, body)
           .withSourceInformation(node.sourceInformation));
       return;
     }
 
     assert(node.isCheckedModeCheck || node.isCastTypeCheck);
     DartType type = node.typeExpression;
-    assert(type.kind != TypeKind.TYPEDEF);
+    assert(!type.isTypedef);
     if (type.isFunctionType) {
       // TODO(5022): We currently generate $isFunction checks for
       // function types.
       registry.registerTypeUse(
           new TypeUse.isCheck(compiler.commonElements.functionType));
     }
     registry.registerTypeUse(new TypeUse.isCheck(type));
 
     CheckedModeHelper helper;
     if (node.isBooleanConversionCheck) {
@@ skipping 76 matching lines @@
     }
   }
 
   void visitTypeInfoReadRaw(HTypeInfoReadRaw node) {
     use(node.inputs[0]);
     js.Expression receiver = pop();
     push(js.js(r'#.#', [receiver, backend.namer.rtiFieldName]));
   }
 
   void visitTypeInfoReadVariable(HTypeInfoReadVariable node) {
-    TypeVariableElement element = node.variable.element;
+    TypeVariableEntity element = node.variable.element;
 
     int index = element.index;
     HInstruction object = node.object;
     use(object);
     js.Expression receiver = pop();
 
     if (typeVariableAccessNeedsSubstitution(element, object.instructionType)) {
       js.Expression typeName =
-          js.quoteName(backend.namer.runtimeTypeName(element.enclosingClass));
-      Element helperElement = helpers.getRuntimeTypeArgument;
+          js.quoteName(backend.namer.runtimeTypeName(element.typeDeclaration));
+      FunctionEntity helperElement = helpers.getRuntimeTypeArgument;
       registry.registerStaticUse(
           new StaticUse.staticInvoke(helperElement, CallStructure.THREE_ARGS));
       js.Expression helper =
           backend.emitter.staticFunctionAccess(helperElement);
       push(js.js(
           r'#(#, #, #)', [helper, receiver, typeName, js.js.number(index)]));
     } else {
-      Element helperElement = helpers.getTypeArgumentByIndex;
+      FunctionEntity helperElement = helpers.getTypeArgumentByIndex;
       registry.registerStaticUse(
           new StaticUse.staticInvoke(helperElement, CallStructure.TWO_ARGS));
       js.Expression helper =
           backend.emitter.staticFunctionAccess(helperElement);
       push(js.js(r'#(#, #)', [helper, receiver, js.js.number(index)]));
     }
   }
 
   void visitTypeInfoExpression(HTypeInfoExpression node) {
     List<js.Expression> arguments = <js.Expression>[];
@@ skipping 15 matching lines @@
         // We expect only flat types for the INSTANCE representation.
         assert(
             node.dartType == (node.dartType as InterfaceType).element.thisType);
         registry.registerInstantiatedClass(commonElements.listClass);
         push(new js.ArrayInitializer(arguments)
             .withSourceInformation(node.sourceInformation));
     }
   }
 
   bool typeVariableAccessNeedsSubstitution(
-      TypeVariableElement element, TypeMask receiverMask) {
-    ClassElement cls = element.enclosingClass;
+      TypeVariableEntity element, TypeMask receiverMask) {
+    ClassEntity cls = element.typeDeclaration;
 
     // See if the receiver type narrows the set of classes to ones that can be
     // indexed.
     // TODO(sra): Currently the only convenient query is [singleClass]. We
     // should iterate over all the concrete classes in [receiverMask].
-    ClassElement receiverClass = receiverMask.singleClass(closedWorld);
+    ClassEntity receiverClass = receiverMask.singleClass(closedWorld);
     if (receiverClass != null) {
       if (backend.rti.isTrivialSubstitution(receiverClass, cls)) {
         return false;
       }
     }
 
     if (closedWorld.isUsedAsMixin(cls)) return true;
 
-    return closedWorld.anyStrictSubclassOf(cls, (ClassElement subclass) {
+    return closedWorld.anyStrictSubclassOf(cls, (ClassEntity subclass) {
       return !backend.rti.isTrivialSubstitution(subclass, cls);
     });
   }
 
   void visitReadTypeVariable(HReadTypeVariable node) {
-    TypeVariableElement element = node.dartType.element;
-    Element helperElement = helpers.convertRtiToRuntimeType;
+    TypeVariableEntity element = node.dartType.element;
+    FunctionEntity helperElement = helpers.convertRtiToRuntimeType;
     registry.registerStaticUse(
         new StaticUse.staticInvoke(helperElement, CallStructure.ONE_ARG));
 
     use(node.inputs[0]);
     if (node.hasReceiver) {
-      if (backend.isInterceptorClass(element.enclosingClass)) {
+      if (backend.isInterceptorClass(element.typeDeclaration)) {
         int index = element.index;
         js.Expression receiver = pop();
         js.Expression helper =
             backend.emitter.staticFunctionAccess(helperElement);
         js.Expression rtiFieldName = backend.namer.rtiFieldName;
         push(js.js(r'#(#.# && #.#[#])', [
           helper,
           receiver,
           rtiFieldName,
           receiver,
@@ skipping 11 matching lines @@
     }
   }
 
   void visitInterfaceType(HInterfaceType node) {
     List<js.Expression> typeArguments = <js.Expression>[];
     for (HInstruction type in node.inputs) {
       use(type);
       typeArguments.add(pop());
     }
     InterfaceType type = node.dartType;
-    ClassElement cls = type.element;
+    ClassEntity cls = type.element;
     var arguments = [backend.emitter.typeAccess(cls)];
     if (!typeArguments.isEmpty) {
       arguments.add(new js.ArrayInitializer(typeArguments));
     }
     push(js.js('#(#)', [
       accessHelper(helpers.buildInterfaceType, arguments.length),
       arguments
     ]));
   }
 
@@ skipping 14 matching lines @@
     registry.registerStaticUse(new StaticUse.staticInvoke(
         helper, new CallStructure.unnamed(argumentCount)));
     return backend.emitter.staticFunctionAccess(helper);
   }
 
   @override
   void visitRef(HRef node) {
     visit(node.value);
   }
 }