Split ast based parts from InferrerEngineImpl

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 86 matching lines @@
       node = resolvedAst.node;
     }
     FieldInitializationScope fieldScope =
         analyzedElement.isGenerativeConstructor
             ? new FieldInitializationScope(types)
             : null;
     locals =
         new LocalsHandler(inferrer, types, compiler.options, node, fieldScope);
   }
 
-  ElementGraphBuilder(MemberElement element, ResolvedAst resolvedAst,
-      Compiler compiler, InferrerEngine inferrer, [LocalsHandler handler])
-      : this.internal(element, resolvedAst, element.memberContext.declaration,
-            inferrer, compiler, handler);
+  ElementGraphBuilder(
+      MemberElement element, Compiler compiler, InferrerEngine inferrer,
+      [LocalsHandler handler])
+      : this.internal(element, element.resolvedAst,
+            element.memberContext.declaration, inferrer, compiler, handler);
 
   TreeElements get elements => resolvedAst.elements;
 
   bool accumulateIsChecks = false;
   bool conditionIsSimple = false;
   List<ast.Send> isChecks;
   int loopLevel = 0;
 
   bool get inLoop => loopLevel > 0;
   bool get isThisExposed {
@@ skipping 764 matching lines @@
 
   TypeInformation visitCascade(ast.Cascade node) {
     // Ignore the result of the cascade send and return the type of the cascade
     // receiver.
     visit(node.expression);
     return cascadeReceiverStack.removeLast();
   }
 
   void analyzeSuperConstructorCall(
       ConstructorElement target, ArgumentsTypes arguments) {
+    assert(target.isDeclaration);
     ResolvedAst resolvedAst = target.resolvedAst;
-    inferrer.analyze(resolvedAst, arguments);
+    ast.Node body;
+    if (resolvedAst.kind == ResolvedAstKind.PARSED) {
+      body = resolvedAst.node;
+    }
+    inferrer.analyze(target, body, arguments);
     isThisExposed = isThisExposed || inferrer.checkIfExposesThis(target);
   }
 
   TypeInformation run() {
     var node;
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
       node = resolvedAst.node;
     }
     ast.Expression initializer;
     if (analyzedElement.isField) {
@@ skipping 42 matching lines @@
           ? declaration.callMethod
           : declaration;
       bool needNewContext = declarationMethod != analyzedElement;
       if (needNewContext) {
         assert(
             declarationMethod is ConstructorElement,
             failedAt(
                 parameter,
                 "Unexpected function declaration "
                 "${declarationMethod}, expected ${analyzedElement}."));
-        visitor = new ElementGraphBuilder(declarationMethod,
-            parameter.functionDeclaration.resolvedAst, compiler, inferrer);
+        visitor =
+            new ElementGraphBuilder(declarationMethod, compiler, inferrer);
       }
       TypeInformation type =
           (defaultValue == null) ? types.nullType : visitor.visit(defaultValue);
       inferrer.setDefaultTypeOfParameter(parameter, type,
           isInstanceMember: function.isInstanceMember);
     });
 
     if (closedWorld.nativeData.isNativeMember(analyzedElement)) {
       // Native methods do not have a body, and we currently just say
       // they return dynamic.
@@ skipping 126 matching lines @@
     // the safe side, we mark [this] as exposed here. We could do better by
     // analyzing the closure.
     // TODO(herhut): Analyze whether closure exposes this.
     isThisExposed = true;
     LocalFunctionElement element = elements.getFunctionDefinition(node);
     // We don'TypeInformation put the closure in the work queue of the
     // inferrer, because it will share information with its enclosing
     // method, like for example the types of local variables.
     LocalsHandler closureLocals =
         new LocalsHandler.from(locals, node, useOtherTryBlock: false);
-    ElementGraphBuilder visitor = new ElementGraphBuilder(element.callMethod,
-        element.resolvedAst, compiler, inferrer, closureLocals);
+    ElementGraphBuilder visitor = new ElementGraphBuilder(
+        element.callMethod, compiler, inferrer, closureLocals);
     visitor.run();
     inferrer.recordReturnType(element.callMethod, visitor.returnType);
 
     // Record the types of captured non-boxed variables. Types of
     // these variables may already be there, because of an analysis of
     // a previous closure.
     ClosureRepresentationInfo nestedClosureData = compiler
         .backendStrategy.closureDataLookup
         .getClosureRepresentationInfo(element);
     nestedClosureData.forEachCapturedVariable((variable, field) {
@@ skipping 1859 matching lines @@
         node,
         iteratorSelector,
         iteratorMask,
         expressionType,
         new ArgumentsTypes.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }