Further decouple KernelImpactBuilder from elements

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 '../core_types.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 '../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.
 ResolutionImpact build(Compiler compiler, ResolvedAst resolvedAst) {
   AstElement element = resolvedAst.element;
   return compiler.reporter.withCurrentElement(element.implementation, () {
     JavaScriptBackend backend = compiler.backend;
     Kernel kernel = backend.kernelTask.kernel;
-    KernelImpactBuilder builder =
-        new KernelImpactBuilder(resolvedAst, compiler, kernel);
+    KernelAstAdapter astAdapter = new KernelAstAdapter(kernel, compiler.backend,
+        resolvedAst, kernel.nodeToAst, kernel.nodeToElement);
+    KernelImpactBuilder builder = new KernelImpactBuilder(
+        '${resolvedAst.element}', astAdapter, compiler.commonElements);
     if (element.isFunction ||
         element.isGetter ||
         element.isSetter ||
         element.isFactoryConstructor) {
       ir.Procedure function = kernel.functions[element];
       if (function == null) {
         throw "FOUND NULL FUNCTION: $element";
       } else {
         return builder.buildProcedure(function);
       }
@@ skipping 11 matching lines @@
       } else {
         return builder.buildField(field);
       }
     } else {
       throw new UnsupportedError("Unsupported element: $element");
     }
   });
 }
 
 class KernelImpactBuilder extends ir.Visitor {
-  final ResolvedAst resolvedAst;
-  final Compiler compiler;
+  final ResolutionWorldImpactBuilder impactBuilder;
+  final KernelWorldBuilder astAdapter;
+  final CommonElements commonElements;
 
-  JavaScriptBackend get backend => compiler.backend;
-
-  ResolutionWorldImpactBuilder impactBuilder;
-  KernelWorldBuilder 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);
-  }
+  KernelImpactBuilder(String name, this.astAdapter, this.commonElements)
+      : this.impactBuilder = new ResolutionWorldImpactBuilder(name);
 
   /// Add a checked-mode type use of [type] if it is not `dynamic`.
   DartType checkType(ir.DartType irType) {
     DartType type = astAdapter.getDartType(irType);
     if (!type.isDynamic) {
       impactBuilder.registerTypeUse(new TypeUse.checkedModeCheck(type));
     }
     return type;
   }
 
@@ skipping 50 matching lines @@
       case ir.AsyncMarker.SyncStar:
         impactBuilder.registerFeature(Feature.SYNC_STAR);
         break;
       case ir.AsyncMarker.Async:
         impactBuilder.registerFeature(Feature.ASYNC);
         break;
       case ir.AsyncMarker.AsyncStar:
         impactBuilder.registerFeature(Feature.ASYNC_STAR);
         break;
       case ir.AsyncMarker.SyncYielding:
-        compiler.reporter.internalError(resolvedAst.element,
+        throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
             "Unexpected async marker: ${procedure.function.asyncMarker}");
     }
     if (procedure.isExternal &&
         !astAdapter.isForeignLibrary(procedure.enclosingLibrary)) {
       impactBuilder
           .registerNativeData(astAdapter.getNativeBehaviorForMethod(procedure));
     }
     return impactBuilder;
   }
 
@@ skipping 56 matching lines @@
   void visitNullLiteral(ir.NullLiteral literal) {
     impactBuilder.registerConstantLiteral(new NullConstantExpression());
   }
 
   @override
   void visitListLiteral(ir.ListLiteral literal) {
     visitNodes(literal.expressions);
     DartType elementType = checkType(literal.typeArgument);
 
     impactBuilder.registerListLiteral(new ListLiteralUse(
-        compiler.commonElements.listType(elementType),
+        commonElements.listType(elementType),
         isConstant: literal.isConst,
         isEmpty: literal.expressions.isEmpty));
   }
 
   @override
   void visitMapLiteral(ir.MapLiteral literal) {
     visitNodes(literal.entries);
     DartType keyType = checkType(literal.keyType);
     DartType valueType = checkType(literal.valueType);
     impactBuilder.registerMapLiteral(new MapLiteralUse(
-        compiler.commonElements.mapType(keyType, valueType),
+        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) {
@@ skipping 129 matching lines @@
     if (target is ir.Procedure && target.kind == ir.ProcedureKind.Method) {
       FunctionEntity method = astAdapter.getMethod(target);
       impactBuilder.registerStaticUse(new StaticUse.superTearOff(method));
     } else {
       MemberEntity member = astAdapter.getMember(target);
       impactBuilder.registerStaticUse(new StaticUse.superGet(member));
     }
   }
 
   @override
-  void visitDirectGet(ir.StaticGet node) {
+  void visitDirectPropertyGet(ir.DirectPropertyGet node) {
     handleSuperGet(node.target);
   }
 
   @override
   void visitSuperPropertyGet(ir.SuperPropertyGet node) {
     handleSuperGet(node.interfaceTarget);
   }
 
   void handleSuperSet(ir.Node target, ir.Node value) {
     visitNode(value);
@@ skipping 167 matching lines @@
     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);
 }