Use entities internally in MemberTypeInformation

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 322 matching lines @@
  *
  * - Fields and parameters being assigned by synthesized calls done by
  *   the backend: we do not know what types the backend will use.
  *
  * - Native functions and fields: because native methods contain no Dart
  *   code, and native fields do not have Dart assignments, we just
  *   trust their type annotation.
  *
  */
 abstract class ElementTypeInformation extends TypeInformation {
-  final Element _element;
-
   /// Marker to disable inference for closures in [handleSpecialCases].
   bool disableInferenceForClosures = true;
 
-  ElementTypeInformation._internal(MemberTypeInformation context, this._element)
+  ElementTypeInformation._internal(MemberTypeInformation context)
       : super(context);
-  ElementTypeInformation._withAssignments(MemberTypeInformation context,
-      this._element, ParameterAssignments assignments)
+  ElementTypeInformation._withAssignments(
+      MemberTypeInformation context, ParameterAssignments assignments)
       : super.withAssignments(context, assignments);
 
   String getInferredSignature(TypeSystem types);
 
   String get debugName;
 }
 
 /**
  * A node representing members in the broadest sense:
  *
  * - Functions
  * - Constructors
  * - Fields (also synthetic ones due to closures)
  * - Local functions (closures)
  *
  * These should never be created directly but instead are constructed by
  * the [ElementTypeInformation] factory.
  */
 abstract class MemberTypeInformation extends ElementTypeInformation
     with ApplyableTypeInformation {
-  MemberElement get _member => super._element;
+  final MemberEntity _member;
 
   /**
    * If [element] is a function, [closurizedCount] is the number of
    * times it is closurized. The value gets updated while inferring.
    */
   int closurizedCount = 0;
 
   // Strict `bool` value is computed in cleanup(). Also used as a flag to see if
   // cleanup has been called.
   bool _isCalledOnce = null;
 
   /**
    * This map contains the callers of [element]. It stores all unique call sites
    * to enable counting the global number of call sites of [element].
    *
    * 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<MemberElement, Setlet<Spannable>> _callers;
 
-  MemberTypeInformation._internal(MemberElement element)
-      : super._internal(null, element);
+  MemberTypeInformation._internal(this._member) : super._internal(null);
 
-  MemberElement get member => _element;
+  MemberElement get member => _member;
 
   String get debugName => '$member';
 
   void addCall(MemberElement caller, Spannable node) {
     assert(node is ast.Node || node is Element);
     _callers ??= <MemberElement, Setlet<Spannable>>{};
     _callers.putIfAbsent(caller, () => new Setlet()).add(node);
   }
 
   void removeCall(MemberElement caller, node) {
@@ skipping 57 matching lines @@
               inferrer.closedWorld.nativeData.getNativeMethodBehavior(function))
           .type;
     }
     return null;
   }
 
   TypeMask potentiallyNarrowType(TypeMask mask, InferrerEngine inferrer) {
     Compiler compiler = inferrer.compiler;
     if (!compiler.options.trustTypeAnnotations &&
         !compiler.options.enableTypeAssertions &&
-        !inferrer.trustTypeAnnotations(_member)) {
+        !inferrer.optimizerHints.trustTypeAnnotations(_member)) {
       return mask;
     }
     return _potentiallyNarrowType(mask, inferrer);
   }
 
   TypeMask _potentiallyNarrowType(TypeMask mask, InferrerEngine inferrer);
 
   TypeMask computeType(InferrerEngine inferrer) {
     TypeMask special = handleSpecialCases(inferrer);
     if (special != null) return potentiallyNarrowType(special, inferrer);
@@ skipping 19 matching lines @@
     super.cleanup();
   }
 
   @override
   String getInferredSignature(TypeSystem types) {
     return types.getInferredSignatureOfMethod(_member);
   }
 }
 
 class FieldTypeInformation extends MemberTypeInformation {
-  FieldElement get _field => _member;
+  FieldEntity get _field => _member;
+  final DartType _type;
 
-  FieldTypeInformation(FieldElement element) : super._internal(element);
+  FieldTypeInformation(FieldEntity element, this._type)
+      : super._internal(element);
 
   TypeMask handleSpecialCases(InferrerEngine inferrer) {
     if (!inferrer.backend.canFieldBeUsedForGlobalOptimizations(
             _field, inferrer.closedWorld) ||
-        inferrer.assumeDynamic(_field)) {
+        inferrer.optimizerHints.assumeDynamic(_field)) {
       // Do not infer types for fields that have a corresponding annotation or
       // are assigned by synthesized calls
 
       giveUp(inferrer);
       return safeType(inferrer);
     }
     if (inferrer.closedWorld.nativeData.isNativeMember(_field)) {
       // Use the type annotation as the type for native elements. We
       // also give up on inferring to make sure this element never
       // goes in the work queue.
       giveUp(inferrer);
       return inferrer
           .typeOfNativeBehavior(inferrer.closedWorld.nativeData
               .getNativeFieldLoadBehavior(_field))
           .type;
     }
     return null;
   }
 
   TypeMask _potentiallyNarrowType(TypeMask mask, InferrerEngine inferrer) {
-    return _narrowType(inferrer.closedWorld, mask, _field.type);
+    return _narrowType(inferrer.closedWorld, mask, _type);
   }
 
   bool hasStableType(InferrerEngine inferrer) {
     // The number of assignments of non-final fields is
     // not stable. Therefore such a field cannot be stable.
-    if (!(_field.isConst || _field.isFinal)) {
+    if (!_field.isAssignable) {
       return false;
     }
     return super.hasStableType(inferrer);
   }
 }
 
 class GetterTypeInformation extends MemberTypeInformation {
-  GetterElement get _getter => _member;
+  FunctionEntity get _getter => _member;
+  final FunctionType _type;
 
-  GetterTypeInformation(GetterElement element) : super._internal(element);
+  GetterTypeInformation(FunctionEntity element, this._type)
+      : super._internal(element);
 
   TypeMask handleSpecialCases(InferrerEngine inferrer) {
     return _handleFunctionCase(_getter, inferrer);
   }
 
   TypeMask _potentiallyNarrowType(TypeMask mask, InferrerEngine inferrer) {
-    FunctionType type = _getter.type;
-    return _narrowType(inferrer.closedWorld, mask, type.returnType);
+    return _narrowType(inferrer.closedWorld, mask, _type.returnType);
   }
 
   bool hasStableType(InferrerEngine inferrer) {
     return super.hasStableType(inferrer);
   }
 }
 
 class SetterTypeInformation extends MemberTypeInformation {
-  SetterElement get _setter => _member;
+  FunctionEntity get _setter => _member;
 
-  SetterTypeInformation(SetterElement element) : super._internal(element);
+  SetterTypeInformation(FunctionEntity element) : super._internal(element);
 
   TypeMask handleSpecialCases(InferrerEngine inferrer) {
     return _handleFunctionCase(_setter, inferrer);
   }
 
   TypeMask _potentiallyNarrowType(TypeMask mask, InferrerEngine inferrer) {
     return mask;
   }
 
   bool hasStableType(InferrerEngine inferrer) {
     return super.hasStableType(inferrer);
   }
 }
 
 class MethodTypeInformation extends MemberTypeInformation {
-  MethodElement get _method => _member;
+  FunctionEntity get _method => _member;
+  final FunctionType _type;
 
-  MethodTypeInformation(MethodElement element) : super._internal(element);
+  MethodTypeInformation(FunctionEntity element, this._type)
+      : super._internal(element);
 
   TypeMask handleSpecialCases(InferrerEngine inferrer) {
     return _handleFunctionCase(_method, inferrer);
   }
 
   TypeMask _potentiallyNarrowType(TypeMask mask, InferrerEngine inferrer) {
-    FunctionType type = _method.type;
-    return _narrowType(inferrer.closedWorld, mask, type.returnType);
+    return _narrowType(inferrer.closedWorld, mask, _type.returnType);
   }
 
   bool hasStableType(InferrerEngine inferrer) {
     return false;
   }
 }
 
 class FactoryConstructorTypeInformation extends MemberTypeInformation {
-  ConstructorElement get _constructor => _member;
+  ConstructorEntity get _constructor => _member;
+  final FunctionType _type;
 
-  FactoryConstructorTypeInformation(ConstructorElement element)
+  FactoryConstructorTypeInformation(ConstructorEntity element, this._type)
       : super._internal(element);
 
   TypeMask handleSpecialCases(InferrerEngine inferrer) {
     CommonMasks commonMasks = inferrer.commonMasks;
-    if (_constructor.isIntFromEnvironmentConstructor) {
-      giveUp(inferrer);
-      return commonMasks.intType.nullable();
-    } else if (_constructor.isBoolFromEnvironmentConstructor) {
-      giveUp(inferrer);
-      return commonMasks.boolType.nullable();
-    } else if (_constructor.isStringFromEnvironmentConstructor) {
-      giveUp(inferrer);
-      return commonMasks.stringType.nullable();
+    if (_constructor.isFromEnvironmentConstructor) {
+      if (_constructor.enclosingClass == inferrer.commonElements.intClass) {
+        giveUp(inferrer);
+        return commonMasks.intType.nullable();
+      } else if (_constructor.enclosingClass ==
+          inferrer.commonElements.boolClass) {
+        giveUp(inferrer);
+        return commonMasks.boolType.nullable();
+      } else if (_constructor.enclosingClass ==
+          inferrer.commonElements.stringClass) {
+        giveUp(inferrer);
+        return commonMasks.stringType.nullable();
+      }
     }
     return _handleFunctionCase(_constructor, inferrer);
   }
 
   TypeMask _potentiallyNarrowType(TypeMask mask, InferrerEngine inferrer) {
-    FunctionType type = _constructor.type;
-    return _narrowType(inferrer.closedWorld, mask, type.returnType);
+    return _narrowType(inferrer.closedWorld, mask, _type.returnType);
   }
 
   bool hasStableType(InferrerEngine inferrer) {
     return super.hasStableType(inferrer);
   }
 }
 
 class GenerativeConstructorTypeInformation extends MemberTypeInformation {
-  ConstructorElement get _constructor => _member;
+  ConstructorEntity get _constructor => _member;
 
   GenerativeConstructorTypeInformation(ConstructorElement element)
       : super._internal(element);
 
   TypeMask handleSpecialCases(InferrerEngine inferrer) {
     return _handleFunctionCase(_constructor, inferrer);
   }
 
   TypeMask _potentiallyNarrowType(TypeMask mask, InferrerEngine inferrer) {
     return mask;
   }
 
   bool hasStableType(InferrerEngine inferrer) {
     return super.hasStableType(inferrer);
   }
 }
 
 /**
  * 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 ParameterElement _parameter;
   final MethodElement _method;
   bool _isInstanceMemberParameter;
   bool _isClosureParameter;
   bool _isTearOffClosureParameter = false;
 
   ParameterTypeInformation.localFunction(
-      MemberTypeInformation context, ParameterElement parameter, this._method)
+      MemberTypeInformation context, this._parameter, this._method)
       : _isInstanceMemberParameter = false,
         _isClosureParameter = true,
-        super._internal(context, parameter);
+        super._internal(context);
 
   ParameterTypeInformation.static(
-      MemberTypeInformation context, ParameterElement parameter, this._method)
+      MemberTypeInformation context, this._parameter, this._method)
       : _isInstanceMemberParameter = false,
         _isClosureParameter = false,
-        super._internal(context, parameter);
+        super._internal(context);
 
-  ParameterTypeInformation.instanceMember(
-      MemberTypeInformation context,
-      ParameterElement parameter,
-      this._method,
-      ParameterAssignments assignments)
+  ParameterTypeInformation.instanceMember(MemberTypeInformation context,
+      this._parameter, this._method, ParameterAssignments assignments)
       : _isInstanceMemberParameter = true,
         _isClosureParameter = false,
-        super._withAssignments(context, parameter, assignments);
+        super._withAssignments(context, assignments);
 
   MethodElement get method => _method;
 
   Local get parameter => _parameter;
 
   String get debugName => '$parameter';
 
   void tagAsTearOffClosureParameter(InferrerEngine inferrer) {
     assert(_parameter.isRegularParameter);
     _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)) {
+        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;
 
@@ skipping 28 matching lines @@
       giveUp(inferrer);
       return safeType(inferrer);
     }
 
     return null;
   }
 
   TypeMask potentiallyNarrowType(TypeMask mask, InferrerEngine inferrer) {
     Compiler compiler = inferrer.compiler;
     if (!compiler.options.trustTypeAnnotations &&
-        !inferrer.trustTypeAnnotations(_method)) {
+        !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);
   }
 
   TypeMask computeType(InferrerEngine inferrer) {
@@ skipping 1106 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);
 }