Refactor IrBuilder to use SemanticVisitor.

pkg/compiler/lib/src/resolution/semantic_visitor.dart

 // Copyright (c) 2015, 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.semantics_visitor;
 
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../tree/tree.dart';
@@ skipping 1040 matching lines @@
   /// or
   ///     m() { assert(expression1, expression2); }
   ///
   R errorInvalidAssert(
       Send node,
       NodeList arguments,
       A arg);
 
   /// Binary expression `left operator right` where [operator] is a user
   /// definable operator. Binary expressions using operator `==` are handled
-  /// by [visitEquals].
+  /// by [visitEquals] and index operations `a[b]` are handled by [visitIndex].
   ///
   /// For instance:
   ///     add(a, b) => a + b;
   ///     sub(a, b) => a - b;
   ///     mul(a, b) => a * b;
   ///
   R visitBinary(
       Send node,
       Node left,
       BinaryOperator operator,
@@ skipping 12 matching lines @@
   ///       m(a) => super + a;
   ///     }
   ///
   R visitSuperBinary(
       Send node,
       FunctionElement function,
       BinaryOperator operator,
       Node argument,
       A arg);
 
+  /// Index expression `receiver[index]`.
+  ///
+  /// For instance:
+  ///     lookup(a, b) => a[b];
+  ///
+  R visitIndex(
+      Send node,
+      Node receiver,
+      Node index,
+      A arg);
+
+  /// Index expression `super[index]` where 'operator []' is implemented on a
+  /// superclass by [function].
+  ///
+  /// For instance:
+  ///     class B {
+  ///       operator [](_) => null;
+  ///     }
+  ///     class C extends B {
+  ///       m(a) => super[a];
+  ///     }
+  ///
+  R visitSuperIndex(
+      Send node,
+      FunctionElement function,
+      Node index,
+      A arg);
+
   /// Binary expression `left == right`.
   ///
   /// For instance:
   ///     neq(a, b) => a != b;
   ///
   R visitNotEquals(
       Send node,
       Node left,
       Node right,
       A arg);
@@ skipping 82 matching lines @@
       Send node,
       Node expression,
       A arg);
 
   /// Index set expression `receiver[index] = rhs`.
   ///
   /// For instance:
   ///     m(receiver, index, rhs) => receiver[index] = rhs;
   ///
   R visitIndexSet(
-      Send node,
+      SendSet node,
       Node receiver,
       Node index,
       Node rhs,
       A arg);
 
   /// Index set expression `super[index] = rhs` where `operator []=` is defined
   /// on a superclass by [function].
   ///
   /// For instance:
   ///     class B {
   ///       operator []=(a, b) {}
   ///     }
   ///     class C extends B {
   ///       m(a, b) => super[a] = b;
   ///     }
   ///
   R visitSuperIndexSet(
-      Send node,
+      SendSet node,
       FunctionElement function,
       Node index,
       Node rhs,
       A arg);
 
   /// Logical and, &&, expression with operands [left] and [right].
   ///
   /// For instance
   ///     m() => left && right;
   ///
@@ skipping 411 matching lines @@
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a type literal
   /// for class [element].
   ///
   /// For instance:
   ///     class C {}
   ///     m(rhs) => C += rhs;
   ///
-  R visitClassTypeLiteralCompound(
+  R errorClassTypeLiteralCompound(
       Send node,
       TypeConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a type literal
   /// for typedef [element].
   ///
   /// For instance:
   ///     typedef F();
   ///     m(rhs) => F += rhs;
   ///
-  R visitTypedefTypeLiteralCompound(
+  R errorTypedefTypeLiteralCompound(
       Send node,
       TypeConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a type literal
   /// for type variable [element].
   ///
   /// For instance:
   ///     class C<T> {
   ///       m(rhs) => T += rhs;
   ///     }
   ///
-  R visitTypeVariableTypeLiteralCompound(
+  R errorTypeVariableTypeLiteralCompound(
       Send node,
       TypeVariableElement element,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on the type
   /// literal for `dynamic`.
   ///
   /// For instance:
   ///     m(rhs) => dynamic += rhs;
   ///
-  R visitDynamicTypeLiteralCompound(
+  R errorDynamicTypeLiteralCompound(
       Send node,
       TypeConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on the index
   /// operators of [receiver] whose getter and setter are defined by
   /// [getterSelector] and [setterSelector], respectively.
   ///
   /// For instance:
   ///     m(receiver, index, rhs) => receiver[index] += rhs;
   ///
   R visitCompoundIndexSet(
-      Send node,
+      SendSet node,
       Node receiver,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on the index
   /// operators of a super class defined by [getter] and [setter].
   ///
   /// For instance:
   ///     class B {
   ///       operator [](index) {}
   ///       operator [](index, value) {}
   ///     }
   ///     class C extends B {
   ///       m(index, rhs) => super[index] += rhs;
   ///     }
   ///
   R visitSuperCompoundIndexSet(
-      Send node,
+      SendSet node,
       FunctionElement getter,
       FunctionElement setter,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Prefix expression with [operator] of the property on [receiver] whose
   /// getter and setter are defined by [getterSelector] and [setterSelector],
   /// respectively.
@@ skipping 277 matching lines @@
       FunctionElement setter,
       IncDecOperator operator,
       A arg);
 
   /// Prefix expression with [operator] on a type literal for a class [element].
   ///
   /// For instance:
   ///     class C {}
   ///     m() => ++C;
   ///
-  R visitClassTypeLiteralPrefix(
+  R errorClassTypeLiteralPrefix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Prefix expression with [operator] on a type literal for a typedef
   /// [element].
   ///
   /// For instance:
   ///     typedef F();
   ///     m() => ++F;
   ///
-  R visitTypedefTypeLiteralPrefix(
+  R errorTypedefTypeLiteralPrefix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Prefix expression with [operator] on a type literal for a type variable
   /// [element].
   ///
   /// For instance:
   ///     class C<T> {
   ///       m() => ++T;
   ///     }
   ///
-  R visitTypeVariableTypeLiteralPrefix(
+  R errorTypeVariableTypeLiteralPrefix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       A arg);
 
   /// Prefix expression with [operator] on the type literal for `dynamic`.
   ///
   /// For instance:
   ///     m() => ++dynamic;
   ///
-  R visitDynamicTypeLiteralPrefix(
+  R errorDynamicTypeLiteralPrefix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Postfix expression with [operator] of the property on [receiver] whose
   /// getter and setter are defined by [getterSelector] and [setterSelector],
   /// respectively.
   ///
   /// For instance:
@@ skipping 276 matching lines @@
       IncDecOperator operator,
       A arg);
 
   /// Postfix expression with [operator] on a type literal for a class
   /// [element].
   ///
   /// For instance:
   ///     class C {}
   ///     m() => C++;
   ///
-  R visitClassTypeLiteralPostfix(
+  R errorClassTypeLiteralPostfix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Postfix expression with [operator] on a type literal for a typedef
   /// [element].
   ///
   /// For instance:
   ///     typedef F();
   ///     m() => F++;
   ///
-  R visitTypedefTypeLiteralPostfix(
+  R errorTypedefTypeLiteralPostfix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Postfix expression with [operator] on a type literal for a type variable
   /// [element].
   ///
   /// For instance:
   ///     class C<T> {
   ///       m() => T++;
   ///     }
   ///
-  R visitTypeVariableTypeLiteralPostfix(
+  R errorTypeVariableTypeLiteralPostfix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       A arg);
 
   /// Postfix expression with [operator] on the type literal for `dynamic`.
   ///
   /// For instance:
   ///     m() => dynamic++;
   ///
-  R visitDynamicTypeLiteralPostfix(
+  R errorDynamicTypeLiteralPostfix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Read of the [constant].
   ///
   /// For instance
   ///     const c = c;
   ///     m() => c;
@@ skipping 205 matching lines @@
 
   /// Invocation of an undefined unary [operator] with operands
   /// [left] and [right].
   R errorUndefinedBinaryExpression(
       Send node,
       Node left,
       Operator operator,
       Node right,
       A arg);
 }