Refactor visitSendSet for super compounds and assignment.

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 923 matching lines @@
           message: "Unexpected super target '$target'."));
       return new StaticAccess.superMethod(target);
     }
   }
 
   /// Compute the [AccessSemantics] corresponding to a compound super access
   /// reading from [getter] and writing to [setter].
   AccessSemantics computeCompoundSuperAccessSemantics(
       Spannable node,
       Element getter,
-      Element setter) {
+      Element setter,
+      {bool isIndex: false}) {
     if (getter.isErroneous) {
       if (setter.isErroneous) {
         return new StaticAccess.unresolvedSuper(getter);
       } else if (setter.isFunction) {
         assert(invariant(node, setter.name == '[]=',
             message: "Unexpected super setter '$setter'."));
         return new CompoundAccessSemantics(
                     CompoundAccessKind.UNRESOLVED_SUPER_GETTER, getter, setter);
       } else {
         assert(invariant(node, setter.isSetter,
             message: "Unexpected super setter '$setter'."));
         return new CompoundAccessSemantics(
             CompoundAccessKind.UNRESOLVED_SUPER_GETTER, getter, setter);
       }
     } else if (getter.isField) {
-      if (setter.isField) {
+      if (setter.isErroneous) {
+        assert(invariant(node, getter.isFinal,
+            message: "Unexpected super setter '$setter' for getter '$getter."));
+        return new StaticAccess.superFinalField(getter);
+      } else if (setter.isField) {
         if (getter == setter) {
           return new StaticAccess.superField(getter);
         } else {
           return new CompoundAccessSemantics(
               CompoundAccessKind.SUPER_FIELD_FIELD, getter, setter);
         }
       } else {
         // Either the field is accessible directly, or a setter shadows the
         // setter access. If there was another instance member it would shadow
         // the field.
@@ skipping 12 matching lines @@
       } else {
         assert(invariant(node, setter.isSetter,
             message: "Unexpected super setter '$setter'."));
         return new CompoundAccessSemantics(
             CompoundAccessKind.SUPER_GETTER_SETTER, getter, setter);
       }
     } else {
       assert(invariant(node, getter.isFunction,
           message: "Unexpected super getter '$getter'."));
       if (setter.isErroneous) {
-        return new CompoundAccessSemantics(
-            CompoundAccessKind.UNRESOLVED_SUPER_SETTER, getter, setter);
+        if (isIndex) {
+          return new CompoundAccessSemantics(
+              CompoundAccessKind.UNRESOLVED_SUPER_SETTER, getter, setter);
+        } else {
+          return new StaticAccess.superMethod(getter);
+        }
       } else if (setter.isFunction) {
+        assert(invariant(node, setter.name == '[]=',
+            message: "Unexpected super setter '$setter'."));
         assert(invariant(node, getter.name == '[]',
             message: "Unexpected super getter '$getter'."));
-        assert(invariant(node, setter.name == '[]=',
-            message: "Unexpected super setter '$setter'."));
         return new CompoundAccessSemantics(
                     CompoundAccessKind.SUPER_GETTER_SETTER, getter, setter);
       } else {
         assert(invariant(node, setter.isSetter,
             message: "Unexpected super setter '$setter'."));
         return new CompoundAccessSemantics(
             CompoundAccessKind.SUPER_METHOD_SETTER, getter, setter);
       }
     }
   }
@@ skipping 90 matching lines @@
       Spannable node,
       Selector selector,
       {Name alternateName}) {
 
     Name name = selector.memberName;
     // TODO(johnniwinther): Ensure correct behavior if currentClass is a
     // patch.
     Element target = currentClass.lookupSuperByName(name);
     // [target] may be null which means invoking noSuchMethod on super.
     if (target == null) {
-      Element error = reportAndCreateErroneousElement(
+      if (alternateName != null) {
+        target = currentClass.lookupSuperByName(alternateName);
+      }
+      Element error;
+      if (selector.isSetter) {
+        error = reportAndCreateErroneousElement(
+          node, name.text, MessageKind.SETTER_NOT_FOUND_IN_SUPER,
+          {'className': currentClass.name, 'name': name});
+      } else {
+        error = reportAndCreateErroneousElement(
           node, name.text, MessageKind.NO_SUCH_SUPER_MEMBER,
           {'className': currentClass.name, 'memberName': name});
-      if (alternateName != null) {
-        target = currentClass.lookupSuperByName(alternateName);
       }
       if (target == null) {
         // If a setter wasn't resolved, use the [ErroneousElement].
         target = error;
       }
       // We still need to register the invocation, because we might
       // call [:super.noSuchMethod:] which calls [JSInvocationMirror._invokeOn].
       registry.registerDynamicInvocation(new UniverseSelector(selector, null));
       registry.registerSuperNoSuchMethod();
     }
@@ skipping 11 matching lines @@
   ///
   ///     class Super {
   ///       set name(_) {}
   ///     }
   ///     class Sub extends Super {
   ///       foo => super.name; // Access to the setter.
   ///     }
   ///
   AccessSemantics computeSuperAccessSemanticsForSelectors(
       Spannable node,
-      Selector getterSelector, Selector setterSelector) {
+      Selector getterSelector,
+      Selector setterSelector,
+      {bool isIndex: false}) {
+    bool getterError = false;
+    bool setterError = false;
 
     // TODO(johnniwinther): Ensure correct behavior if currentClass is a
     // patch.
     Element getter = currentClass.lookupSuperByName(getterSelector.memberName);
     // [target] may be null which means invoking noSuchMethod on super.
     if (getter == null) {
       getter = reportAndCreateErroneousElement(
           node, getterSelector.name, MessageKind.NO_SUCH_SUPER_MEMBER,
           {'className': currentClass.name, 'memberName': getterSelector.name});
-      // We still need to register the invocation, because we might
-      // call `super.noSuchMethod` which calls [JSInvocationMirror._invokeOn].
-      registry.registerDynamicInvocation(
-          new UniverseSelector(getterSelector, null));
-      registry.registerSuperNoSuchMethod();
+      getterError = true;
     }
     Element setter = currentClass.lookupSuperByName(setterSelector.memberName);
     // [target] may be null which means invoking noSuchMethod on super.
     if (setter == null) {
       setter = reportAndCreateErroneousElement(
           node, setterSelector.name, MessageKind.NO_SUCH_SUPER_MEMBER,
           {'className': currentClass.name, 'memberName': setterSelector.name});
+      setterError = true;
+    } else if (getter == setter) {
+      if (setter.isFunction) {
+        setter = reportAndCreateErroneousElement(
+            node, setterSelector.name,
+            MessageKind.ASSIGNING_METHOD_IN_SUPER,
+            {'superclassName': setter.enclosingClass.name,
+             'name': setterSelector.name});
+        setterError = true;
+      } else if (setter.isField && setter.isFinal) {
+        setter = reportAndCreateErroneousElement(
+            node, setterSelector.name,
+            MessageKind.ASSIGNING_FINAL_FIELD_IN_SUPER,
+            {'superclassName': setter.enclosingClass.name,
+             'name': setterSelector.name});
+        setterError = true;
+      }
+    }
+    if (getterError) {
       // We still need to register the invocation, because we might
-      // call `super.noSuchMethod` which calls [JSInvocationMirror._invokeOn].
+      // call [:super.noSuchMethod:] which calls [JSInvocationMirror._invokeOn].
+      registry.registerDynamicInvocation(
+          new UniverseSelector(getterSelector, null));
+    }
+    if (setterError) {
+      // We still need to register the invocation, because we might
+      // call [:super.noSuchMethod:] which calls [JSInvocationMirror._invokeOn].
       registry.registerDynamicInvocation(
           new UniverseSelector(setterSelector, null));
+    }
+    if (getterError || setterError) {
       registry.registerSuperNoSuchMethod();
     }
-    return computeCompoundSuperAccessSemantics(node, getter, setter);
+    return computeCompoundSuperAccessSemantics(
+        node, getter, setter, isIndex: isIndex);
   }
 
   /// Resolve [node] as a subexpression that is _not_ the prefix of a member
   /// access. For instance `a` in `a + b`, as opposed to `a` in `a.b`.
   ResolutionResult visitExpression(Node node) {
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = false;
     ResolutionResult result = visit(node);
     sendIsMemberAccess = oldSendIsMemberAccess;
     return result;
@@ skipping 84 matching lines @@
     registry.registerSendStructure(node, const InvalidUnaryStructure());
     return const NoneResult();
   }
 
   /// Handle the unary expression of a user definable unary [operator], like
   /// `-a`, and `-super`.
   ResolutionResult handleUserDefinableUnary(Send node, UnaryOperator operator) {
     ResolutionResult result = const NoneResult();
     Node expression = node.receiver;
     Selector selector = operator.selector;
-    // TODO(johnniwinther): Remove this when all information goes through the
+    // TODO(23998): Remove this when all information goes through the
     // [SendStructure].
     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(semantics.element.declaration);
         }
-        // TODO(johnniwinther): Remove this when all information goes through
+        // TODO(23998): Remove this when all information goes through
         // the [SendStructure].
         registry.useElement(node, semantics.element);
       }
     } else {
       ResolutionResult expressionResult = visitExpression(expression);
       semantics = new DynamicAccess.dynamicProperty(expression);
       registry.registerDynamicInvocation(new UniverseSelector(selector, null));
 
       if (expressionResult.isConstant) {
         bool isValidConstant;
@@ skipping 139 matching lines @@
     ResolutionResult result = const NoneResult();
     Node left = node.receiver;
     Node right = node.arguments.head;
     AccessSemantics semantics;
     Selector selector;
     if (operator.kind == BinaryOperatorKind.INDEX) {
       selector = new Selector.index();
     } else {
       selector = new Selector.binaryOperator(operator.selectorName);
     }
-    // TODO(johnniwinther): Remove this when all information goes through the
+    // TODO(23998): Remove this when all information goes through the
     // [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(semantics.element.declaration);
         }
-        // TODO(johnniwinther): Remove this when all information goes through
+        // 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.registerDynamicInvocation(new UniverseSelector(selector, null));
       semantics = new DynamicAccess.dynamicProperty(left);
 
@@ skipping 117 matching lines @@
 
   /// Handle an invocation of an expression, like `(){}()` or `(foo)()`.
   ResolutionResult handleExpressionInvoke(Send node) {
     assert(invariant(node, node.isCall,
         message: "Unexpected expression: $node"));
     Node expression = node.selector;
     visitExpression(expression);
     CallStructure callStructure =
         resolveArguments(node.argumentsNode).callStructure;
     Selector selector = callStructure.callSelector;
-    // TODO(johnniwinther): Remove this when all information goes through the
+    // TODO(23998): Remove this when all information goes through the
     // [SendStructure].
     registry.setSelector(node, selector);
     registry.registerDynamicInvocation(new UniverseSelector(selector, null));
     registry.registerSendStructure(node,
         new InvokeStructure(new AccessSemantics.expression(), selector));
     return const NoneResult();
   }
 
   /// Handle a, possibly invalid, assertion, like `assert(cond)` or `assert()`.
   ResolutionResult handleAssert(Send node) {
@@ skipping 39 matching lines @@
           resolveArguments(node.argumentsNode).callStructure;
       Selector selector = callStructure.callSelector;
       // TODO(johnniwinther): Handle invalid this access as an
       // [AccessSemantics].
       if (checkThisAccess(node)) {
         registry.registerDynamicInvocation(
             new UniverseSelector(selector, null));
         registry.registerSendStructure(node,
             new InvokeStructure(accessSemantics, selector));
       }
-      // TODO(johnniwinther): Remove this when all information goes through
+      // TODO(23998): Remove this when all information goes through
       // the [SendStructure].
       registry.setSelector(node, selector);
     } else {
       // TODO(johnniwinther): Handle get of `this` when it is a [Send] node.
       internalError(node, "Unexpected node '$node'.");
     }
     return const NoneResult();
   }
 
   /// Handle access of a super property, like `super.foo` and `super.foo()`.
@@ skipping 74 matching lines @@
           break;
         default:
           internalError(node, "Unexpected super property access $semantics.");
           break;
       }
       registry.registerSendStructure(node,
           new GetStructure(semantics, selector));
     }
     target = semantics.element;
 
