Split inference type-info accessors into members, parameters and local functions

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 84 matching lines @@
       node = resolvedAst.node;
     }
     FieldInitializationScope fieldScope =
         analyzedElement.isGenerativeConstructor
             ? new FieldInitializationScope(types)
             : null;
     locals =
         new LocalsHandler(inferrer, types, compiler.options, node, fieldScope);
   }
 
-  ElementGraphBuilder(Element element, ResolvedAst resolvedAst,
+  ElementGraphBuilder(AstElement element, ResolvedAst resolvedAst,
       Compiler compiler, InferrerEngine inferrer, [LocalsHandler handler])
       : this.internal(
             element,
             resolvedAst,
             element.outermostEnclosingMemberOrTopLevel.implementation,
             inferrer,
             compiler,
             handler);
 
   TreeElements get elements => resolvedAst.elements;
@@ skipping 768 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(
-      AstElement target, ArgumentsTypes arguments) {
+      ConstructorElement target, ArgumentsTypes arguments) {
     ResolvedAst resolvedAst = target.resolvedAst;
     inferrer.analyze(resolvedAst, arguments);
     isThisExposed = isThisExposed || inferrer.checkIfExposesThis(target);
   }
 
   TypeInformation run() {
     var node;
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
       node = resolvedAst.node;
     }
@@ skipping 32 matching lines @@
       // constructor comes from the corresponding parameter of the target.
 
       // If this is a default value from a different context (because
       // the current function is synthetic, e.g., a constructor from
       // a mixin application), we have to start a new inferrer visitor
       // with the correct context.
       // TODO(johnniwinther): Remove once function signatures are fixed.
       ElementGraphBuilder visitor = this;
       if (inferrer.hasAlreadyComputedTypeOfParameterDefault(element)) return;
       if (element.functionDeclaration != analyzedElement) {
-        visitor = new ElementGraphBuilder(element.functionDeclaration,
+        ConstructorElement constructor = element.functionDeclaration;
+        visitor = new ElementGraphBuilder(constructor,
             element.functionDeclaration.resolvedAst, compiler, inferrer);
       }
       TypeInformation type =
           (defaultValue == null) ? types.nullType : visitor.visit(defaultValue);
       inferrer.setDefaultTypeOfParameter(element, type);
     });
 
     if (inferrer.isNativeMember(analyzedElement)) {
       // Native methods do not have a body, and we currently just say
       // they return dynamic.
       return types.dynamicType;
     }
 
     if (analyzedElement.isGenerativeConstructor) {
       isThisExposed = false;
       signature.forEachParameter((FormalElement _element) {
         ParameterElement element = _element;
-        TypeInformation parameterType = inferrer.typeOfElement(element);
+        TypeInformation parameterType = inferrer.typeOfParameter(element);
         if (element.isInitializingFormal) {
           InitializingFormalElement initializingFormal = element;
           if (initializingFormal.fieldElement.isFinal) {
-            inferrer.recordTypeOfFinalField(node, analyzedElement,
+            inferrer.recordTypeOfFinalField(
                 initializingFormal.fieldElement, parameterType);
           } else {
             locals.updateField(initializingFormal.fieldElement, parameterType);
-            inferrer.recordTypeOfNonFinalField(initializingFormal.node,
+            inferrer.recordTypeOfNonFinalField(
                 initializingFormal.fieldElement, parameterType);
           }
         }
         locals.update(element, parameterType, node);
       });
       ClassElement cls = analyzedElement.enclosingClass;
       Spannable spannable = node;
       if (analyzedElement.isSynthesized) {
         spannable = analyzedElement;
         ConstructorElement constructor = analyzedElement;
@@ skipping 15 matching lines @@
         // For a generative constructor like: `Foo();`, we synthesize
         // a call to the default super constructor (the one that takes
         // no argument). Resolution ensures that such a constructor
         // exists.
         if (!isConstructorRedirect &&
             !seenSuperConstructorCall &&
             !cls.isObject) {
           ConstructorElement target = cls.superclass.lookupDefaultConstructor();
           ArgumentsTypes arguments = new ArgumentsTypes([], {});
           analyzeSuperConstructorCall(target, arguments);
-          inferrer.registerCalledElement(node, null, null, outermostElement,
+          inferrer.registerCalledMember(node, null, null, outermostElement,
               target.implementation, arguments, sideEffects, inLoop);
         }
         visit(node.body);
         inferrer.recordExposesThis(analyzedElement, isThisExposed);
       }
       if (!isConstructorRedirect) {
         // Iterate over all instance fields, and give a null type to
         // fields that we haven'TypeInformation initialized for sure.
         cls.forEachInstanceField((_, FieldElement field) {
           if (field.isFinal) return;
           TypeInformation type = locals.fieldScope.readField(field);
           ResolvedAst resolvedAst = field.resolvedAst;
           if (type == null && resolvedAst.body == null) {
-            inferrer.recordTypeOfNonFinalField(
-                spannable, field, types.nullType);
+            inferrer.recordTypeOfNonFinalField(field, types.nullType);
           }
         });
       }
       if (analyzedElement.isGenerativeConstructor && cls.isAbstract) {
         if (closedWorld.isInstantiated(cls)) {
           returnType = types.nonNullSubclass(cls);
         } else {
           // TODO(johnniwinther): Avoid analyzing [analyzedElement] in this
           // case; it's never called.
           returnType = types.nonNullEmpty();
         }
       } else {
         returnType = types.nonNullExact(cls);
       }
     } else {
       signature.forEachParameter((FormalElement _element) {
         ParameterElement element = _element;
-        locals.update(element, inferrer.typeOfElement(element), node);
+        locals.update(element, inferrer.typeOfParameter(element), node);
       });
       visit(node.body);
       switch (function.asyncMarker) {
         case AsyncMarker.SYNC:
           if (returnType == null) {
             // No return in the body.
             returnType = locals.seenReturnOrThrow
                 ? types.nonNullEmpty() // Body always throws.
                 : types.nullType;
           } else if (!locals.seenReturnOrThrow) {
             // We haven'TypeInformation seen returns on all branches. So the method may
             // also return null.
-            returnType = inferrer.addReturnTypeFor(
-                analyzedElement, returnType, types.nullType);
+            recordReturnType(types.nullType);
           }
           break;
 
         case AsyncMarker.SYNC_STAR:
           // TODO(asgerf): Maybe make a ContainerTypeMask for these? The type
           //               contained is the method body's return type.
-          returnType = inferrer.addReturnTypeFor(
-              analyzedElement, returnType, types.syncStarIterableType);
+          recordReturnType(types.syncStarIterableType);
           break;
 
         case AsyncMarker.ASYNC:
-          returnType = inferrer.addReturnTypeFor(
-              analyzedElement, returnType, types.asyncFutureType);
+          recordReturnType(types.asyncFutureType);
           break;
 
         case AsyncMarker.ASYNC_STAR:
-          returnType = inferrer.addReturnTypeFor(
-              analyzedElement, returnType, types.asyncStarStreamType);
+          recordReturnType(types.asyncStarStreamType);
           break;
       }
     }
 
     inferrer.closedWorldRefiner
         .registerSideEffects(analyzedElement.declaration, sideEffects);
     assert(breaksFor.isEmpty);
     assert(continuesFor.isEmpty);
     return returnType;
   }
 
   TypeInformation visitFunctionExpression(ast.FunctionExpression node) {
     // We loose track of [this] in closures (see issue 20840). To be on
     // 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, element.resolvedAst, compiler, inferrer, closureLocals);
     visitor.run();
-    inferrer.recordReturnType(element, visitor.returnType);
+    inferrer.recordReturnTypeOfLocalFunction(element, 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) {
       if (!nestedClosureData.isVariableBoxed(variable)) {
         if (variable == nestedClosureData.thisLocal) {
-          inferrer.recordType(field, thisType);
+          inferrer.recordTypeOfField(field, thisType);
         }
         // The type is null for type parameters.
         if (locals.locals[variable] == null) return;
-        inferrer.recordType(field, locals.locals[variable]);
+        inferrer.recordTypeOfField(field, locals.locals[variable]);
       }
       capturedVariables.add(variable);
     });
 
     return inferrer.concreteTypes.putIfAbsent(node, () {
       return types.allocateClosure(node, element);
     });
   }
 
   TypeInformation visitFunctionDeclaration(ast.FunctionDeclaration node) {
@@ skipping 76 matching lines @@
       if (element.isField) {
         ResolvedAst elementResolvedAst = element.resolvedAst;
         if (!selector.isSetter &&
             isInClassOrSubclass(element) &&
             !element.isFinal &&
             locals.fieldScope.readField(element) == null &&
             elementResolvedAst.body == null) {
           // If the field is being used before this constructor
           // actually had a chance to initialize it, say it can be
           // null.
-          inferrer.recordTypeOfNonFinalField(
-              resolvedAst.node, element, types.nullType);
+          inferrer.recordTypeOfNonFinalField(element, types.nullType);
         }
         // Accessing a field does not expose [:this:].
         return true;
       }
       // TODO(ngeoffray): We could do better here if we knew what we
       // are calling does not expose this.
       isThisExposed = true;
       return false;
     });
   }
