Encapsulate use of ast.Node in type_graph_nodes

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';
@@ skipping 489 matching lines @@
         : new ElementGraphBuilder(element, resolvedAst, compiler, this);
     TypeInformation type;
     reporter.withCurrentElement(element, () {
       // ignore: UNDEFINED_METHOD
       type = visitor.run();
     });
     addedInGraph++;
 
     if (element.isField) {
       FieldElement fieldElement = element;
-      ast.Node node = resolvedAst.node;
       ast.Node initializer = resolvedAst.body;
       if (element.isFinal || element.isConst) {
         // If [element] is final and has an initializer, we record
         // the inferred type.
         if (resolvedAst.body != null) {
           if (type is! ListTypeInformation && type is! MapTypeInformation) {
             // For non-container types, the constant handler does
             // constant folding that could give more precise results.
             ConstantExpression constant = fieldElement.constant;
             if (constant != null) {
               ConstantValue value =
                   compiler.backend.constants.getConstantValue(constant);
               if (value != null) {
                 if (value.isFunction) {
                   FunctionConstantValue functionConstant = value;
                   MethodElement function = functionConstant.element;
-                  type = types.allocateClosure(node, function);
+                  type = types.allocateClosure(function);
                 } else {
                   // Although we might find a better type, we have to keep
                   // the old type around to ensure that we get a complete view
                   // of the type graph and do not drop any flow edges.
                   TypeMask refinedType = computeTypeMask(closedWorld, value);
                   assert(TypeMask.assertIsNormalized(refinedType, closedWorld));
                   type = new NarrowTypeInformation(type, refinedType);
                   types.allocatedTypes.add(type);
                 }
               } else {
@@ skipping 369 matching lines @@
    * [inLoop] tells whether the call happens in a loop.
    */
   TypeInformation registerCalledSelector(
       ast.Node node,
       Selector selector,
       TypeMask mask,
       TypeInformation receiverType,
       MemberElement caller,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
-      bool inLoop) {
+      bool inLoop,
+      bool isConditional) {
     if (selector.isClosureCall) {
       return registerCalledClosure(node, selector, mask, receiverType, caller,
           arguments, sideEffects, inLoop);
     }
 
     closedWorld.locateMembers(selector, mask).forEach((_callee) {
       MemberElement callee = _callee;
       updateSideEffects(sideEffects, selector, callee);
     });
 
     CallSiteTypeInformation info = new DynamicCallSiteTypeInformation(
         types.currentMember,
         node,
         caller,
         selector,
         mask,
         receiverType,
         arguments,
-        inLoop);
+        inLoop,
+        isConditional);
 
     info.addToGraph(this);
     types.allocatedCalls.add(info);
     return info;
   }
 
   /**
    * Registers a call to await with an expression of type [argumentType] as
    * argument.
    */
@@ skipping 168 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) {}
 }