Mostly use entities in use.dart

pkg/compiler/lib/src/resolution/members.dart

 // Copyright (c) 2012, 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 dart2js.resolution.members;
 
 import '../common.dart';
 import '../common/names.dart' show Selectors;
 import '../common/resolution.dart' show Resolution;
 import '../compile_time_constants.dart';
@@ skipping 1162 matching lines @@
     registry.setSelector(node, selector);
 
     AccessSemantics semantics;
     if (node.isSuperCall) {
       semantics = checkSuperAccess(node);
       if (semantics == null) {
         semantics = computeSuperAccessSemanticsForSelector(node, selector);
         // TODO(johnniwinther): Add information to [AccessSemantics] about
         // whether it is erroneous.
         if (semantics.kind == AccessKind.SUPER_METHOD) {
-          registry.registerStaticUse(new StaticUse.superInvoke(
-              semantics.element.declaration, selector.callStructure));
+          MethodElement superMethod = semantics.element.declaration;
+          registry.registerStaticUse(
+              new StaticUse.superInvoke(superMethod, selector.callStructure));
         }
         // TODO(23998): Remove this when all information goes through
         // the [SendStructure].
         registry.useElement(node, semantics.element);
       }
     } else {
       ResolutionResult expressionResult = visitExpression(expression);
       semantics = const DynamicAccess.expression();
       registry.registerDynamicUse(new DynamicUse(selector, null));
 
@@ skipping 152 matching lines @@
     // [SendStructure].
     registry.setSelector(node, selector);
 
     if (node.isSuperCall) {
       semantics = checkSuperAccess(node);
       if (semantics == null) {
         semantics = computeSuperAccessSemanticsForSelector(node, selector);
         // TODO(johnniwinther): Add information to [AccessSemantics] about
         // whether it is erroneous.
         if (semantics.kind == AccessKind.SUPER_METHOD) {
-          registry.registerStaticUse(new StaticUse.superInvoke(
-              semantics.element.declaration, selector.callStructure));
+          MethodElement superMethod = semantics.element.declaration;
+          registry.registerStaticUse(
+              new StaticUse.superInvoke(superMethod, selector.callStructure));
         }
         // TODO(23998): Remove this when all information goes through
         // the [SendStructure].
         registry.useElement(node, semantics.element);
       }
       visitExpression(right);
     } else {
       ResolutionResult leftResult = visitExpression(left);
       ResolutionResult rightResult = visitExpression(right);
       registry.registerDynamicUse(new DynamicUse(selector, null));
@@ skipping 197 matching lines @@
         case AccessKind.SUPER_METHOD:
           MethodElement superMethod = semantics.element;
           superMethod.computeType(resolution);
           if (!callStructure.signatureApplies(superMethod.type)) {
             registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
             registry.registerDynamicUse(new DynamicUse(selector, null));
             registry.registerFeature(Feature.SUPER_NO_SUCH_METHOD);
             isIncompatibleInvoke = true;
           } else {
             registry.registerStaticUse(
-                new StaticUse.superInvoke(semantics.element, callStructure));
+                new StaticUse.superInvoke(superMethod, callStructure));
           }
           break;
         case AccessKind.SUPER_FIELD:
         case AccessKind.SUPER_FINAL_FIELD:
         case AccessKind.SUPER_GETTER:
-          registry.registerStaticUse(new StaticUse.superGet(semantics.element));
+          MemberElement superMember = semantics.element;
+          registry.registerStaticUse(new StaticUse.superGet(superMember));
           selector = callStructure.callSelector;
           registry.registerDynamicUse(new DynamicUse(selector, null));
           break;
         case AccessKind.SUPER_SETTER:
         case AccessKind.UNRESOLVED_SUPER:
           // NoSuchMethod registered in [computeSuperSemantics].
           break;
         case AccessKind.INVALID:
           // 'super' is not allowed.
           break;
         default:
           reporter.internalError(
               node, "Unexpected super property access $semantics.");
           break;
       }
       registry.registerSendStructure(
           node,
           isIncompatibleInvoke
               ? new IncompatibleInvokeStructure(semantics, selector)
               : new InvokeStructure(semantics, selector));
     } else {
       switch (semantics.kind) {
         case AccessKind.SUPER_METHOD:
           // TODO(johnniwinther): Method this should be registered as a
           // closurization.
-          registry
-              .registerStaticUse(new StaticUse.superTearOff(semantics.element));
+          MethodElement superMethod = semantics.element;
+          registry.registerStaticUse(new StaticUse.superTearOff(superMethod));
           break;
         case AccessKind.SUPER_FIELD:
         case AccessKind.SUPER_FINAL_FIELD:
         case AccessKind.SUPER_GETTER:
-          registry.registerStaticUse(new StaticUse.superGet(semantics.element));
+          MemberElement superMember = semantics.element;
+          registry.registerStaticUse(new StaticUse.superGet(superMember));
           break;
         case AccessKind.SUPER_SETTER:
         case AccessKind.UNRESOLVED_SUPER:
           // NoSuchMethod registered in [computeSuperSemantics].
           break;
         case AccessKind.INVALID:
           // 'super' is not allowed.
           break;
         default:
           reporter.internalError(
@@ skipping 1036 matching lines @@
         case AccessKind.STATIC_METHOD:
         case AccessKind.TOPLEVEL_METHOD:
           MethodElement method = semantics.element;
           method.computeType(resolution);
           if (!callStructure.signatureApplies(method.type)) {
             registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
             registry.registerDynamicUse(new DynamicUse(selector, null));
             isIncompatibleInvoke = true;
           } else {
             registry.registerStaticUse(
-                new StaticUse.staticInvoke(semantics.element, callStructure));
+                new StaticUse.staticInvoke(method, callStructure));
             handleForeignCall(node, semantics.element, callStructure);
             if (method == resolution.commonElements.identicalFunction &&
                 argumentsResult.isValidAsConstant) {
               result = new ConstantResult(
                   node,
                   new IdenticalConstantExpression(
                       argumentsResult.argumentResults[0].constant,
                       argumentsResult.argumentResults[1].constant));
             }
           }
           break;
         case AccessKind.STATIC_FIELD:
         case AccessKind.FINAL_STATIC_FIELD:
         case AccessKind.STATIC_GETTER:
         case AccessKind.TOPLEVEL_FIELD:
         case AccessKind.FINAL_TOPLEVEL_FIELD:
         case AccessKind.TOPLEVEL_GETTER:
-          registry
-              .registerStaticUse(new StaticUse.staticGet(semantics.element));
+          MemberElement member = semantics.element;
+          registry.registerStaticUse(new StaticUse.staticGet(member));
           selector = callStructure.callSelector;
           registry.registerDynamicUse(new DynamicUse(selector, null));
           break;
         case AccessKind.STATIC_SETTER:
         case AccessKind.TOPLEVEL_SETTER:
         case AccessKind.UNRESOLVED:
           registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
           member = reportAndCreateErroneousElement(node.selector, name.text,
               MessageKind.UNDEFINED_STATIC_GETTER_BUT_SETTER, {'name': name});
           break;
         default:
           reporter.internalError(
               node, "Unexpected statically resolved access $semantics.");
           break;
       }
       registry.registerSendStructure(
           node,
           isIncompatibleInvoke
               ? new IncompatibleInvokeStructure(semantics, selector)
               : new InvokeStructure(semantics, selector));
     } else {
       selector = new Selector.getter(name);
       switch (semantics.kind) {
         case AccessKind.STATIC_METHOD:
         case AccessKind.TOPLEVEL_METHOD:
-          registry.registerStaticUse(
-              new StaticUse.staticTearOff(semantics.element));
+          MethodElement method = semantics.element;
+          registry.registerStaticUse(new StaticUse.staticTearOff(method));
           break;
         case AccessKind.STATIC_FIELD:
         case AccessKind.FINAL_STATIC_FIELD:
         case AccessKind.STATIC_GETTER:
         case AccessKind.TOPLEVEL_FIELD:
         case AccessKind.FINAL_TOPLEVEL_FIELD:
         case AccessKind.TOPLEVEL_GETTER:
-          registry
-              .registerStaticUse(new StaticUse.staticGet(semantics.element));
+          MemberElement member = semantics.element;
+          registry.registerStaticUse(new StaticUse.staticGet(member));
           break;
         case AccessKind.STATIC_SETTER:
         case AccessKind.TOPLEVEL_SETTER:
         case AccessKind.UNRESOLVED:
           registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
           member = reportAndCreateErroneousElement(node.selector, name.text,
               MessageKind.UNDEFINED_STATIC_GETTER_BUT_SETTER, {'name': name});
           break;
         default:
           reporter.internalError(
@@ skipping 89 matching lines @@
     } else {
       MemberElement member = element;
       // TODO(johnniwinther): Needed to provoke a parsing and with it discovery
       // of parse errors to make [element] erroneous. Fix this!
       member.computeType(resolution);
       if (member.isMalformed) {
         // [member] has parse errors.
         semantics = new StaticAccess.unresolved(member);
       } else if (member.isFunction) {
         // `a = b`, `a++` or `a += b` where `a` is a function.
+        MethodElement method = member;
         ErroneousElement error = reportAndCreateErroneousElement(
             node.selector, name.text, MessageKind.ASSIGNING_METHOD, const {});
         registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
         if (node.isComplex) {
           // `a++` or `a += b` where `a` is a function.
-          registry.registerStaticUse(new StaticUse.staticTearOff(element));
+          registry.registerStaticUse(new StaticUse.staticTearOff(method));
         }
         semantics = member.isTopLevel
-            ? new StaticAccess.topLevelMethod(member)
-            : new StaticAccess.staticMethod(member);
+            ? new StaticAccess.topLevelMethod(method)
+            : new StaticAccess.staticMethod(method);
       } else {
         // `a = b`, `a++` or `a += b` where `a` is a field.
         assert(invariant(node, member.isField,
             message: "Unexpected element: $member."));
         if (node.isComplex) {
           // `a++` or `a += b` where `a` is a field.
           registry.registerStaticUse(new StaticUse.staticGet(member));
         }
         if (member.isFinal || member.isConst) {
           ErroneousElement error = reportAndCreateErroneousElement(
@@ skipping 305 matching lines @@
       registry.setGetterSelectorInComplexSendSet(node, getterSelector);
       registry.setSelector(node, setterSelector);
       registry.setOperatorSelectorInComplexSendSet(node, operatorSelector);
 
       if (semantics == null) {
         semantics = computeSuperAccessSemanticsForSelectors(
             node, getterSelector, setterSelector,
             isIndex: true);
 
         if (!semantics.getter.isError) {
-          registry.registerStaticUse(new StaticUse.superInvoke(
-              semantics.getter, getterSelector.callStructure));
+          MethodElement getter = semantics.getter;
+          registry.registerStaticUse(
+              new StaticUse.superInvoke(getter, getterSelector.callStructure));
         }
         if (!semantics.setter.isError) {
-          registry.registerStaticUse(new StaticUse.superInvoke(
-              semantics.setter, setterSelector.callStructure));
+          MethodElement setter = semantics.setter;
+          registry.registerStaticUse(
+              new StaticUse.superInvoke(setter, setterSelector.callStructure));
         }
 
         // TODO(23998): Remove these when elements are only accessed
         // through the send structure.
         registry.useElement(node, semantics.setter);
         registry.useElement(node.selector, semantics.getter);
       }
       registry.registerDynamicUse(new DynamicUse(operatorSelector, null));
 
       SendStructure sendStructure = node.isPrefix
@@ skipping 15 matching lines @@
 
           // TODO(23998): Remove these when elements are only accessed
           // through the send structure.
           registry.useElement(node, semantics.setter);
         }
 
         // TODO(23998): Remove this when selectors are only accessed
         // through the send structure.
         registry.setSelector(node, setterSelector);
         if (!semantics.setter.isError) {
-          registry.registerStaticUse(new StaticUse.superInvoke(
-              semantics.setter, setterSelector.callStructure));
+          MethodElement setter = semantics.setter;
+          registry.registerStaticUse(
+              new StaticUse.superInvoke(setter, setterSelector.callStructure));
         }
 
         SendStructure sendStructure = new IndexSetStructure(semantics);
         registry.registerSendStructure(node, sendStructure);
         return const NoneResult();
       } else {
         // `super[a] += b`.
         Selector getterSelector = new Selector.index();
         Selector setterSelector = new Selector.indexSet();
         Selector operatorSelector =
             new Selector.binaryOperator(operator.selectorName);
         if (semantics == null) {
           semantics = computeSuperAccessSemanticsForSelectors(
               node, getterSelector, setterSelector,
               isIndex: true);
 
           if (!semantics.getter.isError) {
+            MethodElement getter = semantics.getter;
             registry.registerStaticUse(new StaticUse.superInvoke(
-                semantics.getter, getterSelector.callStructure));
+                getter, getterSelector.callStructure));
           }
           if (!semantics.setter.isError) {
+            MethodElement setter = semantics.setter;
             registry.registerStaticUse(new StaticUse.superInvoke(
-                semantics.setter, setterSelector.callStructure));
+                setter, setterSelector.callStructure));
           }
 
           // TODO(23998): Remove these when elements are only accessed
           // through the send structure.
           registry.useElement(node, semantics.setter);
           registry.useElement(node.selector, semantics.getter);
         }
 
         // TODO(23998): Remove these when selectors are only accessed
         // through the send structure.
@@ skipping 22 matching lines @@
     Identifier selector = node.selector.asIdentifier();
     String text = selector.source;
     Name name = new Name(text, enclosingElement.library);
     String operatorText = node.assignmentOperator.source;
     Selector getterSelector = new Selector.getter(name);
     Selector setterSelector = new Selector.setter(name);
 
     void registerStaticUses(AccessSemantics semantics) {
       switch (semantics.kind) {
         case AccessKind.SUPER_METHOD:
-          registry
-              .registerStaticUse(new StaticUse.superTearOff(semantics.element));
+          MethodElement method = semantics.element;
+          registry.registerStaticUse(new StaticUse.superTearOff(method));
           break;
         case AccessKind.SUPER_GETTER:
-          registry.registerStaticUse(new StaticUse.superGet(semantics.getter));
+          MethodElement getter = semantics.getter;
+          registry.registerStaticUse(new StaticUse.superGet(getter));
           break;
         case AccessKind.SUPER_SETTER:
-          registry.registerStaticUse(
-              new StaticUse.superSetterSet(semantics.setter));
+          MethodElement setter = semantics.setter;
+          registry.registerStaticUse(new StaticUse.superSetterSet(setter));
           break;
         case AccessKind.SUPER_FIELD:
-          registry.registerStaticUse(new StaticUse.superGet(semantics.element));
-          registry.registerStaticUse(
-              new StaticUse.superFieldSet(semantics.element));
+          FieldElement field = semantics.element;
+          registry.registerStaticUse(new StaticUse.superGet(field));
+          registry.registerStaticUse(new StaticUse.superFieldSet(field));
           break;
         case AccessKind.SUPER_FINAL_FIELD:
-          registry.registerStaticUse(new StaticUse.superGet(semantics.element));
+          FieldElement field = semantics.element;
+          registry.registerStaticUse(new StaticUse.superGet(field));
           break;
         case AccessKind.COMPOUND:
           CompoundAccessSemantics compoundSemantics = semantics;
           switch (compoundSemantics.compoundAccessKind) {
             case CompoundAccessKind.SUPER_GETTER_FIELD:
             case CompoundAccessKind.SUPER_FIELD_FIELD:
-              registry
-                  .registerStaticUse(new StaticUse.superGet(semantics.getter));
-              registry.registerStaticUse(
-                  new StaticUse.superFieldSet(semantics.setter));
+              MemberElement getter = semantics.getter;
+              FieldElement setter = semantics.setter;
+              registry.registerStaticUse(new StaticUse.superGet(getter));
+              registry.registerStaticUse(new StaticUse.superFieldSet(setter));
               break;
             case CompoundAccessKind.SUPER_FIELD_SETTER:
             case CompoundAccessKind.SUPER_GETTER_SETTER:
-              registry
-                  .registerStaticUse(new StaticUse.superGet(semantics.getter));
-              registry.registerStaticUse(
-                  new StaticUse.superSetterSet(semantics.setter));
+              MemberElement getter = semantics.getter;
+              MethodElement setter = semantics.setter;
+              registry.registerStaticUse(new StaticUse.superGet(getter));
+              registry.registerStaticUse(new StaticUse.superSetterSet(setter));
               break;
             case CompoundAccessKind.SUPER_METHOD_SETTER:
-              registry.registerStaticUse(
-                  new StaticUse.superSetterSet(semantics.setter));
+              MethodElement setter = semantics.setter;
+              registry.registerStaticUse(new StaticUse.superSetterSet(setter));
               break;
             case CompoundAccessKind.UNRESOLVED_SUPER_GETTER:
-              registry.registerStaticUse(
-                  new StaticUse.superSetterSet(semantics.setter));
+              MethodElement setter = semantics.setter;
+              registry.registerStaticUse(new StaticUse.superSetterSet(setter));
               break;
             case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
-              registry
-                  .registerStaticUse(new StaticUse.superGet(semantics.getter));
+              MethodElement getter = semantics.getter;
+              registry.registerStaticUse(new StaticUse.superGet(getter));
               break;
             default:
               break;
           }
           break;
         default:
           break;
       }
     }
 
@@ skipping 29 matching lines @@
               reporter.reportWarningMessage(
                   node, MessageKind.ASSIGNING_METHOD_IN_SUPER, {
                 'name': name,
                 'superclassName': semantics.setter.enclosingClass.name
               });
               // TODO(johnniwinther): This shouldn't be needed.
               registry.registerDynamicUse(new DynamicUse(setterSelector, null));
               registry.registerFeature(Feature.SUPER_NO_SUCH_METHOD);
               break;
             case AccessKind.SUPER_FIELD:
-              registry.registerStaticUse(
-                  new StaticUse.superFieldSet(semantics.setter));
+              FieldElement field = semantics.setter;
+              registry.registerStaticUse(new StaticUse.superFieldSet(field));
               break;
             case AccessKind.SUPER_SETTER:
-              registry.registerStaticUse(
-                  new StaticUse.superSetterSet(semantics.setter));
+              MethodElement setter = semantics.setter;
+              registry.registerStaticUse(new StaticUse.superSetterSet(setter));
               break;
             default:
               break;
           }
         }
         return handleUpdate(node, name, semantics);
       } else {
         // `super.a += b`.
         if (semantics == null) {
           semantics = computeSuperAccessSemanticsForSelectors(
@@ skipping 505 matching lines @@
                     type),
                 selector));
         return new ResolutionResult.forElement(constructor);
     }
 
     if (!isInvalid) {
       // [constructor] might be the implementation element
       // and only declaration elements may be registered.
       // TODO(johniwinther): Avoid registration of `type` in face of redirecting
       // factory constructors.
+      ConstructorElement declaration = constructor.declaration;
       registry.registerStaticUse(node.isConst
           ? new StaticUse.constConstructorInvoke(
-              constructor.declaration, callStructure, type)
+              declaration, callStructure, type)
           : new StaticUse.typedConstructorInvoke(
-              constructor.declaration, callStructure, type));
+              constructor, callStructure, type));
       ResolutionInterfaceType interfaceType = type;
       if (interfaceType.typeArguments
           .any((ResolutionDartType type) => !type.isDynamic)) {
         registry.registerFeature(Feature.TYPE_VARIABLE_BOUNDS_CHECK);
       }
     }
 
     ResolutionResult resolutionResult = const NoneResult();
     if (node.isConst) {
       bool isValidAsConstant = !isInvalid && constructor.isConst;
@@ skipping 424 matching lines @@
         loopVariable = registry.getDefinition(identifier);
       }
     } else {
       reporter.reportErrorMessage(declaration, MessageKind.INVALID_FOR_IN);
     }
     if (loopVariableSelector != null) {
       registry.setSelector(declaration, loopVariableSelector);
       if (loopVariable == null || loopVariable.isInstanceMember) {
         registry.registerDynamicUse(new DynamicUse(loopVariableSelector, null));
       } else if (loopVariable.isStatic || loopVariable.isTopLevel) {
-        registry.registerStaticUse(
-            new StaticUse.staticSet(loopVariable.declaration));
+        MemberElement member = loopVariable.declaration;
+        registry.registerStaticUse(new StaticUse.staticSet(member));
       }
     } else {
       // The selector may only be null if we reported an error.
       assert(invariant(declaration, reporter.hasReportedError));
     }
     if (loopVariable != null) {
       // loopVariable may be null if it could not be resolved.
       registry.setForInVariable(node, loopVariable);
     }
   }
@@ skipping 397 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(
     DiagnosticReporter reporter, Node node, Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }