Remove reference of LocalFunctionElement in ParameterTypeInformation.

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 568 matching lines @@
  * A node representing parameters:
  *
  * - Parameters
  * - Initializing formals
  *
  * These should never be created directly but instead are constructed by
  * the [ElementTypeInformation] factory.
  */
 class ParameterTypeInformation extends ElementTypeInformation {
   ParameterElement get _parameter => super._element;
-  final FunctionElement _declaration;
   final MethodElement _method;
+  bool _isInstanceMemberParameter;
+  bool _isClosureParameter;
+  bool _isTearOffClosureParameter = false;
 
-  ParameterTypeInformation.localFunction(MemberTypeInformation context,
-      ParameterElement parameter, this._declaration, this._method)
-      : super._internal(context, parameter);
+  ParameterTypeInformation.localFunction(
+      MemberTypeInformation context, ParameterElement parameter, this._method)
+      : _isInstanceMemberParameter = false,
+        _isClosureParameter = true,
+        super._internal(context, parameter);
 
   ParameterTypeInformation.static(
       MemberTypeInformation context, ParameterElement parameter, this._method)
-      : this._declaration = _method,
+      : _isInstanceMemberParameter = false,
+        _isClosureParameter = false,
         super._internal(context, parameter);
 
   ParameterTypeInformation.instanceMember(
       MemberTypeInformation context,
       ParameterElement parameter,
       this._method,
       ParameterAssignments assignments)
-      : this._declaration = _method,
+      : _isInstanceMemberParameter = true,
+        _isClosureParameter = false,
         super._withAssignments(context, parameter, assignments);
 
   MethodElement get method => _method;
 
   Local get parameter => _parameter;
 
   String get debugName => '$parameter';
 
-  bool isTearOffClosureParameter = false;
-
   void tagAsTearOffClosureParameter(InferrerEngine inferrer) {
     assert(_parameter.isRegularParameter);
-    isTearOffClosureParameter = true;
+    _isTearOffClosureParameter = true;
     // We have to add a flow-edge for the default value (if it exists), as we
     // might not see all call-sites and thus miss the use of it.
     TypeInformation defaultType =
         inferrer.getDefaultTypeOfParameter(_parameter);
     if (defaultType != null) defaultType.addUser(this);
   }
 
   // TODO(herhut): Cleanup into one conditional.
   TypeMask handleSpecialCases(InferrerEngine inferrer) {
     if (!inferrer.backend.canFunctionParametersBeUsedForGlobalOptimizations(
             _method, inferrer.closedWorld) ||
         inferrer.assumeDynamic(_method)) {
       // Do not infer types for parameters that have a corresponding annotation
       // or that are assigned by synthesized calls.
       giveUp(inferrer);
       return safeType(inferrer);
     }
 
     // The below do not apply to parameters of constructors, so skip
     // initializing formals.
     if (_parameter.isInitializingFormal) return null;
 
-    if ((isTearOffClosureParameter || _declaration.isLocal) &&
+    if ((_isTearOffClosureParameter || _isClosureParameter) &&
         disableInferenceForClosures) {
       // Do not infer types for parameters of closures. We do not
       // clear the assignments in case the closure is successfully
       // traced.
       giveUp(inferrer, clearAssignments: false);
       return safeType(inferrer);
     }
-    if (_declaration.isInstanceMember &&
-        (_declaration.name == Identifiers.noSuchMethod_ ||
-            (_declaration.name == Identifiers.call &&
+    if (_isInstanceMemberParameter &&
+        (_method.name == Identifiers.noSuchMethod_ ||
+            (_method.name == Identifiers.call &&
                 disableInferenceForClosures))) {
       // Do not infer types for parameters of [noSuchMethod] and
       // [call] instance methods.
       giveUp(inferrer);
       return safeType(inferrer);
     }
     if (inferrer.closedWorldRefiner
         .getCurrentlyKnownMightBePassedToApply(_method)) {
       giveUp(inferrer);
       return safeType(inferrer);
@@ skipping 31 matching lines @@
         inferrer.types.computeTypeMask(assignments), inferrer);
   }
 
   TypeMask safeType(InferrerEngine inferrer) {
     return potentiallyNarrowType(super.safeType(inferrer), inferrer);
   }
 
   bool hasStableType(InferrerEngine inferrer) {
     // The number of assignments of parameters of instance methods is
     // not stable. Therefore such a parameter cannot be stable.
-    if (_declaration.isInstanceMember) {
+    if (_isInstanceMemberParameter) {
       return false;
     }
     return super.hasStableType(inferrer);
   }
 
   accept(TypeInformationVisitor visitor) {
     return visitor.visitParameterTypeInformation(this);
   }
 
   String toString() => 'ParameterElement $_parameter $type';
@@ skipping 1082 matching lines @@
     // TODO(ngeoffray): Narrow to bound.
     return type;
   } else {
     ResolutionInterfaceType interfaceType = annotation;
     otherType = new TypeMask.nonNullSubtype(interfaceType.element, closedWorld);
   }
   if (isNullable) otherType = otherType.nullable();
   if (type == null) return otherType;
   return type.intersection(otherType, closedWorld);
 }