Encapsulate use of ast.Node in type_graph_nodes

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

 // Copyright (c) 2013, 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.
 
 library simple_types_inferrer;
 
 import '../closure.dart' show ClosureRepresentationInfo;
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../compiler.dart' show Compiler;
@@ skipping 1108 matching lines @@
           inferrer.recordTypeOfField(field, thisType);
         }
         // The type is null for type parameters.
         if (locals.locals[variable] == null) return;
         inferrer.recordTypeOfField(field, locals.locals[variable]);
       }
       capturedVariables.add(variable);
     });
 
     return inferrer.concreteTypes.putIfAbsent(node, () {
-      return types.allocateClosure(node, element.callMethod);
+      return types.allocateClosure(element.callMethod);
     });
   }
 
   TypeInformation visitFunctionDeclaration(ast.FunctionDeclaration node) {
     LocalFunctionElement element =
         elements.getFunctionDefinition(node.function);
     TypeInformation type =
         inferrer.concreteTypes.putIfAbsent(node.function, () {
-      return types.allocateClosure(node.function, element.callMethod);
+      return types.allocateClosure(element.callMethod);
     });
     locals.update(element, type, node);
     visit(node.function);
     return type;
   }
 
   TypeInformation visitStringInterpolation(ast.StringInterpolation node) {
     // Interpolation could have any effects since it could call any toString()
     // method.
     // TODO(sra): This could be modelled by a call to toString() but with a
@@ skipping 1598 matching lines @@
       mask = receiverType == types.dynamicType
           ? null
           : types.newTypedSelector(receiverType, mask);
       inferrer.updateSelectorInMember(outermostElement, node, selector, mask);
     }
 
     // If the receiver of the call is a local, we may know more about
     // its type by refining it with the potential targets of the
     // calls.
     ast.Send send = node.asSend();
+    bool isConditional = false;
     if (send != null) {
+      isConditional = send.isConditional;
       ast.Node receiver = send.receiver;
       if (receiver != null) {
         Element element = elements[receiver];
         if (Elements.isLocal(element) && !capturedVariables.contains(element)) {
           TypeInformation refinedType = types.refineReceiver(
               selector, mask, receiverType, send.isConditional);
           locals.update(element, refinedType, node);
         }
       }
     }
 
     return inferrer.registerCalledSelector(node, selector, mask, receiverType,
-        outermostElement, arguments, sideEffects, inLoop);
+        outermostElement, arguments, sideEffects, inLoop, isConditional);
   }
 
   TypeInformation handleDynamicInvoke(ast.Send node) {
     return _handleDynamicSend(node);
   }
 
   TypeInformation handleDynamicGet(ast.Send node) {
     return _handleDynamicSend(node);
   }
 
@@ skipping 164 matching lines @@
     Selector moveNextSelector = Selectors.moveNext;
     TypeMask moveNextMask = memberData.typeOfIteratorMoveNext(node);
 
     TypeInformation iteratorType = handleDynamicSend(node, iteratorSelector,
         iteratorMask, expressionType, new ArgumentsTypes.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }