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

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

 // Copyright (c) 2017, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
@@ skipping 25 matching lines @@
 import 'type_graph_inferrer.dart';
 import 'type_graph_nodes.dart';
 import 'type_system.dart';
 
 /**
  * An inferencing engine that computes a call graph of
  * [TypeInformation] nodes by visiting the AST of the application, and
  * then does the inferencing on the graph.
  */
 class InferrerEngine {
-  final Map<Element, TypeInformation> defaultTypeOfParameter =
-      new Map<Element, TypeInformation>();
+  final Map<ParameterElement, TypeInformation> defaultTypeOfParameter =
+      new Map<ParameterElement, TypeInformation>();
   final WorkQueue workQueue = new WorkQueue();
   final FunctionEntity mainElement;
-  final Set<Element> analyzedElements = new Set<Element>();
+  final Set<MemberElement> analyzedElements = new Set<MemberElement>();
 
   /// The maximum number of times we allow a node in the graph to
   /// change types. If a node reaches that limit, we give up
   /// inferencing on it and give it the dynamic type.
   final int MAX_CHANGE_COUNT = 6;
 
   int overallRefineCount = 0;
   int addedInGraph = 0;
 
   final Compiler compiler;
 
   /// The [ClosedWorld] on which inference reasoning is based.
   final ClosedWorld closedWorld;
 
   final ClosedWorldRefiner closedWorldRefiner;
   final TypeSystem types;
   final Map<ast.Node, TypeInformation> concreteTypes =
       new Map<ast.Node, TypeInformation>();
 
   /// Parallel structure for concreteTypes.
   // TODO(efortuna): Remove concreteTypes and/or parameterize InferrerEngine by
   // ir.Node or ast.Node type. Then remove this in favor of `concreteTypes`.
   final Map<ir.Node, TypeInformation> concreteKernelTypes =
       new Map<ir.Node, TypeInformation>();
-  final Set<Element> generativeConstructorsExposingThis = new Set<Element>();
+  final Set<ConstructorElement> generativeConstructorsExposingThis =
+      new Set<ConstructorElement>();
 
   /// Data computed internally within elements, like the type-mask of a send a
   /// list allocation, or a for-in loop.
   final Map<Element, GlobalTypeInferenceElementData> inTreeData =
       new Map<Element, GlobalTypeInferenceElementData>();
 
   InferrerEngine(this.compiler, ClosedWorld closedWorld,
       this.closedWorldRefiner, this.mainElement)
       : this.types = new TypeSystem(closedWorld),
         this.closedWorld = closedWorld;
@@ skipping 131 matching lines @@
         data.setMoveNextTypeMask(node, mask);
       }
     }
   }
 
   bool isNativeMember(Element element) {
     return element is MemberElement &&
         closedWorld.nativeData.isNativeMember(element);
   }
 
-  bool checkIfExposesThis(Element element) {
+  bool checkIfExposesThis(ConstructorElement element) {
     element = element.implementation;
     return generativeConstructorsExposingThis.contains(element);
   }
 
-  void recordExposesThis(Element element, bool exposesThis) {
+  void recordExposesThis(ConstructorElement element, bool exposesThis) {
     element = element.implementation;
     if (exposesThis) {
       generativeConstructorsExposingThis.add(element);
     }
   }
 
   JavaScriptBackend get backend => compiler.backend;
   OptimizerHintsForTests get optimizerHints => backend.optimizerHints;
   DiagnosticReporter get reporter => compiler.reporter;
   CommonMasks get commonMasks => closedWorld.commonMasks;
@@ skipping 109 matching lines @@
     types.allocatedClosures.forEach((dynamic info) {
       void trace(
           Iterable<FunctionElement> elements, ClosureTracerVisitor tracer) {
         tracer.run();
         if (!tracer.continueAnalyzing) {
           elements.forEach((FunctionElement e) {
             closedWorldRefiner.registerMightBePassedToApply(e);
             if (debug.VERBOSE) print("traced closure $e as ${true} (bail)");
             e.functionSignature.forEachParameter((parameter) {
               types
-                  .getInferredTypeOf(parameter)
+                  .getInferredTypeOfParameter(parameter)
                   .giveUp(this, clearAssignments: false);
             });
           });
           bailedOutOn.addAll(elements);
           return;
         }
         elements
             .where((e) => !bailedOutOn.contains(e))
             .forEach((FunctionElement e) {
           e.functionSignature.forEachParameter((parameter) {
-            var info = types.getInferredTypeOf(parameter);
+            var info = types.getInferredTypeOfParameter(parameter);
             info.maybeResume();
             workQueue.add(info);
           });
           if (tracer.tracedType.mightBePassedToFunctionApply) {
             closedWorldRefiner.registerMightBePassedToApply(e);
           }
           if (debug.VERBOSE) {
             print("traced closure $e as "
                 "${closedWorldRefiner
                 .getCurrentlyKnownMightBePassedToApply(e)}");
@@ skipping 69 matching lines @@
           print('${types.getInferredSignatureOf(info.element)} for '
               '${info.element}');
         } else if (info is ClosureTypeInformation) {
           print('${types.getInferredSignatureOf(info.element)} for '
               '${info.element}');
         } else if (info is DynamicCallSiteTypeInformation) {
           for (MemberElement target in info.targets) {
             if (target is MethodElement) {
               print('${types.getInferredSignatureOf(target)} for ${target}');
             } else {
-              print('${types.getInferredTypeOf(target).type} for ${target}');
+              print(
+                  '${types.getInferredTypeOfMember(target).type} for ${target}');
             }
           }
         } else if (info is StaticCallSiteTypeInformation) {
           ClassElement cls = info.calledElement.enclosingClass;
           FunctionElement callMethod = cls.lookupMember(Identifiers.call);
           print('${types.getInferredSignatureOf(callMethod)} for ${cls}');
         } else {
           print('${info.type} for some unknown kind of closure');
         }
       });
-      analyzedElements.forEach((Element elem) {
-        TypeInformation type = types.getInferredTypeOf(elem);
+      analyzedElements.forEach((MemberElement elem) {
+        TypeInformation type = types.getInferredTypeOfMember(elem);
         print('${elem} :: ${type} from ${type.assignments} ');
       });
     }
     dump?.afterAnalysis();
 
     reporter.log('Inferred $overallRefineCount types.');
 
     processLoopInformation();
   }
 
   void analyze(ResolvedAst resolvedAst, ArgumentsTypes arguments) {
-    AstElement element = resolvedAst.element.implementation;
+    MemberElement element = resolvedAst.element.implementation;
     if (analyzedElements.contains(element)) return;
     analyzedElements.add(element);
 
     dynamic visitor = compiler.options.kernelGlobalInference
         ? new KernelTypeGraphBuilder(element, resolvedAst, compiler, this)
         : new ElementGraphBuilder(element, resolvedAst, compiler, this);
     TypeInformation type;
     reporter.withCurrentElement(element, () {
       // ignore: UNDEFINED_METHOD
       type = visitor.run();
     });
     addedInGraph++;
 
     if (element.isField) {
-      VariableElement fieldElement = element;
+      FieldElement fieldElement = element;
       ast.Node node = resolvedAst.node;
       ast.Node initializer = resolvedAst.body;
       if (element.isFinal || element.isConst) {
         // If [element] is final and has an initializer, we record
         // the inferred type.
         if (resolvedAst.body != null) {
           if (type is! ListTypeInformation && type is! MapTypeInformation) {
             // For non-container types, the constant handler does
             // constant folding that could give more precise results.
             ConstantExpression constant = fieldElement.constant;
@@ skipping 19 matching lines @@
                     fieldElement.isInstanceMember ||
                         constant.isImplicit ||
                         constant.isPotential,
                     failedAt(
                         fieldElement,
                         "Constant expression without value: "
                         "${constant.toStructuredText()}."));
               }
             }
           }
-          recordType(element, type);
+          recordTypeOfField(element, type);
         } else if (!element.isInstanceMember) {
-          recordType(element, types.nullType);
+          recordTypeOfField(element, types.nullType);
         }
       } else if (initializer == null) {
         // Only update types of static fields if there is no
         // assignment. Instance fields are dealt with in the constructor.
         if (Elements.isStaticOrTopLevelField(element)) {
-          recordTypeOfNonFinalField(node, element, type);
+          recordTypeOfNonFinalField(element, type);
         }
       } else {
-        recordTypeOfNonFinalField(node, element, type);
+        recordTypeOfNonFinalField(element, type);
       }
       if (Elements.isStaticOrTopLevelField(element) &&
           resolvedAst.body != null &&
           !element.isConst) {
         dynamic argument = resolvedAst.body;
         // TODO(13429): We could do better here by using the
         // constant handler to figure out if it's a lazy field or not.
         if (argument.asSend() != null ||
             (argument.asNewExpression() != null && !argument.isConst)) {
-          recordType(element, types.nullType);
+          recordTypeOfField(element, types.nullType);
         }
       }
     } else {
       recordReturnType(element, type);
     }
   }
 
   void processLoopInformation() {
     types.allocatedCalls.forEach((dynamic info) {
       if (!info.inLoop) return;
@@ skipping 54 matching lines @@
    * Update the assignments to parameters in the graph. [remove] tells
    * wheter assignments must be added or removed. If [init] is false,
    * parameters are added to the work queue.
    */
   void updateParameterAssignments(TypeInformation caller, Element callee,
       ArgumentsTypes arguments, Selector selector, TypeMask mask,
       {bool remove, bool addToQueue: true}) {
     if (callee.name == Identifiers.noSuchMethod_) return;
     if (callee.isField) {
       if (selector.isSetter) {
-        ElementTypeInformation info = types.getInferredTypeOf(callee);
+        ElementTypeInformation info = types.getInferredTypeOfMember(callee);
         if (remove) {
           info.removeAssignment(arguments.positional[0]);
         } else {
           info.addAssignment(arguments.positional[0]);
         }
         if (addToQueue) workQueue.add(info);
       }
     } else if (callee.isGetter) {
       return;
     } else if (selector != null && selector.isGetter) {
       // We are tearing a function off and thus create a closure.
       assert(callee.isFunction);
-      MemberTypeInformation info = types.getInferredTypeOf(callee);
+      MemberTypeInformation info = types.getInferredTypeOfMember(callee);
       if (remove) {
         info.closurizedCount--;
       } else {
         info.closurizedCount++;
         if (Elements.isStaticOrTopLevel(callee)) {
           types.allocatedClosures.add(info);
         } else {
           // We add the call-site type information here so that we
           // can benefit from further refinement of the selector.
           types.allocatedClosures.add(caller);
         }
         FunctionElement function = callee.implementation;
         FunctionSignature signature = function.functionSignature;
         signature.forEachParameter((Element parameter) {
-          ParameterTypeInformation info = types.getInferredTypeOf(parameter);
+          ParameterTypeInformation info =
+              types.getInferredTypeOfParameter(parameter);
           info.tagAsTearOffClosureParameter(this);
           if (addToQueue) workQueue.add(info);
         });
       }
     } else {
       FunctionElement function = callee.implementation;
       FunctionSignature signature = function.functionSignature;
       int parameterIndex = 0;
       bool visitingRequiredParameter = true;
       signature.forEachParameter((Element parameter) {
         if (signature.hasOptionalParameters &&
             parameter == signature.optionalParameters.first) {
           visitingRequiredParameter = false;
         }
         TypeInformation type = visitingRequiredParameter
             ? arguments.positional[parameterIndex]
             : signature.optionalParametersAreNamed
                 ? arguments.named[parameter.name]
                 : parameterIndex < arguments.positional.length
                     ? arguments.positional[parameterIndex]
                     : null;
         if (type == null) type = getDefaultTypeOfParameter(parameter);
-        TypeInformation info = types.getInferredTypeOf(parameter);
+        TypeInformation info = types.getInferredTypeOfParameter(parameter);
         if (remove) {
           info.removeAssignment(type);
         } else {
           info.addAssignment(type);
         }
         parameterIndex++;
         if (addToQueue) workQueue.add(info);
       });
     }
   }
 
   /**
    * Sets the type of a parameter's default value to [type]. If the global
    * mapping in [defaultTypeOfParameter] already contains a type, it must be
    * a [PlaceholderTypeInformation], which will be replaced. All its uses are
    * updated.
    */
   void setDefaultTypeOfParameter(
       ParameterElement parameter, TypeInformation type) {
     assert(parameter.functionDeclaration.isImplementation);
     TypeInformation existing = defaultTypeOfParameter[parameter];
     defaultTypeOfParameter[parameter] = type;
-    TypeInformation info = types.getInferredTypeOf(parameter);
+    TypeInformation info = types.getInferredTypeOfParameter(parameter);
     if (existing != null && existing is PlaceholderTypeInformation) {
       // Replace references to [existing] to use [type] instead.
       if (parameter.functionDeclaration.isInstanceMember) {
         ParameterAssignments assignments = info.assignments;
         assignments.replace(existing, type);
       } else {
         List<TypeInformation> assignments = info.assignments;
         for (int i = 0; i < assignments.length; i++) {
           if (assignments[i] == existing) {
             assignments[i] = type;
@@ skipping 10 matching lines @@
   /**
    * Returns the [TypeInformation] node for the default value of a parameter.
    * If this is queried before it is set by [setDefaultTypeOfParameter], a
    * [PlaceholderTypeInformation] is returned, which will later be replaced
    * by the actual node when [setDefaultTypeOfParameter] is called.
    *
    * Invariant: After graph construction, no [PlaceholderTypeInformation] nodes
    *            should be present and a default type for each parameter should
    *            exist.
    */
-  TypeInformation getDefaultTypeOfParameter(Element parameter) {
+  TypeInformation getDefaultTypeOfParameter(ParameterElement parameter) {
     return defaultTypeOfParameter.putIfAbsent(parameter, () {
       return new PlaceholderTypeInformation(types.currentMember);
     });
   }
 
   /**
    * This helper breaks abstractions but is currently required to work around
    * the wrong modeling of default values of optional parameters of
    * synthetic constructors.
    *
    * TODO(johnniwinther): Remove once default values of synthetic parameters
    * are fixed.
    */
-  bool hasAlreadyComputedTypeOfParameterDefault(Element parameter) {
+  bool hasAlreadyComputedTypeOfParameterDefault(ParameterElement parameter) {
     TypeInformation seen = defaultTypeOfParameter[parameter];
     return (seen != null && seen is! PlaceholderTypeInformation);
   }
 
   /**
    * Returns the type of [element].
    */
-  TypeInformation typeOfElement(Entity element) {
-    if (element is FunctionElement) return types.functionType;
-    return types.getInferredTypeOf(element);
+  TypeInformation typeOfParameter(ParameterElement element) {
+    return types.getInferredTypeOfParameter(element);
+  }
+
+  /**
+   * Returns the type of [element].
+   */
+  TypeInformation typeOfMember(MemberElement element) {
+    if (element is MethodElement) return types.functionType;
+    return types.getInferredTypeOfMember(element);
   }
 
   /**
    * Returns the return type of [element].
    */
-  TypeInformation returnTypeOfElement(Entity element) {
-    if (element is! FunctionElement) return types.dynamicType;
-    return types.getInferredTypeOf(element);
+  @deprecated
+  TypeInformation returnTypeOfLocalFunction(LocalFunctionElement element) {
+    return types.getInferredTypeOfLocalFunction(element);
   }
 
   /**
+   * Returns the return type of [element].
+   */
+  TypeInformation returnTypeOfMember(MemberElement element) {
+    if (element is! MethodElement) return types.dynamicType;
+    return types.getInferredTypeOfMember(element);
+  }
+
+  /**
    * Records that [node] sets final field [element] to be of type [type].
    *
    * [nodeHolder] is the element holder of [node].
    */
-  void recordTypeOfFinalField(
-      Spannable node, Entity analyzed, Entity element, TypeInformation type) {
-    types.getInferredTypeOf(element).addAssignment(type);
+  void recordTypeOfFinalField(FieldElement element, TypeInformation type) {
+    types.getInferredTypeOfMember(element).addAssignment(type);
   }
 
   /**
    * Records that [node] sets non-final field [element] to be of type
    * [type].
    */
-  void recordTypeOfNonFinalField(
-      Spannable node, Entity element, TypeInformation type) {
-    types.getInferredTypeOf(element).addAssignment(type);
+  void recordTypeOfNonFinalField(FieldElement element, TypeInformation type) {
+    types.getInferredTypeOfMember(element).addAssignment(type);
   }
 
   /**
    * Records that [element] is of type [type].
    */
-  void recordType(Entity element, TypeInformation type) {
-    types.getInferredTypeOf(element).addAssignment(type);
+  // TODO(johnniwinther): Merge [recordTypeOfFinalField] and
+  // [recordTypeOfNonFinalField] with this?
+  void recordTypeOfField(FieldElement element, TypeInformation type) {
+    types.getInferredTypeOfMember(element).addAssignment(type);
   }
 
   /**
    * Records that the return type [element] is of type [type].
    */
-  void recordReturnType(Element element, TypeInformation type) {
-    TypeInformation info = types.getInferredTypeOf(element);
+  @deprecated
+  void recordReturnTypeOfLocalFunction(
+      LocalFunctionElement element, TypeInformation type) {
+    TypeInformation info = types.getInferredTypeOfLocalFunction(element);
     if (element.name == '==') {
       // Even if x.== doesn't return a bool, 'x == null' evaluates to 'false'.
       info.addAssignment(types.boolType);
+    }
+    // TODO(ngeoffray): Clean up. We do these checks because
+    // [SimpleTypesInferrer] deals with two different inferrers.
+    if (type == null) return;
+    if (info.assignments.isEmpty) info.addAssignment(type);
+  }
+
+  /**
+   * Records that the return type [element] is of type [type].
+   */
+  void recordReturnType(MethodElement element, TypeInformation type) {
+    TypeInformation info = types.getInferredTypeOfMember(element);
+    if (element.name == '==') {
+      // Even if x.== doesn't return a bool, 'x == null' evaluates to 'false'.
+      info.addAssignment(types.boolType);
     }
     // TODO(ngeoffray): Clean up. We do these checks because
     // [SimpleTypesInferrer] deals with two different inferrers.
     if (type == null) return;
     if (info.assignments.isEmpty) info.addAssignment(type);
   }
 
   /**
    * Notifies to the inferrer that [analyzedElement] can have return
    * type [newType]. [currentType] is the type the [ElementGraphBuilder]
    * currently found.
    *
    * Returns the new type for [analyzedElement].
    */
-  TypeInformation addReturnTypeFor(
-      Element element, TypeInformation unused, TypeInformation newType) {
-    TypeInformation type = types.getInferredTypeOf(element);
+  @deprecated
+  TypeInformation addReturnTypeForLocalFunction(LocalFunctionElement element,
+      TypeInformation unused, TypeInformation newType) {
+    TypeInformation type = types.getInferredTypeOfLocalFunction(element);
     // TODO(ngeoffray): Clean up. We do this check because
     // [SimpleTypesInferrer] deals with two different inferrers.
     if (element.isGenerativeConstructor) return type;
+    type.addAssignment(newType);
+    return type;
+  }
+
+  /**
+   * Notifies to the inferrer that [analyzedElement] can have return
+   * type [newType]. [currentType] is the type the [ElementGraphBuilder]
+   * currently found.
+   *
+   * Returns the new type for [analyzedElement].
+   */
+  TypeInformation addReturnTypeForMethod(
+      MethodElement element, TypeInformation unused, TypeInformation newType) {
+    TypeInformation type = types.getInferredTypeOfMember(element);
+    // TODO(ngeoffray): Clean up. We do this check because
+    // [SimpleTypesInferrer] deals with two different inferrers.
+    if (element.isGenerativeConstructor) return type;
     type.addAssignment(newType);
     return type;
   }
 
   /**
    * Registers that [caller] calls [callee] at location [node], with
    * [selector], and [arguments]. Note that [selector] is null for
    * forwarding constructors.
    *
    * [sideEffects] will be updated to incorporate [callee]'s side
    * effects.
    *
    * [inLoop] tells whether the call happens in a loop.
    */
-  TypeInformation registerCalledElement(
+  @deprecated
+  TypeInformation registerCalledLocalFunction(
       Spannable node,
       Selector selector,
       TypeMask mask,
+      Element caller,
+      LocalFunctionElement callee,
+      ArgumentsTypes arguments,
+      SideEffects sideEffects,
+      bool inLoop) {
+    return _registerCalledElement(
+        node, selector, mask, caller, callee, arguments, sideEffects, inLoop);
+  }
+
+  /**
+   * Registers that [caller] calls [callee] at location [node], with
+   * [selector], and [arguments]. Note that [selector] is null for
+   * forwarding constructors.
+   *
+   * [sideEffects] will be updated to incorporate [callee]'s side
+   * effects.
+   *
+   * [inLoop] tells whether the call happens in a loop.
+   */
+  TypeInformation registerCalledMember(
+      Spannable node,
+      Selector selector,
+      TypeMask mask,
+      Element caller,
+      MemberElement callee,
+      ArgumentsTypes arguments,
+      SideEffects sideEffects,
+      bool inLoop) {
+    return _registerCalledElement(
+        node, selector, mask, caller, callee, arguments, sideEffects, inLoop);
+  }
+
+  /**
+   * Registers that [caller] calls [callee] at location [node], with
+   * [selector], and [arguments]. Note that [selector] is null for
+   * forwarding constructors.
+   *
+   * [sideEffects] will be updated to incorporate [callee]'s side
+   * effects.
+   *
+   * [inLoop] tells whether the call happens in a loop.
+   */
+  TypeInformation _registerCalledElement(
+      Spannable node,
+      Selector selector,
+      TypeMask mask,
       Element caller,
       Element callee,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop) {
     CallSiteTypeInformation info = new StaticCallSiteTypeInformation(
         types.currentMember,
         node,
         caller,
         callee,
@@ skipping 176 matching lines @@
     types.allocatedClosures.forEach(cleanup);
     types.allocatedClosures.clear();
 
     analyzedElements.clear();
     generativeConstructorsExposingThis.clear();
 
     types.allocatedMaps.values.forEach(cleanup);
     types.allocatedLists.values.forEach(cleanup);
   }
 
-  Iterable<Element> getCallersOf(Element element) {
+  Iterable<Element> getCallersOf(MemberElement element) {
     if (compiler.disableTypeInference) {
       throw new UnsupportedError(
           "Cannot query the type inferrer when type inference is disabled.");
     }
-    MemberTypeInformation info = types.getInferredTypeOf(element);
+    MemberTypeInformation info = types.getInferredTypeOfMember(element);
     return info.callers;
   }
 
   /**
    * Returns the type of [element] when being called with [selector].
    */
-  TypeInformation typeOfElementWithSelector(
+  TypeInformation typeOfLocalFunctionWithSelector(
+      LocalFunctionElement element, Selector selector) {
+    return _typeOfElementWithSelector(element, selector);
+  }
+
+  /**
+   * Returns the type of [element] when being called with [selector].
+   */
+  TypeInformation typeOfMemberWithSelector(
+      MemberElement element, Selector selector) {
+    return _typeOfElementWithSelector(element, selector);
+  }
+
+  /**
+   * Returns the type of [element] when being called with [selector].
+   */
+  TypeInformation _typeOfElementWithSelector(
       Element element, Selector selector) {
     if (element.name == Identifiers.noSuchMethod_ &&
         selector.name != element.name) {
       // An invocation can resolve to a [noSuchMethod], in which case
       // we get the return type of [noSuchMethod].
-      return returnTypeOfElement(element);
+      if (element.isLocal) {
+        return returnTypeOfLocalFunction(element);
+      } else {
+        return returnTypeOfMember(element);
+      }
     } else if (selector.isGetter) {
       if (element.isFunction) {
         // [functionType] is null if the inferrer did not run.
         return types.functionType == null
             ? types.dynamicType
             : types.functionType;
       } else if (element.isField) {
-        return typeOfElement(element);
+        return typeOfMember(element);
       } else if (Elements.isUnresolved(element)) {
         return types.dynamicType;
       } else {
         assert(element.isGetter);
-        return returnTypeOfElement(element);
+        if (element.isLocal) {
+          return returnTypeOfLocalFunction(element);
+        } else {
+          return returnTypeOfMember(element);
+        }
       }
     } else if (element.isGetter || element.isField) {
       assert(selector.isCall || selector.isSetter);
       return types.dynamicType;
     } else {
-      return returnTypeOfElement(element);
+      if (element.isLocal) {
+        return returnTypeOfLocalFunction(element);
+      } else {
+        return returnTypeOfMember(element);
+      }
     }
   }
 
   /**
    * Records that the captured variable [local] is read.
    */
   void recordCapturedLocalRead(Local local) {}
 
   /**
    * Records that the variable [local] is being updated.
    */
   void recordLocalUpdate(Local local, TypeInformation type) {}
 }