Use entities in the InferrerEngine interface

pkg/compiler/lib/src/inferrer/builder.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 simple_types_inferrer;
 
 import '../closure.dart' show ClosureRepresentationInfo;
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../compiler.dart' show Compiler;
@@ skipping 953 matching lines @@
       inferrer.setDefaultTypeOfParameter(parameter, type);
     });
 
     if (closedWorld.nativeData.isNativeMember(analyzedElement)) {
       // Native methods do not have a body, and we currently just say
       // they return dynamic.
       return types.dynamicType;
     }
 
     if (analyzedElement.isGenerativeConstructor) {
+      ConstructorElement analyzedConstructor = analyzedElement;
       isThisExposed = false;
       signature.forEachParameter((FormalElement _element) {
         ParameterElement element = _element;
         TypeInformation parameterType = inferrer.typeOfParameter(element);
         if (element.isInitializingFormal) {
           InitializingFormalElement initializingFormal = element;
           if (initializingFormal.fieldElement.isFinal) {
             inferrer.recordTypeOfField(
                 initializingFormal.fieldElement, parameterType);
           } else {
             locals.updateField(initializingFormal.fieldElement, parameterType);
             inferrer.recordTypeOfField(
                 initializingFormal.fieldElement, parameterType);
           }
         }
         locals.update(element, parameterType, node);
       });
-      ClassElement cls = analyzedElement.enclosingClass;
+      ClassElement cls = analyzedConstructor.enclosingClass;
       Spannable spannable = node;
-      if (analyzedElement.isSynthesized) {
-        spannable = analyzedElement;
-        ConstructorElement constructor = analyzedElement;
-        synthesizeForwardingCall(spannable, constructor.definingConstructor);
+      if (analyzedConstructor.isSynthesized) {
+        spannable = analyzedConstructor;
+        synthesizeForwardingCall(
+            spannable, analyzedConstructor.definingConstructor);
       } else {
         visitingInitializers = true;
         if (node.initializers != null) {
           for (ast.Node initializer in node.initializers) {
             ast.SendSet fieldInitializer = initializer.asSendSet();
             if (fieldInitializer != null) {
               handleSendSet(fieldInitializer);
             } else {
               Element element = elements[initializer];
               handleConstructorSend(initializer, element);
             }
           }
         }
         visitingInitializers = false;
         // For a generative constructor like: `Foo();`, we synthesize
         // a call to the default super constructor (the one that takes
         // no argument). Resolution ensures that such a constructor
         // exists.
         if (!isConstructorRedirect &&
             !seenSuperConstructorCall &&
             !cls.isObject) {
           ConstructorElement target = cls.superclass.lookupDefaultConstructor();
           ArgumentsTypes arguments = new ArgumentsTypes([], {});
           analyzeSuperConstructorCall(target, arguments);
           inferrer.registerCalledMember(node, null, null, outermostElement,
-              target.implementation, arguments, sideEffects, inLoop);
+              target, arguments, sideEffects, inLoop);
         }
         visit(node.body);
-        inferrer.recordExposesThis(analyzedElement, isThisExposed);
+        inferrer.recordExposesThis(analyzedConstructor, isThisExposed);
       }
       if (!isConstructorRedirect) {
         // Iterate over all instance fields, and give a null type to
         // fields that we haven'TypeInformation initialized for sure.
         cls.forEachInstanceField((_, FieldElement field) {
           if (field.isFinal) return;
           TypeInformation type = locals.fieldScope.readField(field);
           ResolvedAst resolvedAst = field.resolvedAst;
           if (type == null && resolvedAst.body == null) {
             inferrer.recordTypeOfField(field, types.nullType);
@@ skipping 163 matching lines @@
   bool isThisOrSuper(ast.Node node) => node.isThis() || node.isSuper();
 
   bool isInClassOrSubclass(Element element) {
     ClassElement cls = outermostElement.enclosingClass;
     ClassElement enclosing = element.enclosingClass;
     return closedWorld.isSubclassOf(enclosing, cls);
   }
 
   void checkIfExposesThis(Selector selector, TypeMask mask) {
     if (isThisExposed) return;
-    inferrer.forEachElementMatching(selector, mask, (dynamic element) {
+    inferrer.forEachElementMatching(selector, mask, (MemberEntity element) {
       if (element.isField) {
-        ResolvedAst elementResolvedAst = element.resolvedAst;
+        FieldElement field = element;
+        ResolvedAst elementResolvedAst = field.resolvedAst;
         if (!selector.isSetter &&
-            isInClassOrSubclass(element) &&
-            !element.isFinal &&
-            locals.fieldScope.readField(element) == null &&
+            isInClassOrSubclass(field) &&
+            !field.isFinal &&
+            locals.fieldScope.readField(field) == null &&
             elementResolvedAst.body == null) {
           // If the field is being used before this constructor
           // actually had a chance to initialize it, say it can be
           // null.
-          inferrer.recordTypeOfField(element, types.nullType);
+          inferrer.recordTypeOfField(field, types.nullType);
         }
         // Accessing a field does not expose [:this:].
         return true;
       }
       // TODO(ngeoffray): We could do better here if we knew what we
       // are calling does not expose this.
       isThisExposed = true;
       return false;
     });
   }
@@ skipping 763 matching lines @@
         if (targets.length == 1) {
           MemberElement single = targets.first;
           if (single.isField) {
             locals.updateField(single, rhsType);
           }
         }
       }
       handleDynamicSend(
           node, setterSelector, setterMask, receiverType, arguments);
     } else if (element.isField) {
-      if (element.isFinal) {
-        inferrer.recordTypeOfField(element, rhsType);
+      FieldElement field = element;
+      if (field.isFinal) {
+        inferrer.recordTypeOfField(field, rhsType);
       } else {
         if (analyzedElement.isGenerativeConstructor) {
-          locals.updateField(element, rhsType);
+          locals.updateField(field, rhsType);
         }
         if (visitingInitializers) {
-          inferrer.recordTypeOfField(element, rhsType);
+          inferrer.recordTypeOfField(field, rhsType);
         } else {
           handleDynamicSend(
               node, setterSelector, setterMask, receiverType, arguments);
         }
       }
     } else if (element.isLocal) {
       locals.update(element, rhsType, node);
     }
     return rhsType;
   }
@@ skipping 330 matching lines @@
           ? types.nullType
           : arguments.positional[1];
 
       return inferrer.concreteTypes.putIfAbsent(
           node,
           () => types.allocateList(types.fixedListType, node, outermostElement,
               elementType, length));
     } else if (Elements.isConstructorOfTypedArraySubclass(
         constructor, closedWorld)) {
       int length = findLength(node);
-      TypeInformation elementType =
-          inferrer.returnTypeOfMember(target.enclosingClass.lookupMember('[]'));
+      MemberElement member = target.enclosingClass.lookupMember('[]');
+      TypeInformation elementType = inferrer.returnTypeOfMember(member);
       return inferrer.concreteTypes.putIfAbsent(
           node,
           () => types.allocateList(types.nonNullExact(target.enclosingClass),
               node, outermostElement, elementType, length));
     } else {
       return returnType;
     }
   }
 
   @override
@@ skipping 435 matching lines @@
         return types.boolType;
       } else if (types.isNull(arguments.positional[0])) {
         potentiallyAddNullCheck(node, node.receiver);
         return types.boolType;
       }
     }
     return handleDynamicSend(node, selector, mask, receiverType, arguments);
   }
 
   void recordReturnType(TypeInformation type) {
+    MethodElement analyzedMethod = analyzedElement;
     returnType =
-        inferrer.addReturnTypeForMethod(analyzedElement, returnType, type);
+        inferrer.addReturnTypeForMethod(analyzedMethod, returnType, type);
   }
 
   TypeInformation synthesizeForwardingCall(
       Spannable node, ConstructorElement element) {
     assert(element.isDeclaration);
     MethodElement function = analyzedElement.implementation;
     FunctionSignature signature = function.functionSignature;
     FunctionSignature calleeSignature = element.functionSignature;
     if (!calleeSignature.isCompatibleWith(signature)) {
       return types.nonNullEmpty();
@@ skipping 116 matching lines @@
     Selector moveNextSelector = Selectors.moveNext;
     TypeMask moveNextMask = memberData.typeOfIteratorMoveNext(node);
 
     TypeInformation iteratorType = handleDynamicSend(node, iteratorSelector,
         iteratorMask, expressionType, new ArgumentsTypes.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }