Begin refactoring of visitSendSet for unqualified updates.

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.
 
 part of resolution;
 
 /// The state of constants in resolutions.
 enum ConstantState {
   /// Expressions are not required to be constants.
   NON_CONSTANT,
@@ skipping 1871 matching lines @@
 
     // TODO(karlklose): this should be reported by the caller of
     // [resolveSend] to select better warning messages for getters and
     // setters.
     ErroneousElement error = reportAndCreateErroneousElement(
         node, name.text, MessageKind.MEMBER_NOT_FOUND,
         {'className': receiverClass.name, 'memberName': name.text});
     // TODO(johnniwinther): Add an [AccessSemantics] for unresolved static
     // member access.
     return handleErroneousAccess(
-        node, name, error, new StaticAccess.unresolved(error));
+        node, name, new StaticAccess.unresolved(error));
   }
 
   /// Handle qualified access of an instance member, like `a.b` or `a.b()` where
   /// `a` is a class and `b` is a non-static member.
   ResolutionResult handleStaticInstanceMemberAccess(
       Send node, Name name, ClassElement receiverClass, Element member) {
 
     registry.registerThrowNoSuchMethod();
     // TODO(johnniwinther): With the simplified [TreeElements] invariant,
     // try to resolve injected elements if [currentClass] is in the patch
     // library of [receiverClass].
 
     // TODO(karlklose): this should be reported by the caller of
     // [resolveSend] to select better warning messages for getters and
     // setters.
     ErroneousElement error = reportAndCreateErroneousElement(
         node, name.text, MessageKind.MEMBER_NOT_STATIC,
         {'className': receiverClass.name, 'memberName': name});
 
     // TODO(johnniwinther): Add an [AccessSemantics] for statically accessed
     // instance members.
     return handleErroneousAccess(
-        node, name, error, new StaticAccess.unresolved(error));
+        node, name, new StaticAccess.unresolved(error));
   }
 
   /// Handle qualified access of an inaccessible private static class member,
   /// like `a._b` or `a.b()` where `a` is class, `_b` is static member of `a`
   /// but `a` is not defined in the current library.
   ResolutionResult handlePrivateStaticMemberAccess(
       Send node, Name name, ClassElement receiverClass, Element member) {
     registry.registerThrowNoSuchMethod();
     ErroneousElement error = reportAndCreateErroneousElement(
         node, name.text, MessageKind.PRIVATE_ACCESS,
         {'libraryName': member.library.getLibraryOrScriptName(),
          'name': name});
     // TODO(johnniwinther): Add an [AccessSemantics] for unresolved static
     // member access.
     return handleErroneousAccess(
-        node, name, error, new StaticAccess.unresolved(error));
+        node, name, new StaticAccess.unresolved(error));
   }
 
   /// Handle qualified access to a static member, like `a.b` or `a.b()` where
   /// `a` is a class and `b` is a static member of `a`.
   ResolutionResult handleStaticMemberAccess(
       Send node, Name memberName, ClassElement receiverClass) {
     String name = memberName.text;
     receiverClass.ensureResolved(compiler);
     if (node.isOperator) {
       // When the resolved receiver is a class, we can have two cases:
@@ skipping 219 matching lines @@
       Name name,
       PrefixElement prefix) {
     if ((ElementCategory.PREFIX & allowedCategory) == 0) {
       ErroneousElement error = reportAndCreateErroneousElement(
           node,
           name.text,
           MessageKind.PREFIX_AS_EXPRESSION,
           {'prefix': name},
           isError: true);
       return handleErroneousAccess(
-          node, name, error, new StaticAccess.invalid(error));
+          node, name, new StaticAccess.invalid(error));
     }
     if (prefix.isDeferred) {
       // TODO(23998): Remove this when deferred access is detected
       // through a [SendStructure].
       registry.useElement(node.selector, prefix);
     }
     registry.useElement(node, prefix);
     return new PrefixResult(prefix, null);
   }
 
@@ skipping 59 matching lines @@
   }
 
   /// Handle `this` as a qualified property, like `a.this`.
   ResolutionResult handleQualifiedThisAccess(Send node, Name name) {
     ErroneousElement error = reportAndCreateErroneousElement(
         node.selector,
         name.text,
         MessageKind.THIS_PROPERTY, {},
         isError: true);
     AccessSemantics accessSemantics = new StaticAccess.invalid(error);
-    return handleErroneousAccess(node, name, error, accessSemantics);
+    return handleErroneousAccess(node, name, accessSemantics);
   }
 
   /// Handle a qualified [Send], that is where the receiver is non-null, like
   /// `a.b`, `a.b()`, `this.a()` and `super.a()`.
   ResolutionResult handleQualifiedSend(Send node) {
     Identifier selector = node.selector.asIdentifier();
     String text = selector.source;
     Name name = new Name(text, enclosingElement.library);
     if (text == 'this') {
       return handleQualifiedThisAccess(node, name);
@@ skipping 16 matching lines @@
       // TODO(johnniwinther): Use the `element` of [result].
       return handleDynamicPropertyAccess(node, name);
     }
   }
 
   /// Handle access unresolved access to [name] in a non-instance context.
   ResolutionResult handleUnresolvedAccess(
         Send node, Name name, Element element) {
     // TODO(johnniwinther): Support unresolved top level access as an
     // [AccessSemantics].
-    AccessSemantics accessSemantics = new StaticAccess.unresolved(element);
-    return handleErroneousAccess(node, name, element, accessSemantics);
+    AccessSemantics semantics = new StaticAccess.unresolved(element);
+    return handleErroneousAccess(node, name, semantics);
   }
 
