Use entities 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 375 matching lines @@
    * A call site is either an AST [ast.Node], an [Element] (see uses of
    * [synthesizeForwardingCall] in [SimpleTypeInferrerVisitor]).
    *
    * The global information is summarized in [cleanup], after which [_callers]
    * is set to `null`.
    */
   Map<MemberEntity, Setlet<Spannable>> _callers;
 
   MemberTypeInformation._internal(this._member) : super._internal(null);
 
-  MemberElement get member => _member;
+  MemberEntity get member => _member;
 
   String get debugName => '$member';
 
   void addCall(MemberEntity caller, Spannable node) {
     assert(node is ast.Node || node is Element);
     _callers ??= <MemberEntity, Setlet<Spannable>>{};
     _callers.putIfAbsent(caller, () => new Setlet()).add(node);
   }
 
   void removeCall(MemberEntity caller, node) {
@@ skipping 262 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 {
-  final ParameterElement _parameter;
-  final MethodElement _method;
-  bool _isInstanceMemberParameter;
-  bool _isClosureParameter;
+  final Local _parameter;
+  final DartType _type;
+  final FunctionEntity _method;
+  final bool _isInstanceMemberParameter;
+  final bool _isClosureParameter;
+  final bool _isInitializingFormal;
   bool _isTearOffClosureParameter = false;
 
   ParameterTypeInformation.localFunction(
-      MemberTypeInformation context, this._parameter, this._method)
+      MemberTypeInformation context, this._parameter, this._type, this._method)
       : _isInstanceMemberParameter = false,
         _isClosureParameter = true,
+        _isInitializingFormal = false,
         super._internal(context);
 
   ParameterTypeInformation.static(
-      MemberTypeInformation context, this._parameter, this._method)
+      MemberTypeInformation context, this._parameter, this._type, this._method,
+      {bool isInitializingFormal: false})
       : _isInstanceMemberParameter = false,
         _isClosureParameter = false,
+        _isInitializingFormal = isInitializingFormal,
         super._internal(context);
 
-  ParameterTypeInformation.instanceMember(MemberTypeInformation context,
-      this._parameter, this._method, ParameterAssignments assignments)
+  ParameterTypeInformation.instanceMember(
+      MemberTypeInformation context,
+      this._parameter,
+      this._type,
+      this._method,
+      ParameterAssignments assignments)
       : _isInstanceMemberParameter = true,
         _isClosureParameter = false,
+        _isInitializingFormal = false,
         super._withAssignments(context, assignments);
 
-  MethodElement get method => _method;
+  FunctionEntity get method => _method;
 
   Local get parameter => _parameter;
 
   String get debugName => '$parameter';
 
   void tagAsTearOffClosureParameter(InferrerEngine inferrer) {
-    assert(_parameter.isRegularParameter);
+    assert(!_isInitializingFormal);
     _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.optimizerHints.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 (_isInitializingFormal) return null;
 
     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 (_isInstanceMemberParameter &&
@@ skipping 26 matching lines @@
   TypeMask potentiallyNarrowType(TypeMask mask, InferrerEngine inferrer) {
     Compiler compiler = inferrer.compiler;
     if (!compiler.options.trustTypeAnnotations &&
         !inferrer.optimizerHints.trustTypeAnnotations(_method)) {
       return mask;
     }
     // When type assertions are enabled (aka checked mode), we have to always
     // ignore type annotations to ensure that the checks are actually inserted
     // into the function body and retained until runtime.
     assert(!compiler.options.enableTypeAssertions);
-    return _narrowType(inferrer.closedWorld, mask, _parameter.type);
+    return _narrowType(inferrer.closedWorld, mask, _type);
   }
 
   TypeMask computeType(InferrerEngine inferrer) {
     TypeMask special = handleSpecialCases(inferrer);
     if (special != null) return special;
     return potentiallyNarrowType(
         inferrer.types.computeTypeMask(assignments), inferrer);
   }
 
   TypeMask safeType(InferrerEngine inferrer) {
@@ skipping 1099 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);
 }