Split TypeSystem.typeInformations into member/parameter info

pkg/compiler/lib/src/inferrer/type_system.dart

 // Copyright (c) 2017, 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.
 
 import '../common.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart'
     show ResolutionDartType, ResolutionInterfaceType;
 import '../tree/nodes.dart' as ast;
 import '../types/masks.dart';
 import '../universe/selector.dart';
 import '../world.dart';
 import 'type_graph_nodes.dart';
 
 /**
  * The class [SimpleInferrerVisitor] will use when working on types.
  */
 class TypeSystem {
   final ClosedWorld closedWorld;
 
-  /// [ElementTypeInformation]s for elements.
-  final Map<Element, TypeInformation> typeInformations =
-      new Map<Element, TypeInformation>();
+  /// [parameterTypeInformations] and [memberTypeInformations] ordered by
+  /// creation time. This is used as the inference enqueueing order.
+  final List<TypeInformation> _orderedTypeInformations = <TypeInformation>[];
+
+  /// [ParameterTypeInformation]s for parameters.
+  final Map<ParameterElement, TypeInformation> parameterTypeInformations =
+      new Map<ParameterElement, TypeInformation>();
+
+  /// [MemberTypeInformation]s for members.
+  final Map<MemberElement, TypeInformation> memberTypeInformations =
+      new Map<MemberElement, TypeInformation>();
 
   /// [ListTypeInformation] for allocated lists.
   final Map<ast.Node, TypeInformation> allocatedLists =
       new Map<ast.Node, TypeInformation>();
 
   /// [MapTypeInformation] for allocated Maps.
   final Map<ast.Node, TypeInformation> allocatedMaps =
       new Map<ast.Node, TypeInformation>();
 
   /// Closures found during the analysis.
   final Set<TypeInformation> allocatedClosures = new Set<TypeInformation>();
 
   /// Cache of [ConcreteTypeInformation].
   final Map<TypeMask, TypeInformation> concreteTypes =
       new Map<TypeMask, TypeInformation>();
 
   /// List of [TypeInformation]s for calls inside method bodies.
   final List<CallSiteTypeInformation> allocatedCalls =
       <CallSiteTypeInformation>[];
 
   /// List of [TypeInformation]s allocated inside method bodies (narrowing,
   /// phis, and containers).
   final List<TypeInformation> allocatedTypes = <TypeInformation>[];
 
+  /// [parameterTypeInformations] and [memberTypeInformations] ordered by
+  /// creation time. This is used as the inference enqueueing order.
+  Iterable<TypeInformation> get orderedTypeInformations =>
+      _orderedTypeInformations;
+
   Iterable<TypeInformation> get allTypes => [
-        typeInformations.values,
+        parameterTypeInformations.values,
+        memberTypeInformations.values,
         allocatedLists.values,
         allocatedMaps.values,
         allocatedClosures,
         concreteTypes.values,
         allocatedCalls,
         allocatedTypes
       ].expand((x) => x);
 
   TypeSystem(this.closedWorld) {
     nonNullEmptyType = getConcreteTypeFor(commonMasks.emptyType);
@@ skipping 254 matching lines @@
   TypeInformation narrowNotNull(TypeInformation type) {
     if (type.type.isExact && !type.type.isNullable) {
       return type;
     }
     TypeInformation newType =
         new NarrowTypeInformation(type, dynamicType.type.nonNullable());
     allocatedTypes.add(newType);
     return newType;
   }
 
-  ElementTypeInformation getInferredTypeOfParameter(ParameterElement element) {
-    return _getInferredTypeOf(element);
+  ParameterTypeInformation getInferredTypeOfParameter(
+      ParameterElement parameter) {
+    parameter = parameter.implementation;
+
+    ParameterTypeInformation createTypeInformation() {
+      if (parameter.functionDeclaration.isLocal) {
+        LocalFunctionElement localFunction = parameter.functionDeclaration;
+        MethodElement callMethod = localFunction.callMethod;
+        return new ParameterTypeInformation.localFunction(
+            getInferredTypeOfMember(callMethod),
+            parameter,
+            localFunction,
+            callMethod);
+      } else if (parameter.functionDeclaration.isInstanceMember) {
+        MethodElement method = parameter.functionDeclaration;
+        return new ParameterTypeInformation.instanceMember(
+            getInferredTypeOfMember(method),
+            parameter,
+            method,
+            new ParameterAssignments());
+      } else {
+        MethodElement method = parameter.functionDeclaration;
+        return new ParameterTypeInformation.static(
+            getInferredTypeOfMember(method), parameter, method);
+      }
+    }
+
+    return parameterTypeInformations.putIfAbsent(parameter, () {
+      ParameterTypeInformation typeInformation = createTypeInformation();
+      _orderedTypeInformations.add(typeInformation);
+      return typeInformation;
+    });
   }
 
-  ElementTypeInformation getInferredTypeOfMember(MemberElement element) {
-    return _getInferredTypeOf(element);
-  }
-
-  @deprecated
-  ElementTypeInformation _getInferredTypeOf(Element element) {
-    element = element.implementation;
-    assert(element.isParameter || element is MemberElement);
-    return typeInformations[element] ??=
-        new ElementTypeInformation(element, this);
+  MemberTypeInformation getInferredTypeOfMember(MemberElement member) {
+    member = member.implementation;
+    return memberTypeInformations.putIfAbsent(member, () {
+      MemberTypeInformation typeInformation = new MemberTypeInformation(member);
+      _orderedTypeInformations.add(typeInformation);
+      return typeInformation;
+    });
   }
 
   /**
    * Returns the internal inferrer representation for [mask].
    */
   ConcreteTypeInformation getConcreteTypeFor(TypeMask mask) {
     assert(mask != null);
     return concreteTypes.putIfAbsent(mask, () {
       return new ConcreteTypeInformation(mask);
     });
@@ skipping 215 matching lines @@
     TypeMask newType = null;
     for (TypeMask mask in list) {
       newType = newType == null ? mask : newType.union(mask, closedWorld);
       // Likewise - stop early if we already reach dynamic.
       if (newType.containsAll(closedWorld)) return dynamicType;
     }
 
     return newType ?? const TypeMask.nonNullEmpty();
   }
 }