Split MemberTypeInformation by member kind

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/types.dart';
 import '../tree/nodes.dart' as ast;
 import '../types/masks.dart';
@@ skipping 272 matching lines @@
     TypeInformation newType = new NarrowTypeInformation(receiver, otherType);
     allocatedTypes.add(newType);
     return newType;
   }
 
   /**
    * Returns the intersection between [type] and [annotation].
    * [isNullable] indicates whether the annotation implies a null
    * type.
    */
-  TypeInformation narrowType(
-      TypeInformation type, DartType annotation,
+  TypeInformation narrowType(TypeInformation type, DartType annotation,
       {bool isNullable: true}) {
     if (annotation.treatAsDynamic) return type;
     if (annotation.isVoid) return type;
     TypeMask otherType;
     if (annotation.isInterfaceType) {
       InterfaceType interface = annotation;
       if (interface.element == closedWorld.commonElements.objectClass) {
         if (isNullable) {
           return type;
         }
@@ skipping 34 matching lines @@
 
   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,
-            callMethod);
+            getInferredTypeOfMember(callMethod), parameter, 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;
     });
   }
 
   MemberTypeInformation getInferredTypeOfMember(MemberElement member) {
     member = member.implementation;
     return memberTypeInformations.putIfAbsent(member, () {
-      MemberTypeInformation typeInformation = new MemberTypeInformation(member);
+      MemberTypeInformation typeInformation;
+      if (member.isField) {
+        typeInformation = new FieldTypeInformation(member);
+      } else if (member.isGetter) {
+        typeInformation = new GetterTypeInformation(member);
+      } else if (member.isSetter) {
+        typeInformation = new SetterTypeInformation(member);
+      } else if (member.isFunction) {
+        typeInformation = new MethodTypeInformation(member);
+      } else {
+        ConstructorElement constructor = member;
+        if (constructor.isFactoryConstructor) {
+          typeInformation = new FactoryConstructorTypeInformation(member);
+        } else {
+          typeInformation = new GenerativeConstructorTypeInformation(member);
+        }
+      }
       _orderedTypeInformations.add(typeInformation);
       return typeInformation;
     });
   }
 
   /**
    * Returns the internal inferrer representation for [mask].
    */
   ConcreteTypeInformation getConcreteTypeFor(TypeMask mask) {
     assert(mask != null);
@@ skipping 218 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();
   }
 }