Pulling the element model out of global type inference.

pkg/compiler/lib/src/inferrer/inferrer_engine.dart

 // Copyright (c) 2017, 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 '../constants/values.dart';
 import '../common_elements.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../js_backend/annotations.dart';
 import '../js_backend/js_backend.dart';
 import '../native/behavior.dart' as native;
 import '../resolution/tree_elements.dart';
 import '../tree/nodes.dart' as ast;
 import '../types/constants.dart';
 import '../types/types.dart';
 import '../universe/call_structure.dart';
 import '../universe/selector.dart';
 import '../universe/side_effects.dart';
 import '../util/util.dart';
 import '../world.dart';
 import 'closure_tracer.dart';
 import 'debug.dart' as debug;
 import 'locals_handler.dart';
 import 'list_tracer.dart';
 import 'map_tracer.dart';
 import 'builder.dart';
+import 'builder_kernel.dart';
 import 'type_graph_dump.dart';
 import 'type_graph_inferrer.dart';
 import 'type_graph_nodes.dart';
 import 'type_system.dart';
 
 /**
  * An inferencing engine that computes a call graph of
  * [TypeInformation] nodes by visiting the AST of the application, and
  * then does the inferencing on the graph.
  */
@@ skipping 16 matching lines @@
 
   final Compiler compiler;
 
   /// The [ClosedWorld] on which inference reasoning is based.
   final ClosedWorld closedWorld;
 
   final ClosedWorldRefiner closedWorldRefiner;
   final TypeSystem types;
   final Map<ast.Node, TypeInformation> concreteTypes =
       new Map<ast.Node, TypeInformation>();
+
+  /// Parallel structure for concreteTypes.
+  // TODO(efortuna): Remove concreteTypes and/or parameterize InferrerEngine by
+  // ir.Node or ast.Node type. Then remove this in favor of `concreteTypes`.
+  final Map<ir.Node, TypeInformation> concreteKernelTypes =
+      new Map<ir.Node, TypeInformation>();
   final Set<Element> generativeConstructorsExposingThis = new Set<Element>();
 
   /// Data computed internally within elements, like the type-mask of a send a
   /// list allocation, or a for-in loop.
   final Map<Element, GlobalTypeInferenceElementData> inTreeData =
       new Map<Element, GlobalTypeInferenceElementData>();
 
   InferrerEngine(this.compiler, ClosedWorld closedWorld,
       this.closedWorldRefiner, this.mainElement)
       : this.types = new TypeSystem(closedWorld),
@@ skipping 383 matching lines @@
     reporter.log('Inferred $overallRefineCount types.');
 
     processLoopInformation();
   }
 
   void analyze(ResolvedAst resolvedAst, ArgumentsTypes arguments) {
     AstElement element = resolvedAst.element.implementation;
     if (analyzedElements.contains(element)) return;
     analyzedElements.add(element);
 
-    ElementGraphBuilder visitor =
-        new ElementGraphBuilder(element, resolvedAst, compiler, this);
+    var visitor = compiler.options.kernelGlobalInference
+        ? new KernelTypeGraphBuilder(element, resolvedAst, compiler, this)
+        : new ElementGraphBuilder(element, resolvedAst, compiler, this);
     TypeInformation type;
     reporter.withCurrentElement(element, () {
       type = visitor.run();
     });
     addedInGraph++;
 
     if (element.isField) {
       VariableElement fieldElement = element;
       ast.Node node = resolvedAst.node;
       ast.Node initializer = resolvedAst.body;
@@ skipping 563 matching lines @@
   /**
    * Records that the captured variable [local] is read.
    */
   void recordCapturedLocalRead(Local local) {}
 
   /**
    * Records that the variable [local] is being updated.
    */
   void recordLocalUpdate(Local local, TypeInformation type) {}
 }