Use entities.dart and types.dart in kernel impact computation.

pkg/compiler/lib/src/ssa/kernel_impact.dart

 // Copyright (c) 2016, 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 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
-import '../elements/resolution_types.dart';
-import '../elements/elements.dart';
+import '../elements/types.dart';
+import '../elements/elements.dart' show AstElement, ResolvedAst;
+import '../elements/entities.dart';
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../kernel/kernel.dart';
 import '../kernel/kernel_debug.dart';
-import '../kernel/kernel_visitor.dart';
 import '../resolution/registry.dart' show ResolutionWorldImpactBuilder;
 import '../universe/call_structure.dart';
 import '../universe/feature.dart';
 import '../universe/selector.dart';
 import '../universe/use.dart';
 
 import 'kernel_ast_adapter.dart';
 import '../common/resolution.dart';
 
 /// Computes the [ResolutionImpact] for [resolvedAst] through kernel.
@@ skipping 44 matching lines @@
   KernelAstAdapter astAdapter;
 
   KernelImpactBuilder(this.resolvedAst, this.compiler, Kernel kernel) {
     this.impactBuilder =
         new ResolutionWorldImpactBuilder('${resolvedAst.element}');
     this.astAdapter = new KernelAstAdapter(kernel, compiler.backend,
         resolvedAst, kernel.nodeToAst, kernel.nodeToElement);
   }
 
   /// Add a checked-mode type use of [type] if it is not `dynamic`.
