Split TypeSystem.typeInformations into member/parameter info

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 330 matching lines @@
  *   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;
 
-  factory ElementTypeInformation(Element element, TypeSystem types) {
-    if (element.isParameter) {
-      ParameterElement parameter = element;
-      if (parameter.functionDeclaration.isLocal) {
-        return new ParameterTypeInformation._localFunction(element, types);
-      } else if (parameter.functionDeclaration.isInstanceMember) {
-        return new ParameterTypeInformation._instanceMember(element, types);
-      }
-      return new ParameterTypeInformation._static(element, types);
-    }
-    return new MemberTypeInformation(element);
-  }
-
   ElementTypeInformation._internal(MemberTypeInformation context, this._element)
       : super(context);
-  ElementTypeInformation._withAssignments(
-      MemberTypeInformation context, this._element, assignments)
+  ElementTypeInformation._withAssignments(MemberTypeInformation context,
+      this._element, ParameterAssignments assignments)
       : super.withAssignments(context, assignments);
 
   String getInferredSignature(TypeSystem types);
 
   String get debugName;
 }
 
 /**
  * A node representing members in the broadest sense:
  *
@@ skipping 217 matching lines @@
  * - 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 FunctionElement _declaration;
   final MethodElement _method;
 
-  ParameterTypeInformation._internal(MemberTypeInformation context,
+  ParameterTypeInformation.localFunction(MemberTypeInformation context,
       ParameterElement parameter, this._declaration, this._method)
       : super._internal(context, parameter);
 
-  factory ParameterTypeInformation._static(
-      ParameterElement element, TypeSystem types) {
-    MethodElement method = element.functionDeclaration;
-    assert(!method.isInstanceMember);
-    return new ParameterTypeInformation._internal(
-        types.getInferredTypeOfMember(method), element, method, method);
-  }
+  ParameterTypeInformation.static(
+      MemberTypeInformation context, ParameterElement parameter, this._method)
+      : this._declaration = _method,
+        super._internal(context, parameter);
 
-  factory ParameterTypeInformation._localFunction(
-      ParameterElement element, TypeSystem types) {
-    LocalFunctionElement localFunction = element.functionDeclaration;
-    MethodElement callMethod = localFunction.callMethod;
-    return new ParameterTypeInformation._internal(
-        types.getInferredTypeOfMember(callMethod),
-        element,
-        localFunction,
-        callMethod);
-  }
-
-  ParameterTypeInformation._instanceMember(
-      ParameterElement element, TypeSystem types)
-      : _declaration = element.functionDeclaration,
-        _method = element.functionDeclaration,
-        super._withAssignments(
-            types.getInferredTypeOfMember(
-                element.functionDeclaration as MethodElement),
-            element,
-            new ParameterAssignments()) {
-    assert(element.functionDeclaration.isInstanceMember);
-  }
+  ParameterTypeInformation.instanceMember(
+      MemberTypeInformation context,
+      ParameterElement parameter,
+      this._method,
+      ParameterAssignments assignments)
+      : this._declaration = _method,
+        super._withAssignments(context, parameter, assignments);
 
   MethodElement get method => _method;
 
   Local get parameter => _parameter;
 
   String get debugName => '$parameter';
 
   bool isTearOffClosureParameter = false;
 
   void tagAsTearOffClosureParameter(InferrerEngine inferrer) {
@@ skipping 1179 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);
 }