Split ast based parts from InferrerEngineImpl

pkg/compiler/lib/src/inferrer/type_graph_nodes.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 compiler.src.inferrer.type_graph_nodes;
 
 import 'dart:collection' show IterableBase;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 813 matching lines @@
     throw new UnsupportedError('ParameterTypeInformation.getInferredSignature');
   }
 }
 
 enum CallType {
   access,
   complex,
   forIn,
 }
 
-bool validCallType(CallType callType, Spannable call) {
+bool validCallType(CallType callType, Object call) {
   switch (callType) {
     case CallType.complex:
       return call is ast.SendSet;
     case CallType.access:
       return call is ast.Send;
     case CallType.forIn:
       return call is ast.ForIn;
   }
   throw new StateError('Unexpected call type $callType.');
 }
 
 /**
  * A [CallSiteTypeInformation] is a call found in the AST, or a
  * synthesized call for implicit calls in Dart (such as forwarding
  * factories). The [_call] field is a [ast.Node] for the former, and an
  * [Element] for the latter.
  *
  * In the inferrer graph, [CallSiteTypeInformation] nodes do not have
  * any assignment. They rely on the [caller] field for static calls,
  * and [selector] and [receiver] fields for dynamic calls.
  */
 abstract class CallSiteTypeInformation extends TypeInformation
     with ApplyableTypeInformation {
-  final Spannable _call;
+  final Object _call;
   final MemberEntity caller;
   final Selector selector;
   final TypeMask mask;
   final ArgumentsTypes arguments;
   final bool inLoop;
 
   CallSiteTypeInformation(MemberTypeInformation context, this._call,
       this.caller, this.selector, this.mask, this.arguments, this.inLoop)
       : super.noAssignments(context) {
     assert(_checkCaller(caller));
@@ skipping 90 matching lines @@
   void removeAndClearReferences(InferrerEngine inferrer) {
     ElementTypeInformation callee = _getCalledTypeInfo(inferrer);
     callee.removeUser(this);
     if (arguments != null) {
       arguments.forEach((info) => info.removeUser(this));
     }
     super.removeAndClearReferences(inferrer);
   }
 }
 
-class DynamicCallSiteTypeInformation extends CallSiteTypeInformation {
+class DynamicCallSiteTypeInformation<T> extends CallSiteTypeInformation {
   final CallType _callType;
   final TypeInformation receiver;
   final bool isConditional;
 
   /// Cached targets of this call.
   Iterable<MemberEntity> targets;
 
   DynamicCallSiteTypeInformation(
       MemberTypeInformation context,
       this._callType,
-      ast.Node call,
+      T call,
       MemberEntity enclosing,
       Selector selector,
       TypeMask mask,
       this.receiver,
       ArgumentsTypes arguments,
       bool inLoop,
       this.isConditional)
       : super(context, call, enclosing, selector, mask, arguments, inLoop) {
     assert(validCallType(_callType, _call));
   }
@@ skipping 298 matching lines @@
         (arguments == null || arguments.every((info) => info.isStable)) &&
         super.hasStableType(inferrer);
   }
 }
 
 class ClosureCallSiteTypeInformation extends CallSiteTypeInformation {
   final TypeInformation closure;
 
   ClosureCallSiteTypeInformation(
       MemberTypeInformation context,
-      Spannable call,
+      Object call,
       MemberEntity enclosing,
       Selector selector,
       TypeMask mask,
       this.closure,
       ArgumentsTypes arguments,
       bool inLoop)
       : super(context, call, enclosing, selector, mask, arguments, inLoop);
 
   void addToGraph(InferrerEngine inferrer) {
     arguments.forEach((info) => info.addUser(this));
@@ skipping 631 matching lines @@
     otherType = closedWorld.commonMasks.functionType;
   } else {
     assert(annotation.isTypeVariable);
     // TODO(ngeoffray): Narrow to bound.
     return type;
   }
   if (isNullable) otherType = otherType.nullable();
   if (type == null) return otherType;
   return type.intersection(otherType, closedWorld);
 }