Use elements/types.dart in codegen.dart

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 '../elements/elements.dart'
     show
         Entity,
         JumpTarget,
         LabelDefinition,
         Local,
         Name,
         AsyncMarker,
         ResolvedAst,
         FunctionElement;
 import '../elements/entities.dart';
-import '../elements/resolution_types.dart';
+import '../elements/types.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;
 import '../universe/use.dart' show DynamicUse, StaticUse, TypeUse;
@@ skipping 2587 matching lines @@
         new js.PropertyAccess(pop(), backend.namer.operatorIsType(type))
             .withSourceInformation(sourceInformation);
     // We always negate at least once so that the result is boolified.
     push(new js.Prefix('!', field).withSourceInformation(sourceInformation));
     // If the result is not negated, put another '!' in front.
     if (!negative) {
       push(new js.Prefix('!', pop()).withSourceInformation(sourceInformation));
     }
   }
 
-  void checkTypeViaInstanceof(
-      HInstruction input, DartType type, SourceInformation sourceInformation,
+  void checkTypeViaInstanceof(HInstruction input, InterfaceType type,
+      SourceInformation sourceInformation,
       {bool negative: false}) {
     registry.registerTypeUse(new TypeUse.isCheck(type));
 
     use(input);
 
     js.Expression jsClassReference =
         backend.emitter.constructorAccess(type.element);
     push(js.js('# instanceof #',
         [pop(), jsClassReference]).withSourceInformation(sourceInformation));
     if (negative) {
       push(new js.Prefix('!', pop()).withSourceInformation(sourceInformation));
     }
     registry.registerInstantiation(type);
   }
 
   void handleNumberOrStringSupertypeCheck(
       HInstruction input,
       HInstruction interceptor,
-      DartType type,
+      InterfaceType type,
       SourceInformation sourceInformation,
       {bool negative: false}) {
     assert(!identical(type.element, commonElements.listClass) &&
         !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,
+      InterfaceType type, SourceInformation sourceInformation,
       {bool negative: false}) {
     assert(!identical(type.element, commonElements.listClass) &&
         !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,
+      InterfaceType type, SourceInformation sourceInformation,
       {bool negative: false}) {
     assert(!identical(type.element, commonElements.stringClass) &&
         !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);
@@ skipping 305 matching lines @@
       case TypeInfoExpressionKind.COMPLETE:
         int index = 0;
         js.Expression result = backend.rtiEncoder.getTypeRepresentation(
             node.dartType, (TypeVariableType variable) => arguments[index++]);
         assert(index == node.inputs.length);
         push(result);
         return;
 
       case TypeInfoExpressionKind.INSTANCE:
         // We expect only flat types for the INSTANCE representation.
-        assert(
-            node.dartType == (node.dartType as InterfaceType).element.thisType);
+        assert((node.dartType as InterfaceType).typeArguments.length ==
+            arguments.length);
         registry.registerInstantiatedClass(commonElements.listClass);
         push(new js.ArrayInitializer(arguments)
             .withSourceInformation(node.sourceInformation));
     }
   }
 
   bool typeVariableAccessNeedsSubstitution(
       TypeVariableEntity element, TypeMask receiverMask) {
     ClassEntity cls = element.typeDeclaration;
 
@@ skipping 83 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);
   }
 }