-  /// Handle erroneous access of [element] of the given [accessSemantics].
+  /// Handle erroneous access of [element] of the given [semantics].
   ResolutionResult handleErroneousAccess(
-      Send node, Name name, Element element, AccessSemantics accessSemantics) {
+      Send node, Name name, AccessSemantics semantics) {
     SendStructure sendStructure;
     Selector selector;
     if (node.isCall) {
       CallStructure callStructure =
           resolveArguments(node.argumentsNode).callStructure;
       selector = new Selector(SelectorKind.CALL, name, callStructure);
       registry.registerDynamicInvocation(
           new UniverseSelector(selector, null));
-      sendStructure = new InvokeStructure(accessSemantics, selector);
+      sendStructure = new InvokeStructure(semantics, selector);
     } else {
       assert(invariant(node, node.isPropertyAccess));
       selector = new Selector(
           SelectorKind.GETTER, name, CallStructure.NO_ARGS);
       registry.registerDynamicGetter(
           new UniverseSelector(selector, null));
-      sendStructure = new GetStructure(accessSemantics, selector);
+      sendStructure = new GetStructure(semantics, selector);
     }
     // TODO(23998): Remove this when all information goes through
     // the [SendStructure].
     registry.setSelector(node, selector);
-    registry.useElement(node, element);
+    registry.useElement(node, semantics.element);
     registry.registerSendStructure(node, sendStructure);
     return const NoneResult();
   }
 
   /// Handle access to an ambiguous element, that is, a name imported twice.
   ResolutionResult handleAmbiguousSend(
       Send node,
       Name name,
       AmbiguousElement element) {
 
     ErroneousElement error = reportAndCreateErroneousElement(
         node,
         name.text,
         element.messageKind,
         element.messageArguments);
     element.diagnose(enclosingElement, compiler);
     registry.registerThrowNoSuchMethod();
 
     // TODO(johnniwinther): Support ambiguous access as an [AccessSemantics].
+    AccessSemantics semantics = new StaticAccess.unresolved(error);
+    return handleErroneousAccess(node, name, semantics);
+  }
+
+  /// Handle update to an ambiguous element, that is, a name imported twice.
+  ResolutionResult handleAmbiguousUpdate(
+      SendSet node,
+      Name name,
+      AmbiguousElement element) {
+
+    ErroneousElement error = reportAndCreateErroneousElement(
+        node,
+        name.text,
+        element.messageKind,
+        element.messageArguments);
+    element.diagnose(enclosingElement, compiler);
+    registry.registerThrowNoSuchMethod();
+
+    // TODO(johnniwinther): Support ambiguous access as an [AccessSemantics].
     AccessSemantics accessSemantics = new StaticAccess.unresolved(error);
-    return handleErroneousAccess(node, name, error, accessSemantics);
+    return handleUpdate(node, name, accessSemantics);
   }
 
   /// Handle access of an instance [member] from a non-instance context.
   ResolutionResult handleStaticInstanceSend(
       Send node, Name name, MemberElement member) {
     compiler.reportError(
         node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': member.name});
     ErroneousElement error = new ErroneousElementX(
         MessageKind.NO_INSTANCE_AVAILABLE,
         {'name': name},
         name.text,
         enclosingElement);
 
     // TODO(johnniwinther): Support static instance access as an
     // [AccessSemantics].
-    AccessSemantics accessSemantics = new StaticAccess.unresolved(error);
-    return handleErroneousAccess(node, name, error, accessSemantics);
+    AccessSemantics semantics = new StaticAccess.unresolved(error);
+    return handleErroneousAccess(node, name, semantics);
   }
 
   /// Handle access of a parameter, local variable or local function.
   ResolutionResult handleLocalAccess(Send node, Name name, Element element) {
     ResolutionResult result = const NoneResult();
     AccessSemantics semantics = computeLocalAccessSemantics(node, element);
     Selector selector;
     if (node.isCall) {
       CallStructure callStructure =
           resolveArguments(node.argumentsNode).callStructure;
@@ skipping 226 matching lines @@
   ResolutionResult handleResolvedSend(Send node, Name name, Element element) {
     if (element.isAmbiguous) {
       return handleAmbiguousSend(node, name, element);
     }
     if (element.isErroneous) {
       // This handles elements with parser errors.
       // TODO(johnniwinther): Elements with parse error should not set
       // [isErroneous] to `true`.
       assert(invariant(node, element is! ErroneousElement,
           message: "Unexpected erroneous element $element."));
-      return handleErroneousAccess(node, name, element,
+      return handleErroneousAccess(node, name,
           new StaticAccess.unresolved(element));
     }
     if (element.isInstanceMember) {
       if (inInstanceContext) {
         // TODO(johnniwinther): Maybe use the found [element].
         return handleThisPropertyAccess(node, name);
       } else {
         return handleStaticInstanceSend(node, name, element);
       }
     }
     if (element.isClass) {
       // `C`, `C()`, or 'C.b` where 'C' is a class.
       return handleClassSend(node, name, element);
     } else if (element.isTypedef) {
       // `F` or `F()` where 'F' is a typedef.
       return handleTypedefTypeLiteralAccess(node, name, element);
     } else if (element.isTypeVariable) {
       return handleTypeVariableTypeLiteralAccess(node, name, element);
     } else if (element.isPrefix) {
       return handleLibraryPrefix(node, name, element);
     } else if (element.isLocal) {
       return handleLocalAccess(node, name, element);
     } else if (element.isStatic || element.isTopLevel) {
       return handleStaticOrTopLevelAccess(node, name, element);
     }
     return internalError(node, "Unexpected resolved send: $element");
   }
 
+  /// Handle update to resolved [element].
+  ResolutionResult handleResolvedSendSet(
+      SendSet node, Name name, Element element) {
+    if (element.isAmbiguous) {
+      return handleAmbiguousUpdate(node, name, element);
+    }
+    if (element.isErroneous) {
+      // This handles elements with parser errors.
+      // TODO(johnniwinther): Elements with parse error should not set
+      // [isErroneous] to `true`.
+      assert(invariant(node, element is! ErroneousElement,
+          message: "Unexpected erroneous element $element."));
+      return handleUpdate(node, name,new StaticAccess.unresolved(element));
+    }
+    return oldVisitSendSet(node);
+  }
+
   /// Handle an unqualified [Send], that is where the `node.receiver` is null,
   /// like `a`, `a()`, `this()`, `assert()`, and `(){}()`.
   ResolutionResult handleUnqualifiedSend(Send node) {
     Identifier selector = node.selector.asIdentifier();
     if (selector == null) {
       // `(){}()` and `(foo)()`.
       return handleExpressionInvoke(node);
     }
     String text = selector.source;
     if (text == 'assert') {
@@ skipping 17 matching lines @@
       } else {
         // Create [ErroneousElement] for unresolved access.
         ErroneousElement error = reportCannotResolve(node, text);
         return handleUnresolvedAccess(node, name, error);
       }
     } else {
       return handleResolvedSend(node, name, element);
     }
   }
 
+  /// Handle an unqualified [SendSet], that is where the `node.receiver` is
+  /// null, like `a = b`, `a++`, and `a += b`.
+  ResolutionResult handleUnqualifiedSendSet(SendSet node) {
+    Identifier selector = node.selector.asIdentifier();
+    String text = selector.source;
+    Name name = new Name(text, enclosingElement.library);
+    Element element = lookupInScope(compiler, node, scope, text);
+    if (element == null) {
+      return oldVisitSendSet(node);
+    } else {
+      return handleResolvedSendSet(node, name, element);
+    }
+  }
+
   ResolutionResult visitSend(Send node) {
     if (node.isOperator) {
       // `a && b`, `a + b`, `-a`, or `a is T`.
       return handleOperatorSend(node);
     } else if (node.receiver != null) {
       // `a.b`.
       return handleQualifiedSend(node);
     } else {
       // `a`.
       return handleUnqualifiedSend(node);
@@ skipping 234 matching lines @@
   }
 
   /// Handle super index operations like `super.a = b`, `super.a += b`, and
   /// `super.a++`.
   // TODO(johnniwinther): Share code with [handleSuperIndexSendSet].
   ResolutionResult handleSuperSendSet(SendSet node) {
     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(
+        SelectorKind.GETTER, name, CallStructure.NO_ARGS);
+    Selector setterSelector = new Selector(
+        SelectorKind.SETTER, name.setter, CallStructure.ONE_ARG);
     AccessSemantics semantics = checkSuperAccess(node);
     if (node.isPrefix || node.isPostfix) {
       // `super.a++` or `++super.a`.
-      IncDecOperator operator = IncDecOperator.parse(operatorText);
-      Selector getterSelector =
-          new Selector(SelectorKind.GETTER, name, CallStructure.NO_ARGS);
-      Selector setterSelector =
-          new Selector(SelectorKind.SETTER, name.setter, CallStructure.ONE_ARG);
-      Selector operatorSelector =
-          new Selector.binaryOperator(operator.selectorName);
-
-      // TODO(23998): Remove these when selectors are only accessed
-      // through the send structure.
-      registry.setGetterSelectorInComplexSendSet(node, getterSelector);
-      registry.setSelector(node, setterSelector);
-      registry.setOperatorSelectorInComplexSendSet(node, operatorSelector);
-
       if (semantics == null) {
         semantics = computeSuperAccessSemanticsForSelectors(
             node, getterSelector, setterSelector);
-
-        registry.registerStaticInvocation(semantics.getter);
-        registry.registerStaticInvocation(semantics.setter);
-
-        // 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.registerDynamicInvocation(
-          new UniverseSelector(operatorSelector, null));
-
-      SendStructure sendStructure = node.isPrefix
-          ? new PrefixStructure(
-              semantics, operator, getterSelector, setterSelector)
-          : new PostfixStructure(
-              semantics, operator, getterSelector, setterSelector);
-      registry.registerSendStructure(node, sendStructure);
-      return const NoneResult();
+      return handleUpdate(node, name, semantics);
     } else {
-      Node rhs = node.arguments.head;
-      visitExpression(rhs);
-
       AssignmentOperator operator = AssignmentOperator.parse(operatorText);
       if (operator.kind == AssignmentOperatorKind.ASSIGN) {
         // `super.a = b`.
-        Selector setterSelector = new Selector(
-            SelectorKind.SETTER, name.setter, CallStructure.ONE_ARG);
         if (semantics == null) {
           semantics =
               computeSuperAccessSemanticsForSelector(
                   node, setterSelector, alternateName: name);
           switch (semantics.kind) {
             case AccessKind.SUPER_FINAL_FIELD:
               compiler.reportWarning(
                   node,
                   MessageKind.ASSIGNING_FINAL_FIELD_IN_SUPER,
                   {'name': name,
                    'superclassName': semantics.setter.enclosingClass.name});
               registry.registerDynamicInvocation(
                   new UniverseSelector(setterSelector, null));
               registry.registerSuperNoSuchMethod();
               break;
             case AccessKind.SUPER_METHOD:
               compiler.reportWarning(
                   node, MessageKind.ASSIGNING_METHOD_IN_SUPER,
                   {'name': name,
                    'superclassName': semantics.setter.enclosingClass.name});
               registry.registerDynamicInvocation(
                   new UniverseSelector(setterSelector, null));
               registry.registerSuperNoSuchMethod();
               break;
             default:
               registry.registerStaticInvocation(semantics.setter);
               break;
           }
+        }
+        return handleUpdate(node, name, semantics);
+      } else {
+        // `super.a += b`.
+        if (semantics == null) {
+          semantics = computeSuperAccessSemanticsForSelectors(
+              node, getterSelector, setterSelector);
+        }
+        return handleUpdate(node, name, semantics);
+      }
+    }
+  }
 
-          // TODO(23998): Remove these when elements are only accessed
-          // through the send structure.
-          registry.useElement(node, semantics.setter);
+  /// Handle update of an entity defined by [semantics]. For instance `a = b`,
+  /// `a++` or `a += b` where [semantics] describe `a`.
+  ResolutionResult handleUpdate(
+      SendSet node,
+      Name name,
+      AccessSemantics semantics) {
+    SendStructure sendStructure;
+    String operatorText = node.assignmentOperator.source;
+    Selector getterSelector =
+        new Selector(SelectorKind.GETTER, name, CallStructure.NO_ARGS);
+    Selector setterSelector =
+        new Selector(SelectorKind.SETTER, name.setter, CallStructure.ONE_ARG);
+    if (node.isPrefix || node.isPostfix) {
+      // `e++` or `++e`.
+      IncDecOperator operator = IncDecOperator.parse(operatorText);
+      Selector operatorSelector =
+          new Selector.binaryOperator(operator.selectorName);
+
+      // TODO(23998): Remove these when selectors are only accessed
+      // through the send structure.
+      registry.setGetterSelectorInComplexSendSet(node, getterSelector);
+      registry.setSelector(node, setterSelector);
+      registry.setOperatorSelectorInComplexSendSet(node, operatorSelector);
+
+      if (semantics.isAccessedStatically) {
+        registry.registerStaticInvocation(semantics.getter);
+        registry.registerStaticInvocation(semantics.setter);
+      }
+      // 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.registerDynamicInvocation(
+          new UniverseSelector(operatorSelector, null));
+
+      SendStructure sendStructure = node.isPrefix
+          ? new PrefixStructure(
+              semantics, operator, getterSelector, setterSelector)
+          : new PostfixStructure(
+              semantics, operator, getterSelector, setterSelector);
+      registry.registerSendStructure(node, sendStructure);
+      return const NoneResult();
+    } else {
+      Node rhs = node.arguments.head;
+      visitExpression(rhs);
+
+      AssignmentOperator operator = AssignmentOperator.parse(operatorText);
+      if (operator.kind == AssignmentOperatorKind.ASSIGN) {
+        // `e1 = e2`.
+        if (semantics.isAccessedStatically) {
+          registry.registerStaticInvocation(semantics.setter);
         }
 
+        // 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);
 
         SendStructure sendStructure =
             new SetStructure(semantics, setterSelector);
         registry.registerSendStructure(node, sendStructure);
         return const NoneResult();
       } else {
-        // `super.a += b`.
-        Selector getterSelector = new Selector(
-            SelectorKind.GETTER, name, CallStructure.NO_ARGS);
-        Selector setterSelector = new Selector(
-            SelectorKind.SETTER, name.setter, CallStructure.ONE_ARG);
+        // `e1 += e2`.
         Selector operatorSelector =
             new Selector.binaryOperator(operator.selectorName);
-        if (semantics == null) {
-          semantics = computeSuperAccessSemanticsForSelectors(
-              node, getterSelector, setterSelector);
-
+        if (semantics.isAccessedStatically) {
           registry.registerStaticInvocation(semantics.getter);
           registry.registerStaticInvocation(semantics.setter);
+        }
 
-          // 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 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.
         registry.setGetterSelectorInComplexSendSet(node, getterSelector);
         registry.setSelector(node, setterSelector);
         registry.setOperatorSelectorInComplexSendSet(node, operatorSelector);
 
         registry.registerDynamicInvocation(
             new UniverseSelector(operatorSelector, null));
 
         SendStructure sendStructure = new CompoundStructure(
                 semantics, operator, getterSelector, setterSelector);
         registry.registerSendStructure(node, sendStructure);
         return const NoneResult();
       }
     }
   }
 
   ResolutionResult visitSendSet(SendSet node) {
     if (node.isIndex) {
       if (node.isSuperCall) {
         return handleSuperIndexSendSet(node);
       } else {
         return handleIndexSendSet(node);
       }
     } else if (node.isSuperCall) {
       return handleSuperSendSet(node);
+    } else if (node.receiver == null) {
+      return handleUnqualifiedSendSet(node);
     }
     return oldVisitSendSet(node);
   }
 
   ResolutionResult oldVisitSendSet(SendSet node) {
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = node.isPropertyAccess || node.isCall;
     ResolutionResult result = resolveSend(node);
     sendIsMemberAccess = oldSendIsMemberAccess;
     Element target = result.element;
@@ skipping 1276 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }