Split TypeSystem.typeInformations into member/parameter info

pkg/compiler/lib/src/types/types.dart

 // Copyright (c) 2012, 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 types;
 
 import '../common.dart' show failedAt;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../elements/elements.dart';
@@ skipping 15 matching lines @@
 /// closed-world semantics. Any [TypeMask] for an element or node that we return
 /// was inferred to be a "guaranteed type", that means, it is a type that we
 /// can prove to be correct for all executions of the program.  A trivial
 /// implementation would return false on all boolean properties (giving no
 /// guarantees) and the `subclass of Object or null` type mask for the type
 /// based queries (the runtime value could be anything).
 abstract class GlobalTypeInferenceElementResult {
   /// Whether the method element associated with this result always throws.
   bool get throwsAlways;
 
-  /// Whether the element associated with this result is only called once in one
-  /// location in the entire program.
-  bool get isCalledOnce;
-
   /// The inferred type when this result belongs to a parameter or field
   /// element, null otherwise.
   TypeMask get type;
 
   /// The inferred return type when this result belongs to a function element.
   TypeMask get returnType;
 
   /// Returns the type of a list new expression [node].
   TypeMask typeOfNewList(Send node);
 
@@ skipping 14 matching lines @@
   /// Returns the type of the iterator in a [loop].
   TypeMask typeOfIterator(ForIn node);
 
   /// Returns the type of the `moveNext` call of an iterator in a [loop].
   TypeMask typeOfIteratorMoveNext(ForIn node);
 
   /// Returns the type of the `current` getter of an iterator in a [loop].
   TypeMask typeOfIteratorCurrent(ForIn node);
 }
 
+abstract class GlobalTypeInferenceMemberResult
+    extends GlobalTypeInferenceElementResult {
+  /// Whether the member associated with this result is only called once in one
+  /// location in the entire program.
+  bool get isCalledOnce;
+}
+
 abstract class GlobalTypeInferenceElementResultImpl
     implements GlobalTypeInferenceElementResult {
   // TODO(sigmund): delete, store data directly here.
   final Element _owner;
 
   // TODO(sigmund): split - stop using _data after inference is done.
   final GlobalTypeInferenceElementData _data;
 
   // TODO(sigmund): store relevant data & drop reference to inference engine.
   final TypesInferrer _inferrer;
@@ skipping 17 matching lines @@
   TypeMask typeOfSend(Send node) => _data?.typeOfSend(node);
   TypeMask typeOfGetter(SendSet node) => _data?.typeOfGetter(node);
   TypeMask typeOfOperator(SendSet node) => _data?.typeOfOperator(node);
   TypeMask typeOfIterator(ForIn node) => _data?.typeOfIterator(node);
   TypeMask typeOfIteratorMoveNext(ForIn node) =>
       _data?.typeOfIteratorMoveNext(node);
   TypeMask typeOfIteratorCurrent(ForIn node) =>
       _data?.typeOfIteratorCurrent(node);
 }
 