-  ResolutionDartType checkType(ir.DartType irType) {
-    ResolutionDartType type = astAdapter.getDartType(irType);
+  DartType checkType(ir.DartType irType) {
+    DartType type = astAdapter.getDartType(irType);
     if (!type.isDynamic) {
       impactBuilder.registerTypeUse(new TypeUse.checkedModeCheck(type));
     }
     return type;
   }
 
   /// Add checked-mode type use for the parameter type and constant for the
   /// default value of [parameter].
   void handleParameter(ir.VariableDeclaration parameter) {
     checkType(parameter.type);
@@ skipping 119 matching lines @@
   }
 
   @override
   void visitNullLiteral(ir.NullLiteral literal) {
     impactBuilder.registerConstantLiteral(new NullConstantExpression());
   }
 
   @override
   void visitListLiteral(ir.ListLiteral literal) {
     visitNodes(literal.expressions);
-    ResolutionDartType elementType = checkType(literal.typeArgument);
+    DartType elementType = checkType(literal.typeArgument);
 
     impactBuilder.registerListLiteral(new ListLiteralUse(
         compiler.commonElements.listType(elementType),
         isConstant: literal.isConst,
         isEmpty: literal.expressions.isEmpty));
   }
 
   @override
   void visitMapLiteral(ir.MapLiteral literal) {
     visitNodes(literal.entries);
-    ResolutionDartType keyType = checkType(literal.keyType);
-    ResolutionDartType valueType = checkType(literal.valueType);
+    DartType keyType = checkType(literal.keyType);
+    DartType valueType = checkType(literal.valueType);
     impactBuilder.registerMapLiteral(new MapLiteralUse(
         compiler.commonElements.mapType(keyType, valueType),
         isConstant: literal.isConst,
         isEmpty: literal.entries.isEmpty));
   }
 
   void visitMapEntry(ir.MapEntry entry) {
     visitNode(entry.key);
     visitNode(entry.value);
   }
 
   void _visitArguments(ir.Arguments arguments) {
     arguments.positional.forEach(visitNode);
     arguments.named.forEach(visitNode);
   }
 
   @override
   void visitConstructorInvocation(ir.ConstructorInvocation node) {
     handleNew(node, node.target, isConst: node.isConst);
   }
 
   void handleNew(ir.InvocationExpression node, ir.Member target,
       {bool isConst: false}) {
     _visitArguments(node.arguments);
-    ConstructorElement constructor = astAdapter.getConstructor(target);
-    ClassElement cls = astAdapter.getClass(target.enclosingClass);
-    List<ResolutionDartType> typeArguments =
+    FunctionEntity constructor = astAdapter.getConstructor(target);
+    ClassEntity cls = astAdapter.getClass(target.enclosingClass);
+    List<DartType> typeArguments =
         astAdapter.getDartTypes(node.arguments.types);
-    ResolutionInterfaceType type =
-        new ResolutionInterfaceType(cls, typeArguments);
+    InterfaceType type = astAdapter.createInterfaceType(cls, typeArguments);
     CallStructure callStructure = astAdapter.getCallStructure(node.arguments);
     impactBuilder.registerStaticUse(isConst
         ? new StaticUse.constConstructorInvoke(constructor, callStructure, type)
         : new StaticUse.typedConstructorInvoke(
             constructor, callStructure, type));
-    if (typeArguments.any((ResolutionDartType type) => !type.isDynamic)) {
+    if (typeArguments.any((DartType type) => !type.isDynamic)) {
       impactBuilder.registerFeature(Feature.TYPE_VARIABLE_BOUNDS_CHECK);
     }
   }
 
   @override
   void visitSuperInitializer(ir.SuperInitializer node) {
-    ConstructorElement target = astAdapter.getConstructor(node.target);
+    FunctionEntity target = astAdapter.getConstructor(node.target);
     _visitArguments(node.arguments);
     impactBuilder.registerStaticUse(new StaticUse.superConstructorInvoke(
         target, astAdapter.getCallStructure(node.arguments)));
   }
 
   @override
   void visitStaticInvocation(ir.StaticInvocation node) {
-    MethodElement target = astAdapter.getMethod(node.target);
-    if (target.isFactoryConstructor) {
+    FunctionEntity target = astAdapter.getMethod(node.target);
+    if (node.target.kind == ir.ProcedureKind.Factory) {
       // TODO(johnniwinther): We should not mark the type as instantiated but
       // rather follow the type arguments directly.
       //
       // Consider this:
       //
       //    abstract class A<T> {
       //      factory A.regular() => new B<T>();
       //      factory A.redirect() = B<T>;
       //    }
       //
@@ skipping 29 matching lines @@
             astAdapter.getNativeBehaviorForJsEmbeddedGlobalCall(node));
         break;
       case ForeignKind.JS_INTERCEPTOR_CONSTANT:
         if (node.arguments.positional.length != 1 ||
             node.arguments.named.isNotEmpty) {
           astAdapter.reporter.reportErrorMessage(CURRENT_ELEMENT_SPANNABLE,
               MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
         }
         ir.Node argument = node.arguments.positional.first;
         if (argument is ir.TypeLiteral && argument.type is ir.InterfaceType) {
-          ResolutionInterfaceType type = astAdapter.getDartType(argument.type);
+          InterfaceType type = astAdapter.getInterfaceType(argument.type);
           impactBuilder.registerTypeUse(new TypeUse.instantiation(type));
         }
         break;
       case ForeignKind.NONE:
         break;
     }
   }
 
   @override
   void visitStaticGet(ir.StaticGet node) {
     ir.Member target = node.target;
     if (target is ir.Procedure && target.kind == ir.ProcedureKind.Method) {
-      MethodElement method = astAdapter.getMethod(target);
+      FunctionEntity method = astAdapter.getMethod(target);
       impactBuilder.registerStaticUse(new StaticUse.staticTearOff(method));
     } else {
-      MemberElement member = astAdapter.getMember(target);
+      MemberEntity member = astAdapter.getMember(target);
       impactBuilder.registerStaticUse(new StaticUse.staticGet(member));
     }
   }
 
   @override
   void visitStaticSet(ir.StaticSet node) {
     visitNode(node.value);
-    MemberElement member = astAdapter.getMember(node.target);
+    MemberEntity member = astAdapter.getMember(node.target);
     impactBuilder.registerStaticUse(new StaticUse.staticSet(member));
   }
 
   void handleSuperInvocation(ir.Node target, ir.Node arguments) {
-    MethodElement method = astAdapter.getMethod(target);
+    FunctionEntity method = astAdapter.getMethod(target);
     _visitArguments(arguments);
     impactBuilder.registerStaticUse(new StaticUse.superInvoke(
         method, astAdapter.getCallStructure(arguments)));
   }
 
   @override
   void visitDirectMethodInvocation(ir.DirectMethodInvocation node) {
     handleSuperInvocation(node.target, node.arguments);
   }
 
   @override
   void visitSuperMethodInvocation(ir.SuperMethodInvocation node) {
     // TODO(johnniwinther): Should we support this or always use the
     // [MixinFullResolution] transformer?
     handleSuperInvocation(node.interfaceTarget, node.arguments);
   }
 
   void handleSuperGet(ir.Member target) {
     if (target is ir.Procedure && target.kind == ir.ProcedureKind.Method) {
-      MethodElement method = astAdapter.getMethod(target);
+      FunctionEntity method = astAdapter.getMethod(target);
       impactBuilder.registerStaticUse(new StaticUse.superTearOff(method));
     } else {
-      MemberElement member = astAdapter.getMember(target);
+      MemberEntity member = astAdapter.getMember(target);
       impactBuilder.registerStaticUse(new StaticUse.superGet(member));
     }
   }
 
   @override
   void visitDirectGet(ir.StaticGet node) {
     handleSuperGet(node.target);
   }
 
   @override
   void visitSuperPropertyGet(ir.SuperPropertyGet node) {
     handleSuperGet(node.interfaceTarget);
   }
 
   void handleSuperSet(ir.Node target, ir.Node value) {
     visitNode(value);
     if (target is ir.Field) {
-      FieldElement field = astAdapter.getField(target);
+      FieldEntity field = astAdapter.getField(target);
       impactBuilder.registerStaticUse(new StaticUse.superFieldSet(field));
     } else {
-      MethodElement method = astAdapter.getMethod(target);
+      FunctionEntity method = astAdapter.getMethod(target);
       impactBuilder.registerStaticUse(new StaticUse.superSetterSet(method));
     }
   }
 
   @override
   void visitDirectPropertySet(ir.DirectPropertySet node) {
     handleSuperSet(node.target, node.value);
   }
 
   @override
@@ skipping 142 matching lines @@
   @override
   void visitFieldInitializer(ir.FieldInitializer node) {
     impactBuilder.registerStaticUse(
         new StaticUse.fieldInit(astAdapter.getField(node.field)));
     visitNode(node.value);
   }
 
   @override
   void visitRedirectingInitializer(ir.RedirectingInitializer node) {
     _visitArguments(node.arguments);
-    Element target = astAdapter.getElement(node.target).declaration;
+    FunctionEntity target = astAdapter.getConstructor(node.target);
     impactBuilder.registerStaticUse(new StaticUse.superConstructorInvoke(
         target, astAdapter.getCallStructure(node.arguments)));
   }
 
   // TODO(johnniwinther): Make this throw and visit child nodes explicitly
   // instead to ensure that we don't visit unwanted parts of the ir.
   @override
   void defaultNode(ir.Node node) => node.visitChildren(this);
 }