-    // TODO(johnniwinther): Remove these when all information goes through
+    // TODO(23998): Remove these when all information goes through
     // the [SendStructure].
     registry.useElement(node, target);
     registry.setSelector(node, selector);
     return const NoneResult();
   }
 
   /// Handle a [Send] whose selector is an [Operator], like `a && b`, `a is T`,
   /// `a + b`, and `~a`.
   ResolutionResult handleOperatorSend(Send node) {
     String operatorText = node.selector.asOperator().source;
@@ skipping 172 matching lines @@
 
     AccessSemantics semantics =
         new StaticAccess.typeParameterTypeLiteral(element);
     registry.useElement(node, element);
     registry.registerTypeLiteral(node, element.type);
 
     if (node.isCall) {
       CallStructure callStructure =
           resolveArguments(node.argumentsNode).callStructure;
       Selector selector = callStructure.callSelector;
-      // TODO(johnniwinther): Remove this when all information goes through
+      // TODO(23998): Remove this when all information goes through
       // the [SendStructure].
       registry.setSelector(node, selector);
 
       registry.registerSendStructure(node,
           new InvokeStructure(semantics, selector));
     } else {
       // TODO(johnniwinther): Avoid the need for a [Selector] here.
       registry.registerSendStructure(node,
           new GetStructure(semantics,
               new Selector(SelectorKind.GETTER, name, CallStructure.NO_ARGS)));
@@ skipping 12 matching lines @@
       TypeDeclarationElement element,
       DartType type,
       ConstantAccess semantics) {
     registry.useElement(node, element);
     registry.registerTypeLiteral(node, type);
 
     if (node.isCall) {
       CallStructure callStructure =
           resolveArguments(node.argumentsNode).callStructure;
       Selector selector = callStructure.callSelector;
-      // TODO(johnniwinther): Remove this when all information goes through
+      // TODO(23998): Remove this when all information goes through
       // the [SendStructure].
       registry.setSelector(node, selector);
 
       // The node itself is not a constant but we register the selector (the
       // identifier that refers to the class/typedef) as a constant.
       registry.useElement(node.selector, element);
       analyzeConstantDeferred(node.selector, enforceConst: false);
 
       registry.registerSendStructure(node,
           new InvokeStructure(semantics, selector));
@@ skipping 124 matching lines @@
       ErroneousElement error = reportAndCreateErroneousElement(
           node,
           name.text,
           MessageKind.PREFIX_AS_EXPRESSION,
           {'prefix': name},
           isError: true);
       return handleErroneousAccess(
           node, name, error, new StaticAccess.invalid(error));
     }
     if (prefix.isDeferred) {
-      // TODO(johnniwinther): Remove this when deferred access is detected
+      // 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);
   }
 
   /// Handle qualified [Send] where the receiver resolves to an [Element], like
   /// `a.b` where `a` is a prefix or a class.
   ResolutionResult handlePrefixSend(
@@ skipping 25 matching lines @@
       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(semantics, selector);
     }
     registry.registerSendStructure(node, sendStructure);
-    // TODO(johnniwinther): Remove this when all information goes through
+    // TODO(23998): Remove this when all information goes through
     // the [SendStructure].
     registry.setSelector(node, selector);
     return const NoneResult();
   }
 
   /// Handle dynamic property access, like `a.b` or `a.b()` where `a` is not a
   /// prefix or class.
   ResolutionResult handleDynamicPropertyAccess(Send node, Name name) {
     AccessSemantics semantics =
         new DynamicAccess.dynamicProperty(node.receiver);
@@ skipping 71 matching lines @@
           new UniverseSelector(selector, null));
       sendStructure = new InvokeStructure(accessSemantics, 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);
     }
-    // TODO(johnniwinther): Remove this when all information goes through
+    // TODO(23998): Remove this when all information goes through
     // the [SendStructure].
     registry.setSelector(node, selector);
     registry.useElement(node, element);
     registry.registerSendStructure(node, sendStructure);
     return const NoneResult();
   }
 
   /// Handle access to an ambiguous element, that is, a name imported twice.
   ResolutionResult handleAmbiguousSend(
       Send node,
@@ skipping 108 matching lines @@
         default:
           internalError(node,
               "Unexpected local access $semantics.");
           break;
       }
       selector = new Selector(SelectorKind.GETTER, name, CallStructure.NO_ARGS);
       registry.registerSendStructure(node,
           new GetStructure(semantics, selector));
     }
 
-    // TODO(johnniwinther): Remove these when all information goes through
+    // TODO(23998): Remove these when all information goes through
     // the [SendStructure].
     registry.useElement(node, element);
     registry.setSelector(node, selector);
 
     registerPotentialAccessInClosure(node, element);
 
     return result;
   }
 
   /// Handle access of a static or top level [element].
@@ skipping 119 matching lines @@
           new GetStructure(semantics, selector));
       if (member.isConst) {
         FieldElement field = member;
         result = new ConstantResult(
             node, new VariableConstantExpression(field), element: field);
       } else {
         result = new ElementResult(member);
       }
     }
 
-    // TODO(johnniwinther): Remove these when all information goes through
+    // TODO(23998): Remove these when all information goes through
     // the [SendStructure].
     registry.useElement(node, member);
     registry.setSelector(node, selector);
 
     return result;
   }
 
   /// Handle access to resolved [element].
   ResolutionResult handleResolvedSend(Send node, Name name, Element element) {
     if (element.isAmbiguous) {
@@ skipping 135 matching lines @@
     visitExpression(index);
     if (node.isPrefix || node.isPostfix) {
       // `a[b]++` or `++a[b]`.
       IncDecOperator operator = IncDecOperator.parse(operatorText);
       AccessSemantics semantics = new DynamicAccess.dynamicProperty(receiver);
       Selector getterSelector = new Selector.index();
       Selector setterSelector = new Selector.indexSet();
       Selector operatorSelector =
           new Selector.binaryOperator(operator.selectorName);
 
-      // TODO(johnniwinther): Remove these when selectors are only accessed
+      // 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(getterSelector, null));
       registry.registerDynamicInvocation(
           new UniverseSelector(setterSelector, null));
       registry.registerDynamicInvocation(
           new UniverseSelector(operatorSelector, null));
 
       SendStructure sendStructure = node.isPrefix
           ? new IndexPrefixStructure(
               semantics, operator, getterSelector, setterSelector)
           : new IndexPostfixStructure(
               semantics, operator, getterSelector, setterSelector);
       registry.registerSendStructure(node, sendStructure);
       return const NoneResult();
     } else {
       Node rhs = node.arguments.tail.head;
       visitExpression(rhs);
 
       AssignmentOperator operator = AssignmentOperator.parse(operatorText);
       if (operator.kind == AssignmentOperatorKind.ASSIGN) {
         // `a[b] = c`.
         AccessSemantics semantics = new DynamicAccess.dynamicProperty(receiver);
         Selector setterSelector = new Selector.indexSet();
 
-        // TODO(johnniwinther): Remove this when selectors are only accessed
+        // TODO(23998): Remove this when selectors are only accessed
         // through the send structure.
         registry.setSelector(node, setterSelector);
         registry.registerDynamicInvocation(
             new UniverseSelector(setterSelector, null));
 
         SendStructure sendStructure =
             new IndexSetStructure(semantics, setterSelector);
         registry.registerSendStructure(node, sendStructure);
         return const NoneResult();
       } else {
         // `a[b] += c`.
         AccessSemantics semantics = new DynamicAccess.dynamicProperty(receiver);
         Selector getterSelector = new Selector.index();
         Selector setterSelector = new Selector.indexSet();
         Selector operatorSelector =
             new Selector.binaryOperator(operator.selectorName);
 
-        // TODO(johnniwinther): Remove these when selectors are only accessed
+        // 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(getterSelector, null));
         registry.registerDynamicInvocation(
             new UniverseSelector(setterSelector, null));
         registry.registerDynamicInvocation(
@@ skipping 16 matching lines @@
     visitExpression(index);
     AccessSemantics semantics = checkSuperAccess(node);
     if (node.isPrefix || node.isPostfix) {
       // `super[a]++` or `++super[a]`.
       IncDecOperator operator = IncDecOperator.parse(operatorText);
       Selector getterSelector = new Selector.index();
       Selector setterSelector = new Selector.indexSet();
       Selector operatorSelector =
           new Selector.binaryOperator(operator.selectorName);
 
-      // TODO(johnniwinther): Remove these when selectors are only accessed
+      // 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);
+            node, getterSelector, setterSelector, isIndex: true);
 
         registry.registerStaticInvocation(semantics.getter);
         registry.registerStaticInvocation(semantics.setter);
 
-        // TODO(johnniwinther): Remove these when elements are only accessed
+        // 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 IndexPrefixStructure(
               semantics, operator, getterSelector, setterSelector)
           : new IndexPostfixStructure(
               semantics, operator, getterSelector, setterSelector);
       registry.registerSendStructure(node, sendStructure);
       return const NoneResult();
     } else {
       Node rhs = node.arguments.tail.head;
       visitExpression(rhs);
 
       AssignmentOperator operator = AssignmentOperator.parse(operatorText);
       if (operator.kind == AssignmentOperatorKind.ASSIGN) {
         // `super[a] = b`.
         Selector setterSelector = new Selector.indexSet();
         if (semantics == null) {
           semantics =
               computeSuperAccessSemanticsForSelector(node, setterSelector);
 
-          // TODO(johnniwinther): Remove these when elements are only accessed
+          // TODO(23998): Remove these when elements are only accessed
           // through the send structure.
           registry.useElement(node, semantics.setter);
         }
 
-        // TODO(johnniwinther): Remove this when selectors are only accessed
+        // TODO(23998): Remove this when selectors are only accessed
         // through the send structure.
         registry.setSelector(node, setterSelector);
         registry.registerStaticInvocation(semantics.setter);
 
         SendStructure sendStructure =
             new IndexSetStructure(semantics, setterSelector);
         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);
+              node, getterSelector, setterSelector, isIndex: true);
 
           registry.registerStaticInvocation(semantics.getter);
           registry.registerStaticInvocation(semantics.setter);
 
-          // TODO(johnniwinther): Remove these when elements are only accessed
+          // 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(johnniwinther): Remove these when selectors are only accessed
+        // 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 CompoundIndexSetStructure(
                 semantics, operator, getterSelector, setterSelector);
         registry.registerSendStructure(node, sendStructure);
         return const NoneResult();
       }
     }
   }
 
+  /// 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;
+    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();
+    } 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;
+          }
+
+          // 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);
+        Selector operatorSelector =
+            new Selector.binaryOperator(operator.selectorName);
+        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);
+        }
+
+        // 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);
     }
     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 50 matching lines @@
       } else if (target.isFunction && target.name != '[]=') {
         assert(!target.isSetter);
         if (Elements.isStaticOrTopLevelFunction(target) || target.isLocal) {
           setter = reportAndCreateErroneousElement(
               node.selector, target.name, MessageKind.ASSIGNING_METHOD,
               const {});
         } else if (node.isSuperCall) {
           setter = reportAndCreateErroneousElement(
               node.selector, target.name, MessageKind.ASSIGNING_METHOD_IN_SUPER,
               {'name': target.name,
-               'superclassName': target.enclosingElement.name});
+               'superclassName': target.enclosingClass.name});
           registry.registerSuperNoSuchMethod();
         } else {
           // For instance methods we don't report a warning here because the
           // type checker will detect this as well and report a better error
           // message with the context of the containing class.
         }
         registry.registerThrowNoSuchMethod();
       }
       if (isPotentiallyMutableTarget(target)) {
         registry.registerPotentialMutation(target, node);
@@ skipping 1205 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);
 }