Refactor SsaBuilder.visitSuperSend.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 777 matching lines @@
 
   @override
   ir.Primitive visitSuperMethodGet(
       ast.Send node,
       MethodElement method,
       _) {
     return irBuilder.buildSuperMethodGet(method);
   }
 
   @override
+  ir.Primitive visitUnresolvedSuperGet(
+      ast.Send node,
+      Element element,
+      _) {
+    return giveup(node, 'visitUnresolvedSuperGet');
+  }
+
+  @override
   ir.Primitive visitThisGet(ast.Identifier node, _) {
     return irBuilder.buildThis();
   }
 
   ir.Primitive translateTypeVariableTypeLiteral(TypeVariableElement element) {
     return buildReifyTypeVariable(irBuilder.buildThis(), element.type);
   }
 
   @override
   ir.Primitive visitTypeVariableTypeLiteralGet(ast.Send node,
@@ skipping 102 matching lines @@
   ir.Primitive visitSuperBinary(
       ast.Send node,
       FunctionElement function,
       op.BinaryOperator operator,
       ast.Node argument,
       _) {
     return translateSuperBinary(function, operator, argument);
   }
 
   @override
+  ir.Primitive visitUnresolvedSuperBinary(
+      ast.Send node,
+      Element element,
+      op.BinaryOperator operator,
+      ast.Node argument,
+      _) {
+    return giveup(node, 'visitUnresolvedSuperBinary');
+  }
+
+  @override
   ir.Primitive visitSuperIndex(
       ast.Send node,
       FunctionElement function,
       ast.Node index,
       _) {
     return irBuilder.buildSuperIndex(function, visit(index));
   }
 
   @override
+  ir.Primitive visitUnresolvedSuperIndex(
+      ast.Send node,
+      Element element,
+      ast.Node index,
+      _) {
+    return giveup(node, 'visitUnresolvedSuperIndex');
+  }
+
+  @override
   ir.Primitive visitEquals(
       ast.Send node,
       ast.Node left,
       ast.Node right,
       _) {
     return translateBinary(left, op.BinaryOperator.EQ, right);
   }
 
   @override
   ir.Primitive visitSuperEquals(
@@ skipping 47 matching lines @@
   @override
   ir.Primitive visitSuperUnary(
       ast.Send node,
       op.UnaryOperator operator,
       FunctionElement function,
       _) {
     return irBuilder.buildSuperMethodInvocation(
         function, CallStructure.NO_ARGS, const []);
   }
 
+  @override
+  ir.Primitive visitUnresolvedSuperUnary(
+      ast.Send node,
+      op.UnaryOperator operator,
+      Element element,
+      _) {
+    return giveup(node, 'visitUnresolvedSuperUnary');
+  }
+
   // TODO(johnniwinther): Handle this in the [IrBuilder] to ensure the correct
   // semantic correlation between arguments and invocation.
   List<ir.Primitive> translateDynamicArguments(ast.NodeList nodeList,
                                                CallStructure callStructure) {
     List<ir.Primitive> arguments = nodeList.nodes.mapToList(visit);
     return normalizeDynamicArguments(callStructure, arguments);
   }
 
   // TODO(johnniwinther): Handle this in the [IrBuilder] to ensure the correct
   // semantic correlation between arguments and invocation.
@@ skipping 132 matching lines @@
       ast.Send node,
       MethodElement method,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return irBuilder.buildSuperMethodInvocation(method, callStructure,
         translateDynamicArguments(arguments, callStructure));
   }
 
   @override
+  ir.Primitive visitSuperMethodIncompatibleInvoke(
+      ast.Send node,
+      MethodElement method,
+      ast.NodeList arguments,
+      CallStructure callStructure,
+      _) {
+    return giveup(node, 'visitSuperMethodIncompatibleInvoke');
+  }
+
+  @override
+  ir.Primitive visitUnresolvedSuperInvoke(
+      ast.Send node,
+      MethodElement method,
+      ast.NodeList arguments,
+      Selector selector,
+      _) {
+    return giveup(node, 'visitUnresolvedSuperInvoke');
+  }
+
+  @override
   ir.Primitive visitThisInvoke(
       ast.Send node,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return translateCallInvoke(irBuilder.buildThis(), arguments, callStructure);
   }
 
   @override
   ir.Primitive visitTypeVariableTypeLiteralInvoke(
@@ skipping 1664 matching lines @@
     node.body = replacementFor(node.body);
   }
 }
 
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends ir.RecursiveVisitor {
   processReference(ir.Reference reference) {
     reference.unlink();
   }
 }