Mostly use entities in use.dart

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';
@@ skipping 238 matching lines @@
   }
 
   @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);
-    Element element = astAdapter.getElement(target).declaration;
-    ClassElement cls = astAdapter.getElement(target.enclosingClass);
+    ConstructorElement constructor = astAdapter.getConstructor(target);
+    ClassElement cls = astAdapter.getClass(target.enclosingClass);
     List<ResolutionDartType> typeArguments =
         astAdapter.getDartTypes(node.arguments.types);
     ResolutionInterfaceType type =
         new ResolutionInterfaceType(cls, typeArguments);
     CallStructure callStructure = astAdapter.getCallStructure(node.arguments);
     impactBuilder.registerStaticUse(isConst
-        ? new StaticUse.constConstructorInvoke(element, callStructure, type)
-        : new StaticUse.typedConstructorInvoke(element, callStructure, type));
+        ? new StaticUse.constConstructorInvoke(constructor, callStructure, type)
+        : new StaticUse.typedConstructorInvoke(
+            constructor, callStructure, type));
     if (typeArguments.any((ResolutionDartType type) => !type.isDynamic)) {
       impactBuilder.registerFeature(Feature.TYPE_VARIABLE_BOUNDS_CHECK);
     }
   }
 
   @override
   void visitSuperInitializer(ir.SuperInitializer node) {
-    Element target = astAdapter.getElement(node.target).declaration;
+    ConstructorElement target = astAdapter.getConstructor(node.target);
     _visitArguments(node.arguments);
     impactBuilder.registerStaticUse(new StaticUse.superConstructorInvoke(
         target, astAdapter.getCallStructure(node.arguments)));
   }
 
   @override
   void visitStaticInvocation(ir.StaticInvocation node) {
-    Element target = astAdapter.getElement(node.target).declaration;
+    MethodElement target = astAdapter.getMethod(node.target);
     if (target.isFactoryConstructor) {
       // 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 42 matching lines @@
         }
         break;
       case ForeignKind.NONE:
         break;
     }
   }
 
   @override
   void visitStaticGet(ir.StaticGet node) {
     ir.Member target = node.target;
-    Element element = astAdapter.getElement(target).declaration;
     if (target is ir.Procedure && target.kind == ir.ProcedureKind.Method) {
-      impactBuilder.registerStaticUse(new StaticUse.staticTearOff(element));
+      MethodElement method = astAdapter.getMethod(target);
+      impactBuilder.registerStaticUse(new StaticUse.staticTearOff(method));
     } else {
-      impactBuilder.registerStaticUse(new StaticUse.staticGet(element));
+      MemberElement member = astAdapter.getMember(target);
+      impactBuilder.registerStaticUse(new StaticUse.staticGet(member));
     }
   }
 
   @override
   void visitStaticSet(ir.StaticSet node) {
     visitNode(node.value);
-    Element element = astAdapter.getElement(node.target).declaration;
-    impactBuilder.registerStaticUse(new StaticUse.staticSet(element));
+    MemberElement member = astAdapter.getMember(node.target);
+    impactBuilder.registerStaticUse(new StaticUse.staticSet(member));
   }
 
   void handleSuperInvocation(ir.Node target, ir.Node arguments) {
-    Element element = astAdapter.getElement(target).declaration;
+    MethodElement method = astAdapter.getMethod(target);
     _visitArguments(arguments);
     impactBuilder.registerStaticUse(new StaticUse.superInvoke(
-        element, astAdapter.getCallStructure(arguments)));
+        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) {
-    Element element = astAdapter.getElement(target).declaration;
     if (target is ir.Procedure && target.kind == ir.ProcedureKind.Method) {
-      impactBuilder.registerStaticUse(new StaticUse.superTearOff(element));
+      MethodElement method = astAdapter.getMethod(target);
+      impactBuilder.registerStaticUse(new StaticUse.superTearOff(method));
     } else {
-      impactBuilder.registerStaticUse(new StaticUse.superGet(element));
+      MemberElement 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);
-    Element element = astAdapter.getElement(target).declaration;
     if (target is ir.Field) {
-      impactBuilder.registerStaticUse(new StaticUse.superFieldSet(element));
+      FieldElement field = astAdapter.getField(target);
+      impactBuilder.registerStaticUse(new StaticUse.superFieldSet(field));
     } else {
-      impactBuilder.registerStaticUse(new StaticUse.superSetterSet(element));
+      MethodElement method = astAdapter.getMethod(target);
+      impactBuilder.registerStaticUse(new StaticUse.superSetterSet(method));
     }
   }
 
   @override
   void visitDirectPropertySet(ir.DirectPropertySet node) {
     handleSuperSet(node.target, node.value);
   }
 
   @override
   void visitSuperPropertySet(ir.SuperPropertySet node) {
@@ skipping 134 matching lines @@
 
   @override
   void visitTypeLiteral(ir.TypeLiteral node) {
     impactBuilder.registerTypeUse(
         new TypeUse.typeLiteral(astAdapter.getDartType(node.type)));
   }
 
   @override
   void visitFieldInitializer(ir.FieldInitializer node) {
     impactBuilder.registerStaticUse(
-        new StaticUse.fieldInit(astAdapter.getElement(node.field)));
+        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;
     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);
 }