More extensive error handling for 'unresolved' cases.

lib/unresolved.dart

 // Copyright (c) 2016, 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.md file.
 
 library rasta.unresolved;
 
 import 'package:kernel/ast.dart' as ir;
 
+import 'accessors.dart';
+
 import "package:compiler/src/resolution/operators.dart" show
     AssignmentOperator,
     BinaryOperator,
     IncDecOperator,
     UnaryOperator;
 
 import "package:compiler/src/universe/call_structure.dart" show
     CallStructure;
 
 import "package:compiler/src/elements/elements.dart" show
     AstElement,
     ConstructorElement,
     Element,
     ErroneousElement,
     FunctionElement,
     MethodElement;
 
 import "package:compiler/src/dart_types.dart" show
     DartType,
     InterfaceType;
 
 import "package:compiler/src/tree/tree.dart" show
+    Expression,
     NewExpression,
     Node,
     NodeList,
     Send;
 
 import "package:compiler/src/universe/selector.dart" show
     Selector;
 
 import "kernel.dart" show
     Kernel;
 
-ir.Arguments buildStringArgument(String argument) {
-  return new ir.Arguments(<ir.Expression>[new ir.StringLiteral(argument)]);
-}
-
-ir.Arguments buildIntArgument(int argument) {
-  return new ir.Arguments(<ir.Expression>[new ir.IntLiteral(argument)]);
-}
-
 abstract class RastaUnresolved {
   Kernel get kernel;
 
   // Implemented in KernelVisitor
   AstElement get currentElement;
+  bool get isVoidContext;
   ir.Arguments buildArguments(NodeList arguments);
+  ir.TreeNode visitForValue(Expression node);
 
   // TODO(ahe): Delete this method.
   ir.InvalidExpression handleUnresolved(Node node);
 
   /// Throws a [NoSuchMethodError] corresponding to a call to
   /// [receiver].[memberName] with the arguments [callArguments].
   ///
   /// The exception object is built by calling [exceptionBuilder]. This should
   /// take the same arguments as the default constructor to [NoSuchMethodError],
   /// but the method itself may encode additional details about the call than
@@ skipping 29 matching lines @@
         exceptionBuilder,
         new ir.Arguments(<ir.Expression>[
           receiver,
           memberNameArg,
           positional,
           named,
           existingArguments
         ])));
   }
 
+  /// Throws a NoSuchMethodError for an unresolved getter named [name].
+  ir.Expression buildThrowUnresolvedGetter(
+      String name,
+      [ir.Procedure exceptionBuilder]) {
+    // TODO(asgerf): We should remove this fallback, but in some cases we do
+    //   not get sufficient information to determine exactly what kind of
+    //   getter it is.
+    exceptionBuilder ??= kernel.getGenericNoSuchMethodBuilder();
+    return buildThrowNoSuchMethodError(
+        exceptionBuilder,
+        new ir.NullLiteral(),
+        name,
+        new ir.Arguments.empty());
+  }
+
+  ir.Expression buildThrowUnresolvedSetter(
+      String name,
+      ir.Expression argument,
+      [ir.Procedure exceptionBuilder]) {
+    // TODO(asgerf): We should remove this fallback, but in some cases we do
+    //   not get sufficient information to determine exactly what kind of
+    //   setter it is.
+    exceptionBuilder ??= kernel.getGenericNoSuchMethodBuilder();
+    return buildThrowNoSuchMethodError(
+        exceptionBuilder,
+        new ir.NullLiteral(),
+        name,
+        new ir.Arguments(<ir.Expression>[argument]));
+  }
+
+  ir.Expression buildThrowUnresolvedSuperGetter(String name) {
+    return buildThrowNoSuchMethodError(
+        kernel.getUnresolvedSuperGetterBuilder(),
+        new ir.ThisExpression(),
+        name,
+        new ir.Arguments.empty());
+  }
+
+  ir.Expression buildThrowUnresolvedSuperSetter(
+      String name,
+      ir.Expression argument) {
+    return buildThrowNoSuchMethodError(
+        kernel.getUnresolvedSuperSetterBuilder(),
+        new ir.ThisExpression(),
+        name,
+        new ir.Arguments(<ir.Expression>[argument]));
+  }
+
   ir.Expression buildThrowSingleArgumentError(
-      ir.Procedure exceptionBuilder, String errorMessage) {
+      ir.Procedure exceptionBuilder,
+      String errorMessage) {
     return new ir.Throw(new ir.StaticInvocation(exceptionBuilder,
         new ir.Arguments(<ir.Expression>[new ir.StringLiteral(errorMessage)])));
   }
 
   ir.Expression visitUnresolvedClassConstructorInvoke(
       NewExpression node,
       ErroneousElement element,
       DartType type,
       NodeList arguments,
       Selector selector,
@@ skipping 16 matching lines @@
         ? '${node.send.selector}'
         : type.name;
     return buildThrowNoSuchMethodError(
         kernel.getUnresolvedConstructorBuilder(),
         receiver,
         methodName,
         buildArguments(arguments),
         constructor);
   }
 
-  ir.InvalidExpression visitUnresolvedCompound(
-      Send node,
-      Element element,
-      AssignmentOperator operator,
-      Node rhs,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedGet(
-      Send node,
-      Element element,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedInvoke(
+  ir.Expression visitUnresolvedCompound(
+      Send node,
+      Element element,
+      AssignmentOperator operator,
+      Node rhs,
+      _) {
+    return buildThrowUnresolvedGetter('${node.selector}');
+  }
+
+  ir.Expression visitUnresolvedGet(
+      Send node,
+      Element element,
+      _) {
+    return buildThrowUnresolvedGetter('${node.selector}');
+  }
+
+  ir.Expression visitUnresolvedInvoke(
       Send node,
       Element element,
       NodeList arguments,
       Selector selector,
       _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedPostfix(
-      Send node,
-      Element element,
-      IncDecOperator operator,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedPrefix(
-      Send node,
-      Element element,
-      IncDecOperator operator,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedRedirectingFactoryConstructorInvoke(
+    // TODO(asgerf): Should we use a type literal as receiver for unresolved
+    //   static invocations?
+    return buildThrowNoSuchMethodError(
+        kernel.getGenericNoSuchMethodBuilder(),
+        new ir.NullLiteral(),
+        element.name,
+        buildArguments(arguments),
+        element);
+  }
+
+  ir.Expression visitUnresolvedPostfix(
+      Send node,
+      Element element,
+      IncDecOperator operator,
+      _) {
+    return buildThrowUnresolvedGetter('${node.selector}');
+  }
+
+  ir.Expression visitUnresolvedPrefix(
+      Send node,
+      Element element,
+      IncDecOperator operator,
+      _) {
+    return buildThrowUnresolvedGetter('${node.selector}');
+  }
+
+  ir.Expression visitUnresolvedRedirectingFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
       InterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSet(
-      Send node,
-      Element element,
-      Node rhs,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSetIfNull(
-      Send node,
-      Element element,
-      Node rhs,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedStaticGetterCompound(
-      Send node,
-      Element element,
-      MethodElement setter,
-      AssignmentOperator operator,
-      Node rhs,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedStaticGetterPostfix(
-      Send node,
-      Element element,
-      MethodElement setter,
-      IncDecOperator operator,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedStaticGetterPrefix(
-      Send node,
-      Element element,
-      MethodElement setter,
-      IncDecOperator operator,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedStaticGetterSetIfNull(
-      Send node,
-      Element element,
-      MethodElement setter,
-      Node rhs,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedStaticSetterCompound(
-      Send node,
-      MethodElement getter,
-      Element element,
-      AssignmentOperator operator,
-      Node rhs,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedStaticSetterPostfix(
-      Send node,
-      MethodElement getter,
-      Element element,
-      IncDecOperator operator,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedStaticSetterPrefix(
-      Send node,
-      MethodElement getter,
-      Element element,
-      IncDecOperator operator,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedStaticSetterSetIfNull(
-      Send node,
-      MethodElement getter,
-      Element element,
-      Node rhs,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSuperBinary(
+    // The body of the factory will throw an error.
+    return new ir.StaticInvocation(kernel.functionToIr(constructor),
+        buildArguments(arguments));
+  }
+
+  ir.Expression visitUnresolvedSet(
+      Send node,
+      Element element,
+      Node rhs,
+      _) {
+    return buildThrowUnresolvedSetter('${node.selector}', visitForValue(rhs));
+  }
+
+  ir.Expression visitUnresolvedSetIfNull(
+      Send node,
+      Element element,
+      Node rhs,
+      _) {
+    return buildThrowUnresolvedGetter('${node.selector}');
+  }
+
+  ir.Expression visitUnresolvedStaticGetterCompound(
+      Send node,
+      Element element,
+      MethodElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      _) {
+    return buildThrowUnresolvedGetter('${node.selector}',
+        kernel.getUnresolvedStaticGetterBuilder());
+  }
+
+  ir.Expression visitUnresolvedStaticGetterPostfix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      _) {
+    return buildThrowUnresolvedGetter('${node.selector}',
+        kernel.getUnresolvedStaticGetterBuilder());
+  }
+
+  ir.Expression visitUnresolvedStaticGetterPrefix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      _) {
+    return buildThrowUnresolvedGetter('${node.selector}',
+        kernel.getUnresolvedStaticGetterBuilder());
+  }
+
+  ir.Expression visitUnresolvedStaticGetterSetIfNull(
+      Send node,
+      Element element,
+      MethodElement setter,
+      Node rhs,
+      _) {
+    return buildThrowUnresolvedGetter('${node.selector}',
+        kernel.getUnresolvedStaticGetterBuilder());
+  }
+
+  ir.Expression visitUnresolvedStaticSetterCompound(
+      Send node,
+      MethodElement getter,
+      Element element,
+      AssignmentOperator operator,
+      Node rhs,
+      _) {
+    return buildThrowUnresolvedSetter('${node.selector}',
+        visitForValue(rhs),
+        kernel.getUnresolvedStaticSetterBuilder());
+  }
+
+  ir.Expression visitUnresolvedStaticSetterPostfix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      _) {
+    var accessor = new ClassStaticAccessor(this, getter.name,
+        kernel.functionToIr(getter), null);
+    return accessor.buildPostfixIncrement(
+        new ir.Name(operator.selectorName),
+        voidContext: isVoidContext);
+  }
+
+  ir.Expression visitUnresolvedStaticSetterPrefix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      _) {
+    var accessor = new ClassStaticAccessor(this, getter.name,
+        kernel.functionToIr(getter), null);
+    return accessor.buildPrefixIncrement(
+        new ir.Name(operator.selectorName),
+        voidContext: isVoidContext);
+  }
+
+  ir.Expression visitUnresolvedStaticSetterSetIfNull(
+      Send node,
+      MethodElement getter,
+      Element element,
+      Node rhs,
+      _) {
+    var accessor = new ClassStaticAccessor(this, getter.name,
+        kernel.functionToIr(getter), null);
+    return accessor.buildNullAwareAssignment(
+        visitForValue(rhs), voidContext: isVoidContext);
+  }
+
+  ir.Expression visitUnresolvedSuperBinary(
       Send node,
       Element element,
       BinaryOperator operator,
       Node argument,
       _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSuperCompound(
-      Send node,
-      Element element,
-      AssignmentOperator operator,
-      Node rhs,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSuperCompoundIndexSet(
+    return buildThrowNoSuchMethodError(
+        kernel.getUnresolvedSuperMethodBuilder(),
+        new ir.ThisExpression(),
+        operator.selectorName,
+        new ir.Arguments(<ir.Expression>[visitForValue(argument)]));
+  }
+
+  ir.Expression visitUnresolvedSuperCompound(
+      Send node,
+      Element element,
+      AssignmentOperator operator,
+      Node rhs,
+      _) {
+    return buildThrowUnresolvedSuperGetter('${node.selector}');
+  }
+
+  ir.Expression visitUnresolvedSuperCompoundIndexSet(
       Send node,
       Element element,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSuperGet(
-      Send node,
-      Element element,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSuperGetterCompound(
-      Send node,
-      Element element,
-      MethodElement setter,
-      AssignmentOperator operator,
-      Node rhs,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSuperGetterCompoundIndexSet(
-      Send node,
-      Element element,
-      MethodElement setter,
+    var accessor = new SuperIndexAccessor(this, visitForValue(index),
+        kernel.functionToIr(element), null);
+    return accessor.buildCompoundAssignment(new ir.Name(operator.selectorName),
+        visitForValue(rhs));
+  }
+
+  ir.Expression visitUnresolvedSuperGet(
+      Send node,
+      Element element,
+      _) {
+    return buildThrowUnresolvedSuperGetter('${node.selector}');
+  }
+
+  ir.Expression visitUnresolvedSuperGetterCompound(
+      Send node,
+      Element element,
+      MethodElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      _) {
+    return buildThrowUnresolvedSuperGetter('${node.selector}');
+  }
+
+  ir.Expression visitUnresolvedSuperGetterCompoundIndexSet(
+      Send node,
+      Element element,
+      MethodElement setter,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       _) {
-    return handleUnresolved(node);
+    return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
-  ir.InvalidExpression visitUnresolvedSuperGetterIndexPostfix(
+  ir.Expression visitUnresolvedSuperGetterIndexPostfix(
       Send node,
       Element element,
       MethodElement setter,
       Node index,
       IncDecOperator operator,
       _) {
-    return handleUnresolved(node);
+    return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
-  ir.InvalidExpression visitUnresolvedSuperGetterIndexPrefix(
+  ir.Expression visitUnresolvedSuperGetterIndexPrefix(
       Send node,
       Element element,
       MethodElement setter,
       Node index,
       IncDecOperator operator,
       _) {
-    return handleUnresolved(node);
+    return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
-  ir.InvalidExpression visitUnresolvedSuperGetterPostfix(
+  ir.Expression visitUnresolvedSuperGetterPostfix(
       Send node,
       Element element,
       MethodElement setter,
       IncDecOperator operator,
       _) {
-    return handleUnresolved(node);
+    return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
-  ir.InvalidExpression visitUnresolvedSuperGetterPrefix(
+  ir.Expression visitUnresolvedSuperGetterPrefix(
       Send node,
       Element element,
       MethodElement setter,
       IncDecOperator operator,
       _) {
-    return handleUnresolved(node);
+    return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
-  ir.InvalidExpression visitUnresolvedSuperGetterSetIfNull(
+  ir.Expression visitUnresolvedSuperGetterSetIfNull(
       Send node,
       Element element,
       MethodElement setter,
       Node rhs,
       _) {
-    return handleUnresolved(node);
+    return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
-  ir.InvalidExpression visitUnresolvedSuperIndex(
+  ir.Expression visitUnresolvedSuperIndex(
       Send node,
       Element element,
       Node index,
       _) {
-    return handleUnresolved(node);
+    return new SuperIndexAccessor(this, visitForValue(index), null, null)
+        .buildSimpleRead();
   }
 
-  ir.InvalidExpression visitUnresolvedSuperIndexPostfix(
+  ir.Expression visitUnresolvedSuperIndexPostfix(
       Send node,
       Element element,
       Node index,
       IncDecOperator operator,
       _) {
-    return handleUnresolved(node);
+    return new SuperIndexAccessor(this, visitForValue(index), null, null)
+        .buildSimpleRead();
   }
 
-  ir.InvalidExpression visitUnresolvedSuperIndexPrefix(
+  ir.Expression visitUnresolvedSuperIndexPrefix(
       Send node,
       Element element,
       Node index,
       IncDecOperator operator,
       _) {
-    return handleUnresolved(node);
+    return new SuperIndexAccessor(this, visitForValue(index), null, null)
+        .buildSimpleRead();
   }
 
-  ir.InvalidExpression visitUnresolvedSuperIndexSet(
+  ir.Expression visitUnresolvedSuperIndexSet(
       Send node,
       Element element,
       Node index,
       Node rhs,
       _) {
-    return handleUnresolved(node);
+    return new SuperIndexAccessor(this, visitForValue(index), null, null)
+        .buildAssignment(visitForValue(rhs));
   }
 
-  ir.InvalidExpression visitUnresolvedSuperInvoke(
+  ir.Expression visitUnresolvedSuperInvoke(
       Send node,
       Element element,
       NodeList arguments,
       Selector selector,
       _) {
-    return handleUnresolved(node);
+    // TODO(asgerf): Should really invoke 'super.noSuchMethod'.
+    return buildThrowNoSuchMethodError(
+        kernel.getUnresolvedSuperMethodBuilder(),
+        new ir.ThisExpression(),
+        '${node.selector}',
+        buildArguments(arguments));
   }
 
-  ir.InvalidExpression visitUnresolvedSuperPostfix(
+  ir.Expression visitUnresolvedSuperPostfix(
       Send node,
       Element element,
       IncDecOperator operator,
       _) {
-    return handleUnresolved(node);
+    return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
-  ir.InvalidExpression visitUnresolvedSuperPrefix(
+  ir.Expression visitUnresolvedSuperPrefix(
       Send node,
       Element element,
       IncDecOperator operator,
       _) {
-    return handleUnresolved(node);
+    return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
-  ir.InvalidExpression visitUnresolvedSuperSetIfNull(
+  ir.Expression visitUnresolvedSuperSetIfNull(
       Send node,
       Element element,
       Node rhs,
       _) {
-    return handleUnresolved(node);
+    return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
-  ir.InvalidExpression visitUnresolvedSuperSetterCompound(
+  ir.Expression visitUnresolvedSuperSetterCompound(
       Send node,
       MethodElement getter,
       Element element,
       AssignmentOperator operator,
       Node rhs,
       _) {
-    return handleUnresolved(node);
+    var accessor = new SuperPropertyAccessor(this, '${node.selector}',
+        kernel.functionToIr(getter), null);
+    return accessor.buildCompoundAssignment(
+        new ir.Name(operator.selectorName),
+        visitForValue(rhs));
   }
 
-  ir.InvalidExpression visitUnresolvedSuperSetterCompoundIndexSet(
+  ir.Expression visitUnresolvedSuperSetterCompoundIndexSet(
       Send node,
       MethodElement getter,
       Element element,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSuperSetterIndexPostfix(
+    var accessor = new SuperIndexAccessor(this, visitForValue(index),
+        kernel.functionToIr(getter), null);
+    return accessor.buildCompoundAssignment(
+        new ir.Name(operator.selectorName),
+        visitForValue(rhs));
+  }
+
+  ir.Expression visitUnresolvedSuperSetterIndexPostfix(
       Send node,
       MethodElement indexFunction,
       Element element,
       Node index,
       IncDecOperator operator,
       _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSuperSetterIndexPrefix(
+    var accessor = new SuperIndexAccessor(this, visitForValue(index),
+        kernel.functionToIr(indexFunction), null);
+    return accessor.buildPostfixIncrement(new ir.Name(operator.selectorName));
+  }
+
+  ir.Expression visitUnresolvedSuperSetterIndexPrefix(
       Send node,
       MethodElement indexFunction,
       Element element,
       Node index,
       IncDecOperator operator,
       _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSuperSetterPostfix(
-      Send node,
-      MethodElement getter,
-      Element element,
-      IncDecOperator operator,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSuperSetterPrefix(
-      Send node,
-      MethodElement getter,
-      Element element,
-      IncDecOperator operator,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSuperSetterSetIfNull(
-      Send node,
-      MethodElement getter,
-      Element element,
-      Node rhs,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSuperUnary(
+    var accessor = new SuperIndexAccessor(this, visitForValue(index),
+        kernel.functionToIr(indexFunction), null);
+    return accessor.buildPrefixIncrement(new ir.Name(operator.selectorName));
+  }
+
+  ir.Expression visitUnresolvedSuperSetterPostfix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      _) {
+    var accessor = new SuperPropertyAccessor(this, '${node.selector}',
+        kernel.functionToIr(getter), null);
+    return accessor.buildPostfixIncrement(new ir.Name(operator.selectorName));
+  }
+
+  ir.Expression visitUnresolvedSuperSetterPrefix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      _) {
+    var accessor = new SuperPropertyAccessor(this, '${node.selector}',
+        kernel.functionToIr(getter), null);
+    return accessor.buildPrefixIncrement(new ir.Name(operator.selectorName));
+  }
+
+  ir.Expression visitUnresolvedSuperSetterSetIfNull(
+      Send node,
+      MethodElement getter,
+      Element element,
+      Node rhs,
+      _) {
+    var accessor = new SuperPropertyAccessor(this, '${node.selector}',
+        kernel.functionToIr(getter), null);
+    return accessor.buildNullAwareAssignment(visitForValue(rhs));
+  }
+
+  ir.Expression visitUnresolvedSuperUnary(
       Send node,
       UnaryOperator operator,
       Element element,
       _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedTopLevelGetterCompound(
+    // TODO(asgerf): Should really call 'super.noSuchMethod'.
+    return buildThrowNoSuchMethodError(
+        kernel.getUnresolvedSuperMethodBuilder(),
+        new ir.ThisExpression(),
+        operator.selectorName,
+        new ir.Arguments.empty());
+  }
+
+  ir.Expression visitUnresolvedTopLevelGetterCompound(
       Send node,
       Element element,
       MethodElement setter,
       AssignmentOperator operator,
       Node rhs,
       _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedTopLevelGetterPostfix(
-      Send node,
-      Element element,
-      MethodElement setter,
-      IncDecOperator operator,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedTopLevelGetterPrefix(
-      Send node,
-      Element element,
-      MethodElement setter,
-      IncDecOperator operator,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedTopLevelGetterSetIfNull(
-      Send node,
-      Element element,
-      MethodElement setter,
-      Node rhs,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedTopLevelSetterCompound(
+    return buildThrowUnresolvedGetter('${node.selector}',
+        kernel.getUnresolvedTopLevelGetterBuilder());
+  }
+
+  ir.Expression visitUnresolvedTopLevelGetterPostfix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      _) {
+    return buildThrowUnresolvedGetter('${node.selector}',
+        kernel.getUnresolvedTopLevelGetterBuilder());
+  }
+
+  ir.Expression visitUnresolvedTopLevelGetterPrefix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      _) {
+    return buildThrowUnresolvedGetter('${node.selector}',
+        kernel.getUnresolvedTopLevelGetterBuilder());
+  }
+
+  ir.Expression visitUnresolvedTopLevelGetterSetIfNull(
+      Send node,
+      Element element,
+      MethodElement setter,
+      Node rhs,
+      _) {
+    return buildThrowUnresolvedGetter('${node.selector}',
+        kernel.getUnresolvedTopLevelGetterBuilder());
+  }
+
+  ir.Expression visitUnresolvedTopLevelSetterCompound(
       Send node,
       MethodElement getter,
       Element element,
       AssignmentOperator operator,
       Node rhs,
       _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedTopLevelSetterPostfix(
-      Send node,
-      MethodElement getter,
-      Element element,
-      IncDecOperator operator,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedTopLevelSetterPrefix(
-      Send node,
-      MethodElement getter,
-      Element element,
-      IncDecOperator operator,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedTopLevelSetterSetIfNull(
-      Send node,
-      MethodElement getter,
-      Element element,
-      Node rhs,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSuperGetterIndexSetIfNull(
-      Send node,
-      Element element,
-      MethodElement setter,
-      Node index,
-      Node rhs,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSuperSetterIndexSetIfNull(
-      Send node,
-      MethodElement getter,
-      Element element,
-      Node index,
-      Node rhs,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSuperIndexSetIfNull(
-      Send node,
-      Element element,
-      Node index,
-      Node rhs,
-      _) {
-    return handleUnresolved(node);
-  }
-
-  ir.InvalidExpression visitUnresolvedSuperSet(
-      Send node,
-      Element element,
-      Node rhs,
-      _) {
-    return handleUnresolved(node);
+    var accessor = new TopLevelStaticAccessor(this, getter.name,
+        kernel.functionToIr(getter), null);
+    return accessor.buildCompoundAssignment(
+        new ir.Name(operator.selectorName),
+        visitForValue(rhs),
+        voidContext: isVoidContext);
+  }
+
+  ir.Expression visitUnresolvedTopLevelSetterPostfix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      _) {
+    var accessor = new TopLevelStaticAccessor(this, getter.name,
+        kernel.functionToIr(getter), null);
+    return accessor.buildPostfixIncrement(
+        new ir.Name(operator.selectorName),
+        voidContext: isVoidContext);
+  }
+
+  ir.Expression visitUnresolvedTopLevelSetterPrefix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      _) {
+    var accessor = new TopLevelStaticAccessor(this, getter.name,
+        kernel.functionToIr(getter), null);
+    return accessor.buildPrefixIncrement(
+        new ir.Name(operator.selectorName),
+        voidContext: isVoidContext);
+  }
+
+  ir.Expression visitUnresolvedTopLevelSetterSetIfNull(
+      Send node,
+      MethodElement getter,
+      Element element,
+      Node rhs,
+      _) {
+    var accessor = new TopLevelStaticAccessor(this, getter.name,
+        kernel.functionToIr(getter), null);
+    return accessor.buildNullAwareAssignment(
+        visitForValue(rhs),
+        voidContext: isVoidContext);
+  }
+
+  ir.Expression visitUnresolvedSuperGetterIndexSetIfNull(
+      Send node,
+      Element element,
+      MethodElement setter,
+      Node index,
+      Node rhs,
+      _) {
+    var accessor = new SuperIndexAccessor(this, visitForValue(index),
+        null, kernel.functionToIr(setter));
+    return accessor.buildNullAwareAssignment(visitForValue(rhs));
+  }
+
+  ir.Expression visitUnresolvedSuperSetterIndexSetIfNull(
+      Send node,
+      MethodElement getter,
+      Element element,
+      Node index,
+      Node rhs,
+      _) {
+    var accessor = new SuperIndexAccessor(this, visitForValue(index),
+        kernel.functionToIr(getter), null);
+    return accessor.buildNullAwareAssignment(visitForValue(rhs));
+  }
+
+  ir.Expression visitUnresolvedSuperIndexSetIfNull(
+      Send node,
+      Element element,
+      Node index,
+      Node rhs,
+      _) {
+    var accessor =
+        new SuperIndexAccessor(this, visitForValue(index), null, null);
+    return accessor.buildNullAwareAssignment(visitForValue(rhs));
+  }
+
+  ir.Expression visitUnresolvedSuperSet(
+      Send node,
+      Element element,
+      Node rhs,
+      _) {
+    return buildThrowUnresolvedSuperSetter('${node.selector}',
+        visitForValue(rhs));
   }
 }