Add KernelWorldBuilder and KElement model.

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 15 matching lines @@
 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;
     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);
-      }
-    } else if (element.isGenerativeConstructor) {
-      ir.Constructor constructor = kernel.functions[element];
-      if (constructor == null) {
-        throw "FOUND NULL CONSTRUCTOR: $element";
-      } else {
-        return builder.buildConstructor(constructor);
-      }
-    } else if (element.isField) {
-      ir.Field field = kernel.fields[element];
-      if (field == null) {
-        throw "FOUND NULL FIELD: $element";
-      } else {
-        return builder.buildField(field);
-      }
-    } else {
-      throw new UnsupportedError("Unsupported element: $element");
+    ir.Member member = getIrMember(compiler, resolvedAst);
+    return buildKernelImpact(member, astAdapter);
+  });
+}
+
+ir.Member getIrMember(Compiler compiler, ResolvedAst resolvedAst) {
+  AstElement element = resolvedAst.element;
+  JavaScriptBackend backend = compiler.backend;
+  Kernel kernel = backend.kernelTask.kernel;
+  ir.Member member;
+  if (element.isFunction ||
+      element.isGetter ||
+      element.isSetter ||
+      element.isConstructor) {
+    member = kernel.functions[element];
+    if (member == null) {
+      throw "FOUND NULL FUNCTION: $element";
     }
-  });
+  } else if (element.isField) {
+    member = kernel.fields[element];
+    if (member == null) {
+      throw "FOUND NULL FIELD: $element";
+    }
+  } else {
+    throw new UnsupportedError("Unsupported element: $element");
+  }
+  return member;
+}
+
+ResolutionImpact buildKernelImpact(
+    ir.Member member, KernelElementAdapter elementAdapter) {
+  KernelImpactBuilder builder =
+      new KernelImpactBuilder('${member.name}', elementAdapter);
+  if (member is ir.Procedure) {
+    return builder.buildProcedure(member);
+  } else if (member is ir.Constructor) {
+    return builder.buildConstructor(member);
+  } else if (member is ir.Field) {
+    return builder.buildField(member);
+  }
+  throw new UnsupportedError("Unsupported member: $member");
 }
 
 class KernelImpactBuilder extends ir.Visitor {
   final ResolutionWorldImpactBuilder impactBuilder;
   final KernelElementAdapter elementAdapter;
-  final CommonElements commonElements;
 
-  KernelImpactBuilder(String name, this.elementAdapter, this.commonElements)
+  KernelImpactBuilder(String name, this.elementAdapter)
       : this.impactBuilder = new ResolutionWorldImpactBuilder(name);
 
+  CommonElements get commonElements => elementAdapter.commonElements;
+
   /// Add a checked-mode type use of [type] if it is not `dynamic`.
   DartType checkType(ir.DartType irType) {
     DartType type = elementAdapter.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
@@ skipping 184 matching lines @@
   @override
   void visitSuperInitializer(ir.SuperInitializer node) {
     ConstructorEntity target = elementAdapter.getConstructor(node.target);
     _visitArguments(node.arguments);
     impactBuilder.registerStaticUse(new StaticUse.superConstructorInvoke(
         target, elementAdapter.getCallStructure(node.arguments)));
   }
 
   @override
   void visitStaticInvocation(ir.StaticInvocation node) {
-    FunctionEntity target = elementAdapter.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>;
       //    }
       //
       //    class B<T> implements A<T> {}
       //
       //    main() {
       //      print(new A<int>.regular() is B<int>);
       //      print(new A<String>.redirect() is B<String>);
       //    }
       //
       // To track that B is actually instantiated as B<int> and B<String> we
       // need to follow the type arguments passed to A.regular and A.redirect
       // to B. Currently, we only do this soundly if we register A<int> and
       // A<String> as instantiated. We should instead register that A.T is
       // instantiated as int and String.
       handleNew(node, node.target, isConst: node.isConst);
     } else {
+      FunctionEntity target = elementAdapter.getMethod(node.target);
       _visitArguments(node.arguments);
       impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
           target, elementAdapter.getCallStructure(node.arguments)));
     }
     switch (elementAdapter.getForeignKind(node)) {
       case ForeignKind.JS:
         impactBuilder.registerNativeData(
             elementAdapter.getNativeBehaviorForJsCall(node));
         break;
       case ForeignKind.JS_BUILTIN:
@@ skipping 246 matching lines @@
     ConstructorEntity target = elementAdapter.getConstructor(node.target);
     impactBuilder.registerStaticUse(new StaticUse.superConstructorInvoke(
         target, elementAdapter.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);
 }