Further splitting of inference type-info

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 69 matching lines @@
   ElementGraphBuilder.internal(
       AstElement analyzedElement,
       this.resolvedAst,
       this.outermostElement,
       InferrerEngine inferrer,
       this.compiler,
       this.locals)
       : this.analyzedElement = analyzedElement,
         this.inferrer = inferrer,
         this.types = inferrer.types,
-        this.inTreeData = inferrer.dataOf(analyzedElement) {
+        this.inTreeData = analyzedElement.isLocal
+            ? inferrer.dataOfLocalFunction(analyzedElement)
+            : inferrer.dataOfMember(analyzedElement) {
     assert(outermostElement != null);
     if (locals != null) return;
     ast.Node node;
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
       node = resolvedAst.node;
     }
     FieldInitializationScope fieldScope =
         analyzedElement.isGenerativeConstructor
             ? new FieldInitializationScope(types)
             : null;
@@ skipping 1007 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);
+      return types.allocateClosureForLocalFunction(node, element);
     });
   }
 
   TypeInformation visitFunctionDeclaration(ast.FunctionDeclaration node) {
     LocalFunctionElement element =
         elements.getFunctionDefinition(node.function);
     TypeInformation type =
         inferrer.concreteTypes.putIfAbsent(node.function, () {
-      return types.allocateClosure(node.function, element);
+      return types.allocateClosureForLocalFunction(node.function, element);
     });
     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 1590 matching lines @@
         element, arguments, sideEffects, inLoop);
   }
 
   TypeInformation handleDynamicSend(ast.Node node, Selector selector,
       TypeMask mask, TypeInformation receiverType, ArgumentsTypes arguments) {
     assert(receiverType != null);
     if (types.selectorNeedsUpdate(receiverType, mask)) {
       mask = receiverType == types.dynamicType
           ? null
           : types.newTypedSelector(receiverType, mask);
-      inferrer.updateSelectorInTree(analyzedElement, node, selector, mask);
+      if (analyzedElement.isLocal) {
+        inferrer.updateSelectorInLocalFunction(
+            analyzedElement, node, selector, mask);
+      } else {
+        inferrer.updateSelectorInMember(analyzedElement, 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();
     if (send != null) {
       ast.Node receiver = send.receiver;
       if (receiver != null) {
         Element element = elements[receiver];
@@ skipping 189 matching lines @@
     Selector moveNextSelector = Selectors.moveNext;
     TypeMask moveNextMask = inTreeData.typeOfIteratorMoveNext(node);
 
     TypeInformation iteratorType = handleDynamicSend(node, iteratorSelector,
         iteratorMask, expressionType, new ArgumentsTypes.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }