Remove reference of LocalFunctionElement in ParameterTypeInformation.

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 '../elements/types.dart';
 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 {
@@ skipping 264 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, ResolutionDartType annotation,
+  TypeInformation narrowType(TypeInformation type, DartType annotation,
       {bool isNullable: true}) {
     if (annotation.treatAsDynamic) return type;
     if (annotation.isVoid) return type;
-    if (annotation.element == closedWorld.commonElements.objectClass &&
-        isNullable) {
-      return type;
-    }
     TypeMask otherType;
-    if (annotation.isTypedef || annotation.isFunctionType) {
+    if (annotation.isInterfaceType) {
+      InterfaceType interface = annotation;
+      if (interface.element == closedWorld.commonElements.objectClass) {
+        if (isNullable) {
+          return type;
+        }
+        otherType = dynamicType.type.nonNullable();
+      } else {
+        otherType = new TypeMask.nonNullSubtype(interface.element, closedWorld);
+      }
+    } else if (annotation.isTypedef || annotation.isFunctionType) {
       otherType = functionType.type;
-    } else if (annotation.isTypeVariable) {
+    } else {
+      assert(annotation.isTypeVariable);
       // TODO(ngeoffray): Narrow to bound.
       return type;
-    } else {
-      ResolutionInterfaceType interface = annotation;
-      otherType = annotation.element == closedWorld.commonElements.objectClass
-          ? dynamicType.type.nonNullable()
-          : new TypeMask.nonNullSubtype(interface.element, closedWorld);
     }
     if (isNullable) otherType = otherType.nullable();
     if (type.type.isExact) {
       return type;
     } else {
       assert(TypeMask.assertIsNormalized(otherType, closedWorld));
       TypeInformation newType = new NarrowTypeInformation(type, otherType);
       allocatedTypes.add(newType);
       return newType;
     }
@@ skipping 14 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,
-            localFunction,
-            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(
@@ skipping 243 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();
   }
 }