@@ skipping 764 matching lines @@
           MemberElement single = targets.first;
           if (single.isField) {
             locals.updateField(single, rhsType);
           }
         }
       }
       handleDynamicSend(
           node, setterSelector, setterMask, receiverType, arguments);
     } else if (element.isField) {
       if (element.isFinal) {
-        inferrer.recordTypeOfFinalField(
-            node, outermostElement, element, rhsType);
+        inferrer.recordTypeOfFinalField(element, rhsType);
       } else {
         if (analyzedElement.isGenerativeConstructor) {
           locals.updateField(element, rhsType);
         }
         if (visitingInitializers) {
-          inferrer.recordTypeOfNonFinalField(node, element, rhsType);
+          inferrer.recordTypeOfNonFinalField(element, rhsType);
         } else {
           handleDynamicSend(
               node, setterSelector, setterMask, receiverType, arguments);
         }
       }
     } else if (element.isLocal) {
       locals.update(element, rhsType, node);
     }
     return rhsType;
   }
@@ skipping 20 matching lines @@
     if (!Selectors.noSuchMethod_.signatureApplies(element)) {
       ClassElement objectClass = closedWorld.commonElements.objectClass;
       element = objectClass.lookupMember(Identifiers.noSuchMethod_);
     }
     return handleStaticSend(node, selector, mask, element, arguments);
   }
 
   /// Handle a .call invocation on the values retrieved from the super
   /// [element]. For instance `super.foo(bar)` where `foo` is a field or getter.
   TypeInformation handleSuperClosureCall(
-      ast.Send node, Element element, ast.NodeList arguments) {
+      ast.Send node, MemberElement element, ast.NodeList arguments) {
     ArgumentsTypes argumentTypes = analyzeArguments(arguments.nodes);
     Selector selector = elements.getSelector(node);
     TypeMask mask = inTreeData.typeOfSend(node);
     // TODO(herhut): We could do better here if we knew what we
     // are calling does not expose this.
     isThisExposed = true;
     return inferrer.registerCalledClosure(
         node,
         selector,
         mask,
-        inferrer.typeOfElement(element),
+        inferrer.typeOfMember(element),
         outermostElement,
         argumentTypes,
         sideEffects,
         inLoop);
   }
 
   /// Handle an invocation of super [method].
   TypeInformation handleSuperMethodInvoke(
       ast.Send node, MethodElement method, ArgumentsTypes arguments) {
     // TODO(herhut): We could do better here if we knew what we
@@ skipping 278 matching lines @@
           ? types.nullType
           : arguments.positional[1];
 
       return inferrer.concreteTypes.putIfAbsent(
           node,
           () => types.allocateList(types.fixedListType, node, outermostElement,
               elementType, length));
     } else if (Elements.isConstructorOfTypedArraySubclass(
         constructor, closedWorld)) {
       int length = findLength(node);
-      TypeInformation elementType = inferrer
-          .returnTypeOfElement(target.enclosingClass.lookupMember('[]'));
+      TypeInformation elementType =
+          inferrer.returnTypeOfMember(target.enclosingClass.lookupMember('[]'));
       return inferrer.concreteTypes.putIfAbsent(
           node,
           () => types.allocateList(types.nonNullExact(target.enclosingClass),
               node, outermostElement, elementType, length));
     } else {
       return returnType;
     }
   }
 
   @override
   TypeInformation bulkHandleNew(ast.NewExpression node, _) {
     Element element = elements[node.send];
     return handleConstructorSend(node.send, element);
   }
 
   @override
   TypeInformation errorNonConstantConstructorInvoke(
       ast.NewExpression node,
       Element element,
       ResolutionDartType type,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return bulkHandleNew(node, _);
   }
 
   /// Handle invocation of a top level or static field or getter [element].
   TypeInformation handleStaticFieldOrGetterInvoke(
-      ast.Send node, Element element) {
+      ast.Send node, MemberElement element) {
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
     TypeMask mask = inTreeData.typeOfSend(node);
     handleStaticSend(node, selector, mask, element, arguments);
     return inferrer.registerCalledClosure(
         node,
         selector,
         mask,
-        inferrer.typeOfElement(element),
+        inferrer.typeOfMember(element),
         outermostElement,
         arguments,
         sideEffects,
         inLoop);
   }
 
   /// Handle invocation of a top level or static [function].
   TypeInformation handleStaticFunctionInvoke(
       ast.Send node, MethodElement function) {
     if (compiler.backend.isForeign(closedWorld.commonElements, function)) {
@@ skipping 292 matching lines @@
       LocalFunctionElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     ArgumentsTypes argumentTypes = analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
     TypeMask mask = inTreeData.typeOfSend(node);
     // This only works for function statements. We need a
     // more sophisticated type system with function types to support
     // more.
-    return inferrer.registerCalledElement(node, selector, mask,
+    return inferrer.registerCalledLocalFunction(node, selector, mask,
         outermostElement, function, argumentTypes, sideEffects, inLoop);
   }
 
   @override
   TypeInformation visitLocalFunctionIncompatibleInvoke(
       ast.Send node,
       LocalFunctionElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     analyzeArguments(node.arguments);
     return types.dynamicType;
   }
 
   TypeInformation handleStaticSend(ast.Node node, Selector selector,
-      TypeMask mask, Element element, ArgumentsTypes arguments) {
+      TypeMask mask, MemberElement element, ArgumentsTypes arguments) {
     assert(!element.isFactoryConstructor ||
         !(element as ConstructorElement).isRedirectingFactory);
     // Erroneous elements may be unresolved, for example missing getters.
     if (Elements.isUnresolved(element)) return types.dynamicType;
     // TODO(herhut): should we follow redirecting constructors here? We would
     // need to pay attention if the constructor is pointing to an erroneous
     // element.
-    return inferrer.registerCalledElement(node, selector, mask,
-        outermostElement, element, arguments, sideEffects, inLoop);
+    return inferrer.registerCalledMember(node, selector, mask, outermostElement,
+        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);
@@ skipping 56 matching lines @@
         return types.boolType;
       } else if (types.isNull(arguments.positional[0])) {
         potentiallyAddNullCheck(node, node.receiver);
         return types.boolType;
       }
     }
     return handleDynamicSend(node, selector, mask, receiverType, arguments);
   }
 
   void recordReturnType(TypeInformation type) {
-    returnType = inferrer.addReturnTypeFor(analyzedElement, returnType, type);
+    if (analyzedElement.isLocal) {
+      returnType = inferrer.addReturnTypeForLocalFunction(
+          analyzedElement, returnType, type);
+    } else {
+      returnType =
+          inferrer.addReturnTypeForMethod(analyzedElement, returnType, type);
+    }
   }
 
   TypeInformation synthesizeForwardingCall(
       Spannable node, ConstructorElement element) {
     element = element.implementation;
     FunctionElement function = analyzedElement;
     FunctionSignature signature = function.functionSignature;
     FunctionSignature calleeSignature = element.functionSignature;
     if (!calleeSignature.isCompatibleWith(signature)) {
       return types.nonNullEmpty();
@@ skipping 14 matching lines @@
         named[element.name] = locals.use(element);
       });
     } else {
       signature.forEachOptionalParameter((FormalElement _element) {
         ParameterElement element = _element;
         unnamed.add(locals.use(element));
       });
     }
 
     ArgumentsTypes arguments = new ArgumentsTypes(unnamed, named);
-    return inferrer.registerCalledElement(node, null, null, outermostElement,
+    return inferrer.registerCalledMember(node, null, null, outermostElement,
         element, arguments, sideEffects, inLoop);
   }
 
   TypeInformation visitRedirectingFactoryBody(ast.RedirectingFactoryBody node) {
     ConstructorElement element = elements.getRedirectingTargetConstructor(node);
     if (Elements.isMalformed(element)) {
       recordReturnType(types.dynamicType);
     } else {
       // We don'TypeInformation create a selector for redirecting factories, and
       // the send is just a property access. Therefore we must
@@ skipping 81 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);
   }
 }