-class GlobalTypeInferenceMemberResult
-    extends GlobalTypeInferenceElementResultImpl {
-  GlobalTypeInferenceMemberResult(
+class GlobalTypeInferenceMemberResultImpl
+    extends GlobalTypeInferenceElementResultImpl
+    implements GlobalTypeInferenceMemberResult {
+  GlobalTypeInferenceMemberResultImpl(
       MemberElement owner,
       GlobalTypeInferenceElementData data,
       TypesInferrer inferrer,
       bool isJsInterop,
       TypeMask _dynamic)
       : super.internal(owner, data, inferrer, isJsInterop, _dynamic);
 
   bool get isCalledOnce => _inferrer.isMemberCalledOnce(_owner);
 
   TypeMask get returnType =>
       _isJsInterop ? _dynamic : _inferrer.getReturnTypeOfMember(_owner);
 
   TypeMask get type =>
       _isJsInterop ? _dynamic : _inferrer.getTypeOfMember(_owner);
 }
 
 class GlobalTypeInferenceParameterResult
     extends GlobalTypeInferenceElementResultImpl {
   GlobalTypeInferenceParameterResult(
       ParameterElement owner, TypesInferrer inferrer, TypeMask _dynamic)
       : super.internal(owner, null, inferrer, false, _dynamic);
 
-  bool get isCalledOnce => _inferrer.isParameterCalledOnce(_owner);
-
   TypeMask get returnType =>
       _isJsInterop ? _dynamic : _inferrer.getReturnTypeOfParameter(_owner);
 
   TypeMask get type =>
       _isJsInterop ? _dynamic : _inferrer.getTypeOfParameter(_owner);
 }
 
 /// Internal data used during type-inference to store intermediate results about
 /// a single element.
 class GlobalTypeInferenceElementData {
@@ skipping 50 matching lines @@
 abstract class TypesInferrer {
   void analyzeMain(FunctionEntity element);
   TypeMask getReturnTypeOfMember(MemberElement element);
   TypeMask getReturnTypeOfParameter(ParameterElement element);
   TypeMask getTypeOfMember(MemberElement element);
   TypeMask getTypeOfParameter(ParameterElement element);
   TypeMask getTypeForNewList(Node node);
   TypeMask getTypeOfSelector(Selector selector, TypeMask mask);
   void clear();
   bool isMemberCalledOnce(MemberElement element);
-  bool isParameterCalledOnce(ParameterElement element);
   bool isFixedArrayCheckedForGrowable(Node node);
 }
 
 /// Results produced by the global type-inference algorithm.
 ///
 /// All queries in this class may contain results that assume whole-program
 /// closed-world semantics. Any [TypeMask] for an element or node that we return
 /// was inferred to be a "guaranteed type", that means, it is a type that we
 /// can prove to be correct for all executions of the program.
 class GlobalTypeInferenceResults {
   // TODO(sigmund): store relevant data & drop reference to inference engine.
   final TypeGraphInferrer _inferrer;
   final ClosedWorld closedWorld;
   final Map<MemberElement, GlobalTypeInferenceMemberResult> _memberResults =
       <MemberElement, GlobalTypeInferenceMemberResult>{};
   final Map<ParameterElement, GlobalTypeInferenceParameterResult>
       _parameterResults =
       <ParameterElement, GlobalTypeInferenceParameterResult>{};
 
   // TODO(sigmund,johnniwinther): compute result objects eagerly and make it an
   // error to query for results that don't exist.
-  GlobalTypeInferenceElementResult resultOfMember(MemberElement member) {
+  GlobalTypeInferenceMemberResult resultOfMember(MemberElement member) {
     assert(
         !member.isGenerativeConstructorBody,
         failedAt(
             member,
             "unexpected input: ConstructorBodyElements are created"
             " after global type inference, no data is avaiable for them."));
 
     bool isJsInterop = closedWorld.nativeData.isJsInteropMember(member);
     return _memberResults.putIfAbsent(
         member,
-        () => new GlobalTypeInferenceMemberResult(
+        () => new GlobalTypeInferenceMemberResultImpl(
             member,
             // We store data in the context of the enclosing method, even
             // for closure elements.
             _inferrer.inferrer.lookupDataOfMember(member.memberContext),
             _inferrer,
             isJsInterop,
             dynamicType));
   }
 
   // TODO(sigmund,johnniwinther): compute result objects eagerly and make it an
@@ skipping 47 matching lines @@
     measure(() {
       typesInferrerInternal ??=
           new TypeGraphInferrer(compiler, closedWorld, closedWorldRefiner);
       typesInferrerInternal.analyzeMain(mainElement);
       typesInferrerInternal.clear();
       results = new GlobalTypeInferenceResults(typesInferrerInternal,
           closedWorld, typesInferrerInternal.inferrer.types);
     });
   }
 }