Refactor handling of compounds.

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 1899 matching lines @@
       ast.Send node,
       ast.NodeList arguments, _) {
     if (compiler.enableUserAssertions) {
       return giveup(node, 'Assert');
     } else {
       return irBuilder.buildNullConstant();
     }
   }
 
   @override
-  ir.Primitive errorUnresolvedCompound(
+  ir.Primitive visitUnresolvedCompound(
       ast.Send node,
       Element element,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
     // TODO(asgerf): What is unresolved? The getter and/or the setter?
     //               If it was the setter, we must evaluate the right-hand side.
     return buildStaticNoSuchMethod(elements.getSelector(node), []);
   }
 
   @override
@@ skipping 41 matching lines @@
   ir.Primitive visitUnresolvedInvoke(
       ast.Send node,
       Element element,
       ast.NodeList arguments,
       Selector selector, _) {
     return buildStaticNoSuchMethod(elements.getSelector(node),
         arguments.nodes.mapToList(visit));
   }
 
   @override
-  ir.Primitive errorUnresolvedPostfix(
+  ir.Primitive visitUnresolvedPostfix(
       ast.Send node,
       Element element,
       op.IncDecOperator operator, _) {
     // TODO(asgerf): Which ones are missing? The getter and/or the setter?
     return buildStaticNoSuchMethod(elements.getSelector(node), []);
   }
 
   @override
-  ir.Primitive errorUnresolvedPrefix(
+  ir.Primitive visitUnresolvedPrefix(
       ast.Send node,
       Element element,
       op.IncDecOperator operator, _) {
     // TODO(asgerf): Which ones are missing? The getter and/or the setter?
     return buildStaticNoSuchMethod(elements.getSelector(node), []);
   }
 
   @override
   ir.Primitive visitUnresolvedRedirectingFactoryConstructorInvoke(
        ast.NewExpression node,
@@ skipping 192 matching lines @@
   ir.Primitive visitAbstractClassConstructorInvoke(
       ast.NewExpression node,
       ConstructorElement element,
       InterfaceType type,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
     return buildAbstractClassInstantiationError(element.enclosingClass);
   }
 
   @override
-  ir.Primitive errorClassTypeLiteralCompound(
+  ir.Primitive visitClassTypeLiteralCompound(
       ast.Send node,
       ConstantExpression constant,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
     return translateCompound(
         getValue: () => irBuilder.buildConstant(constant),
         operator: operator,
         rhs: rhs,
         setValue: (value) {}); // The binary operator will throw before this.
   }
 
   @override
-  ir.Primitive errorClassTypeLiteralPostfix(
+  ir.Primitive visitClassTypeLiteralPostfix(
       ast.Send node,
       ConstantExpression constant,
       op.IncDecOperator operator, _) {
     return translatePrefixPostfix(
       getValue: () => irBuilder.buildConstant(constant),
       operator: operator,
       setValue: (value) {}, // The binary operator will throw before this.
       isPrefix: false);
   }
 
   @override
-  ir.Primitive errorClassTypeLiteralPrefix(
+  ir.Primitive visitClassTypeLiteralPrefix(
       ast.Send node,
       ConstantExpression constant,
       op.IncDecOperator operator, _) {
     return translatePrefixPostfix(
       getValue: () => irBuilder.buildConstant(constant),
       operator: operator,
       setValue: (value) {}, // The binary operator will throw before this.
       isPrefix: true);
   }
 
   @override
-  ir.Primitive errorDynamicTypeLiteralCompound(
+  ir.Primitive visitDynamicTypeLiteralCompound(
       ast.Send node,
       ConstantExpression constant,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
     return translateCompound(
         getValue: () => irBuilder.buildConstant(constant),
         operator: operator,
         rhs: rhs,
         setValue: (value) {}); // The binary operator will throw before this.
   }
 
   @override
-  ir.Primitive errorDynamicTypeLiteralPostfix(
+  ir.Primitive visitDynamicTypeLiteralPostfix(
       ast.Send node,
       ConstantExpression constant,
       op.IncDecOperator operator, _) {
     return translatePrefixPostfix(
         getValue: () => irBuilder.buildConstant(constant),
         operator: operator,
         setValue: (value) {}, // The binary operator will throw before this.
         isPrefix: false);
   }
 
   @override
-  ir.Primitive errorDynamicTypeLiteralPrefix(
+  ir.Primitive visitDynamicTypeLiteralPrefix(
       ast.Send node,
       ConstantExpression constant,
       op.IncDecOperator operator, _) {
     return translatePrefixPostfix(
         getValue: () => irBuilder.buildConstant(constant),
         operator: operator,
         setValue: (value) {}, // The binary operator will throw before this.
         isPrefix: true);
   }
 
   @override
-  ir.Primitive errorFinalLocalVariableCompound(
+  ir.Primitive visitFinalLocalVariableCompound(
       ast.Send node,
       LocalVariableElement variable,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
     Selector selector = new Selector.setter(variable.name, null);
     return translateCompound(
         getValue: () => irBuilder.buildLocalVariableGet(variable),
         operator: operator,
         rhs: rhs,
         setValue: (value) => buildStaticNoSuchMethod(selector, [value]));
   }
 
   @override
   ir.Primitive errorFinalLocalVariableSet(
       ast.SendSet node,
       LocalVariableElement variable,
       ast.Node rhs, _) {
     Selector selector = new Selector.setter(variable.name, null);
     return buildStaticNoSuchMethod(selector, [visit(rhs)]);
   }
 
   @override
-  ir.Primitive errorFinalParameterCompound(
+  ir.Primitive visitFinalParameterCompound(
       ast.Send node,
       ParameterElement parameter,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
     Selector selector = new Selector.setter(parameter.name, null);
     return translateCompound(
         getValue: () => irBuilder.buildLocalVariableGet(parameter),
         operator: operator,
         rhs: rhs,
         setValue: (value) => buildStaticNoSuchMethod(selector, [value]));
   }
 
   @override
   ir.Primitive errorFinalParameterSet(
       ast.SendSet node,
       ParameterElement parameter,
       ast.Node rhs, _) {
     Selector selector = new Selector.setter(parameter.name, null);
     return buildStaticNoSuchMethod(selector, [visit(rhs)]);
   }
 
   @override
-  ir.Primitive errorFinalStaticFieldCompound(
+  ir.Primitive visitStaticFinalFieldCompound(
       ast.Send node,
       FieldElement field,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
     return translateCompound(
         getValue: () => irBuilder.buildStaticFieldGet(field),
         operator: operator,
         rhs: rhs,
         setValue: (value) => buildStaticNoSuchMethod(
             new Selector.setter(field.name, field.library), [value]));
   }
 
   @override
   ir.Primitive errorFinalStaticFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs, _) {
     // TODO(asgerf): Include class name somehow?
     return buildStaticNoSuchMethod(
         new Selector.setter(field.name, field.library),
         [visit(rhs)]);
   }
 
   @override
-  ir.Primitive errorFinalSuperFieldCompound(
+  ir.Primitive visitFinalSuperFieldCompound(
       ast.Send node,
       FieldElement field,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
     Selector selector = useSelectorTypeOfNode(
         new Selector.setter(field.name, field.library),
         node);
     return translateCompound(
         getValue: () => irBuilder.buildSuperFieldGet(field),
         operator: operator,
         rhs: rhs,
         setValue: (value) => buildInstanceNoSuchMethod(selector, [value]));
   }
 
   @override
   ir.Primitive errorFinalSuperFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs, _) {
     Selector selector = useSelectorTypeOfNode(
         new Selector.setter(field.name, field.library),
         node);
     return buildInstanceNoSuchMethod(selector, [visit(rhs)]);
   }
 
   @override
-  ir.Primitive errorFinalTopLevelFieldCompound(
+  ir.Primitive visitTopLevelFinalFieldCompound(
       ast.Send node,
       FieldElement field,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
     return translateCompound(
         getValue: () => irBuilder.buildStaticFieldGet(field),
         operator: operator,
         rhs: rhs,
         setValue: (value) => buildStaticNoSuchMethod(
             new Selector.setter(field.name, field.library), [value]));
   }
 
   @override
   ir.Primitive errorFinalTopLevelFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs, _) {
     return buildStaticNoSuchMethod(
         new Selector.setter(field.name, field.library),
         [visit(rhs)]);
   }
 
   @override
-  ir.Primitive errorLocalFunctionCompound(
+  ir.Primitive visitLocalFunctionCompound(
       ast.Send node,
       LocalFunctionElement function,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
     return translateCompound(
         getValue: () => irBuilder.buildLocalFunctionGet(function),
         operator: operator,
         rhs: rhs,
         setValue: (value) {}); // Binary operator will throw before this.
   }
 
   @override
-  ir.Primitive errorLocalFunctionPostfix(
+  ir.Primitive visitLocalFunctionPostfix(
       ast.Send node,
       LocalFunctionElement function,
       op.IncDecOperator operator,
       _) {
     return translatePrefixPostfix(
         getValue: () => irBuilder.buildLocalFunctionGet(function),
         operator: operator,
         setValue: (value) {}, // Binary operator will throw before this.
         isPrefix: false);
   }
 
   @override
-  ir.Primitive errorLocalFunctionPrefix(
+  ir.Primitive visitLocalFunctionPrefix(
       ast.Send node,
       LocalFunctionElement function,
       op.IncDecOperator operator,
       _) {
     return translatePrefixPostfix(
         getValue: () => irBuilder.buildLocalFunctionGet(function),
         operator: operator,
         setValue: (value) {}, // Binary operator will throw before this.
         isPrefix: true);
   }
@@ skipping 97 matching lines @@
     List<ir.Primitive> args =
         translateDynamicArguments(arguments, callStructure);
     Name name = new Name(setter.name, setter.library);
     Selector selector = useSelectorTypeOfNode(
         new Selector(SelectorKind.CALL, name, callStructure),
         node);
     return buildInstanceNoSuchMethod(selector, args);
   }
 
   @override
-  ir.Primitive errorTypeVariableTypeLiteralCompound(
+  ir.Primitive visitTypeVariableTypeLiteralCompound(
       ast.Send node,
       TypeVariableElement element,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
     return translateCompound(
         getValue: () => irBuilder.buildReifyTypeVariable(element.type),
         operator: operator,
         rhs: rhs,
         setValue: (value) {}); // The binary operator will throw before this.
   }
 
   @override
-  ir.Primitive errorTypeVariableTypeLiteralPostfix(
+  ir.Primitive visitTypeVariableTypeLiteralPostfix(
       ast.Send node,
       TypeVariableElement element,
       op.IncDecOperator operator, _) {
     return translatePrefixPostfix(
         getValue: () => irBuilder.buildReifyTypeVariable(element.type),
         operator: operator,
         setValue: (value) {}, // The binary operator will throw before this.
         isPrefix: false);
   }
 
   @override
-  ir.Primitive errorTypeVariableTypeLiteralPrefix(
+  ir.Primitive visitTypeVariableTypeLiteralPrefix(
       ast.Send node,
       TypeVariableElement element,
       op.IncDecOperator operator, _) {
     return translatePrefixPostfix(
         getValue: () => irBuilder.buildReifyTypeVariable(element.type),
         operator: operator,
         setValue: (value) {}, // The binary operator will throw before this.
         isPrefix: true);
   }
 
   @override
-  ir.Primitive errorTypedefTypeLiteralCompound(
+  ir.Primitive visitTypedefTypeLiteralCompound(
       ast.Send node,
       ConstantExpression constant,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
     return translateCompound(
         getValue: () => irBuilder.buildConstant(constant),
         operator: operator,
         rhs: rhs,
         setValue: (value) {}); // The binary operator will throw before this.
   }
 
   @override
-  ir.Primitive errorTypedefTypeLiteralPostfix(
+  ir.Primitive visitTypedefTypeLiteralPostfix(
       ast.Send node,
       ConstantExpression constant,
       op.IncDecOperator operator, _) {
     return translatePrefixPostfix(
         getValue: () => irBuilder.buildConstant(constant),
         operator: operator,
         setValue: (value) {}, // The binary operator will throw before this.
         isPrefix: false);
   }
 
   @override
-  ir.Primitive errorTypedefTypeLiteralPrefix(
+  ir.Primitive visitTypedefTypeLiteralPrefix(
       ast.Send node,
       TypeConstantExpression constant,
       op.IncDecOperator operator, _) {
     return translatePrefixPostfix(
         getValue: () => irBuilder.buildConstant(constant),
         operator: operator,
         setValue: (value) {}, // The binary operator will throw before this.
         isPrefix: true);
   }
 
@@ skipping 1081 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();
   }
 }