Split MemberTypeInformation by member kind

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;
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart'
-    show
-        ResolutionDartType,
-        ResolutionFunctionType,
-        ResolutionInterfaceType,
-        ResolutionTypeKind;
+    show ResolutionDartType, ResolutionInterfaceType;
+import '../elements/types.dart';
 import '../tree/tree.dart' as ast show Node, Send;
 import '../types/masks.dart'
     show
         CommonMasks,
         ContainerTypeMask,
         DictionaryTypeMask,
         MapTypeMask,
         TypeMask,
         ValueTypeMask;
 import '../universe/selector.dart' show Selector;
@@ skipping 332 matching lines @@
  * 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.
  */
-class MemberTypeInformation extends ElementTypeInformation
+abstract class MemberTypeInformation extends ElementTypeInformation
     with ApplyableTypeInformation {
   MemberElement get _member => super._element;
 
   /**
    * 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(MemberElement element) : super._internal(null, element);
+  MemberTypeInformation._internal(MemberElement element)
+      : super._internal(null, element);
 
   MemberElement get member => _element;
 
   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);
   }
@@ skipping 38 matching lines @@
   }
 
   bool get isClosurized => closurizedCount > 0;
 
   // Closurized methods never become stable to ensure that the information in
   // [users] is accurate. The inference stops tracking users for stable types.
   // Note that we only override the getter, the setter will still modify the
   // state of the [isStable] field inherited from [TypeInformation].
   bool get isStable => super.isStable && !isClosurized;
 
-  TypeMask handleSpecialCases(InferrerEngine inferrer) {
-    if (_member.isField &&
-        (!inferrer.backend.canFieldBeUsedForGlobalOptimizations(
-                _member, inferrer.closedWorld) ||
-            inferrer.assumeDynamic(_member))) {
-      // Do not infer types for fields that have a corresponding annotation or
-      // are assigned by synthesized calls
+  TypeMask handleSpecialCases(InferrerEngine inferrer);
 
-      giveUp(inferrer);
-      return safeType(inferrer);
-    }
-    if (inferrer.closedWorld.nativeData.isNativeMember(_member)) {
+  TypeMask _handleFunctionCase(
+      FunctionEntity function, InferrerEngine inferrer) {
+    if (inferrer.closedWorld.nativeData.isNativeMember(function)) {
       // 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);
-      if (_member.isField) {
-        FieldElement field = _member;
-        return inferrer
-            .typeOfNativeBehavior(inferrer.closedWorld.nativeData
-                .getNativeFieldLoadBehavior(field))
-            .type;
-      } else {
-        assert(_member.isFunction ||
-            _member.isGetter ||
-            _member.isSetter ||
-            _member.isConstructor);
-        MethodElement methodElement = _member;
-        var elementType = methodElement.type;
-        if (elementType.kind != ResolutionTypeKind.FUNCTION) {
-          return safeType(inferrer);
-        } else {
-          return inferrer
-              .typeOfNativeBehavior(inferrer.closedWorld.nativeData
-                  .getNativeMethodBehavior(methodElement))
-              .type;
-        }
-      }
-    }
-
-    CommonMasks commonMasks = inferrer.commonMasks;
-    if (_member.isConstructor) {
-      ConstructorElement constructor = _member;
-      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();
-      }
+      return inferrer
+          .typeOfNativeBehavior(
+              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)) {
       return mask;
     }
-    if (_member.isGenerativeConstructor || _member.isSetter) {
-      return mask;
-    }
-    if (_member.isField) {
-      return _narrowType(inferrer.closedWorld, mask, _member.type);
-    }
-    assert(
-        _member.isFunction || _member.isGetter || _member.isFactoryConstructor);
+    return _potentiallyNarrowType(mask, inferrer);
+  }
 
-    ResolutionFunctionType type = _member.type;
-    return _narrowType(inferrer.closedWorld, mask, type.returnType);
-  }
+  TypeMask _potentiallyNarrowType(TypeMask mask, InferrerEngine inferrer);
 
   TypeMask computeType(InferrerEngine inferrer) {
     TypeMask special = handleSpecialCases(inferrer);
     if (special != null) return potentiallyNarrowType(special, inferrer);
     return potentiallyNarrowType(
         inferrer.types.computeTypeMask(assignments), inferrer);
   }
 
   TypeMask safeType(InferrerEngine inferrer) {
     return potentiallyNarrowType(super.safeType(inferrer), inferrer);
   }
 
   String toString() => 'MemberElement $_member $type';
 
   accept(TypeInformationVisitor visitor) {
     return visitor.visitMemberTypeInformation(this);
   }
 
-  bool hasStableType(InferrerEngine inferrer) {
-    // The number of assignments of non-final fields is
-    // not stable. Therefore such a field cannot be stable.
-    if (_member.isField && !(_member.isConst || _member.isFinal)) {
-      return false;
-    }
-
-    if (_member.isFunction) return false;
-
-    return super.hasStableType(inferrer);
-  }
-
   void cleanup() {
     // This node is on multiple lists so cleanup() can be called twice.
     if (_isCalledOnce != null) return;
     _isCalledOnce = _computeIsCalledOnce();
     _callers = null;
     super.cleanup();
   }
 
   @override
   String getInferredSignature(TypeSystem types) {
     return types.getInferredSignatureOfMethod(_member);
   }
 }
 
+class FieldTypeInformation extends MemberTypeInformation {
+  FieldElement get _field => _member;
+
+  FieldTypeInformation(FieldElement element) : super._internal(element);
+
+  TypeMask handleSpecialCases(InferrerEngine inferrer) {
+    if (!inferrer.backend.canFieldBeUsedForGlobalOptimizations(
+            _field, inferrer.closedWorld) ||
+        inferrer.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);
+  }
+
+  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)) {
+      return false;
+    }
+    return super.hasStableType(inferrer);
+  }
+}
+
+class GetterTypeInformation extends MemberTypeInformation {
+  GetterElement get _getter => _member;
+
+  GetterTypeInformation(GetterElement element) : 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);
+  }
+}
+
+class SetterTypeInformation extends MemberTypeInformation {
+  SetterElement get _setter => _member;
+
+  SetterTypeInformation(SetterElement element) : super._internal(element);
+
+  TypeMask handleSpecialCases(InferrerEngine inferrer) {
+    return _handleFunctionCase(_setter, inferrer);
+  }
+
+  TypeMask _potentiallyNarrowType(TypeMask mask, InferrerEngine inferrer) {
+    return mask;
+  }
+}
+
+class MethodTypeInformation extends MemberTypeInformation {
+  MethodElement get _method => _member;
+
+  MethodTypeInformation(MethodElement element) : 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);
+  }
+
+  bool hasStableType(InferrerEngine inferrer) => false;
+}
+
+class FactoryConstructorTypeInformation extends MemberTypeInformation {
+  ConstructorElement get _constructor => _member;
+
+  FactoryConstructorTypeInformation(ConstructorElement element)
+      : 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();
+    }
+    return _handleFunctionCase(_constructor, inferrer);
+  }
+
+  TypeMask _potentiallyNarrowType(TypeMask mask, InferrerEngine inferrer) {
+    FunctionType type = _constructor.type;
+    return _narrowType(inferrer.closedWorld, mask, type.returnType);
+  }
+
+  bool hasStableType(InferrerEngine inferrer) {
+    return super.hasStableType(inferrer);
+  }
+}
+
+class GenerativeConstructorTypeInformation extends MemberTypeInformation {
+  ConstructorElement 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 MethodElement _method;
   bool _isInstanceMemberParameter;
   bool _isClosureParameter;
   bool _isTearOffClosureParameter = false;
 
-  ParameterTypeInformation.localFunction(MemberTypeInformation context,
-      ParameterElement parameter, this._method)
+  ParameterTypeInformation.localFunction(
+      MemberTypeInformation context, ParameterElement parameter, this._method)
       : _isInstanceMemberParameter = false,
         _isClosureParameter = true,
         super._internal(context, parameter);
 
   ParameterTypeInformation.static(
       MemberTypeInformation context, ParameterElement parameter, this._method)
       : _isInstanceMemberParameter = false,
         _isClosureParameter = false,
         super._internal(context, parameter);
 
@@ skipping 1195 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);
 }