Refactor IrBuilder to use SemanticVisitor.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.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;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
@@ skipping 241 matching lines @@
   /// Remove an [ir.MutableVariable] for a local.
   ///
   /// Subsequent access to the local will be direct rather than through the
   /// mutable variable.  This is used for variables that do not spend their
   /// entire lifetime as mutable variables (e.g., variables that are boxed
   /// in mutable variables for a try block).
   void removeMutableVariable(Local local);
 
   void declareLocalVariable(LocalVariableElement element,
                             {ir.Primitive initialValue});
-  ir.Primitive buildLocalGet(LocalElement element);
-  ir.Primitive buildLocalSet(LocalElement element, ir.Primitive value);
 
   /// Called when entering a nested function with free variables.
   ///
   /// The free variables must subsequently be accessible using [buildLocalGet]
   /// and [buildLocalSet].
   void _enterClosureEnvironment(ClosureEnvironment env);
 
   /// Called when entering a function body or loop body.
   ///
   /// This is not called for for-loops, which instead use the methods
@@ skipping 174 matching lines @@
     ir.Continuation k = new ir.Continuation([v]);
     ir.Expression expression = build(k);
     add(new ir.LetCont(k, expression));
     return v;
   }
 
   ir.Primitive _buildInvokeStatic(Element element,
                                   Selector selector,
                                   List<ir.Primitive> arguments,
                                   SourceInformation sourceInformation) {
+    assert(!element.isLocal);
+    assert(!element.isInstanceMember);
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.InvokeStatic(element, selector, k, arguments,
                                    sourceInformation));
   }
 
   ir.Primitive _buildInvokeSuper(Element target,
                                  Selector selector,
                                  List<ir.Primitive> arguments) {
+    assert(target.isInstanceMember);
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.InvokeMethodDirectly(
             buildThis(), target, selector, k, arguments));
   }
 
   ir.Primitive _buildInvokeDynamic(ir.Primitive receiver,
                                    Selector selector,
                                    List<ir.Primitive> arguments) {
     assert(isOpen);
@@ skipping 213 matching lines @@
         state.localConstants, defaults);
   }
 
   /// Create a super invocation where the method name and the argument structure
   /// are defined by [selector] and the argument values are defined by
   /// [arguments].
   ir.Primitive buildSuperInvocation(Element target,
                                     Selector selector,
                                     List<ir.Primitive> arguments);
 
-  /// Create a setter invocation on the super class where the setter name and
-  /// argument are defined by [selector] and [value], respectively.
-  void buildSuperSet(Element target, Selector selector, ir.Primitive value) {
+  /// Create a getter invocation of the [target] on the super class.
+  ir.Primitive buildSuperGet(Element target) {
+    Selector selector = new Selector.getter(target.name, target.library);
+    return buildSuperInvocation(target, selector, const <ir.Primitive>[]);
+  }
+
+  /// Create a setter invocation of the [target] on the super class of with
+  /// [value].
+  ir.Primitive buildSuperSet(Element target, ir.Primitive value) {
+    Selector selector = new Selector.setter(target.name, target.library);
     buildSuperInvocation(target, selector, [value]);
+    return value;
   }
 
   /// Create an index set invocation on the super class with the provided
   /// [index] and [value].
   ir.Primitive buildSuperIndexSet(Element target,
                                   ir.Primitive index,
                                   ir.Primitive value) {
     _buildInvokeSuper(target, new Selector.indexSet(),
         <ir.Primitive>[index, value]);
     return value;
@@ skipping 28 matching lines @@
   /// Create a dynamic index set invocation on [receiver] with the provided
   /// [index] and [value].
   ir.Primitive  buildDynamicIndexSet(ir.Primitive receiver,
                                      ir.Primitive index,
                                      ir.Primitive value) {
     _buildInvokeDynamic(
         receiver, new Selector.indexSet(), <ir.Primitive>[index, value]);
     return value;
   }
 
+  /// Create a read access of [local].
+  ir.Primitive buildLocalGet(LocalElement element);
+
+  /// Create a write access to [local] with the provided [value].
+  ir.Primitive buildLocalSet(LocalElement element, ir.Primitive value);
+
+  /// Create an invocation of the local [element] where argument structure is
+  /// defined by [selector] and the argument values are defined by [arguments].
+  ir.Primitive buildLocalInvocation(LocalElement element,
+                                    Selector selector,
+                                    List<ir.Primitive> arguments) {
+    return buildCallInvocation(buildLocalGet(element), selector, arguments);
+  }
+
   /// Create a static invocation of [element] where argument structure is
   /// defined by [selector] and the argument values are defined by [arguments].
   ir.Primitive buildStaticInvocation(Element element,
                                      Selector selector,
                                      List<ir.Primitive> arguments,
                                      {SourceInformation sourceInformation}) {
     return _buildInvokeStatic(element, selector, arguments, sourceInformation);
   }
 
   /// Create a static getter invocation of [element] where the getter name is
   /// defined by [selector].
   ir.Primitive buildStaticGet(Element element,
-                              Selector selector,
                               {SourceInformation sourceInformation}) {
-    assert(selector.isGetter);
+    Selector selector = new Selector.getter(element.name, element.library);
     // TODO(karlklose,sigurdm): build different nodes for getters.
     return _buildInvokeStatic(
         element, selector, const <ir.Primitive>[], sourceInformation);
   }
 
   /// Create a static setter invocation of [element] where the setter name and
   /// argument are defined by [selector] and [value], respectively.
   ir.Primitive buildStaticSet(Element element,
-                              Selector selector,
                               ir.Primitive value,
                               {SourceInformation sourceInformation}) {
-    assert(selector.isSetter);
+    Selector selector = new Selector.setter(element.name, element.library);
     // TODO(karlklose,sigurdm): build different nodes for setters.
     _buildInvokeStatic(
         element, selector, <ir.Primitive>[value], sourceInformation);
     return value;
   }
 
   /// Create a constructor invocation of [element] on [type] where the
   /// constructor name and argument structure are defined by [selector] and the
   /// argument values are defined by [arguments].
   ir.Primitive buildConstructorInvocation(FunctionElement element,
@@ skipping 354 matching lines @@
     }
 
     ir.Parameter currentValue = new ir.Parameter(null);
     ir.Continuation currentInvoked = new ir.Continuation([currentValue]);
     bodyBuilder.add(new ir.LetCont(currentInvoked,
         new ir.InvokeMethod(iterator, new Selector.getter("current", null),
             currentInvoked, emptyArguments)));
     if (Elements.isLocal(variableElement)) {
       bodyBuilder.buildLocalSet(variableElement, currentValue);
     } else if (Elements.isStaticOrTopLevel(variableElement)) {
-      bodyBuilder.buildStaticSet(
-          variableElement, variableSelector, currentValue);
+      bodyBuilder.buildStaticSet(variableElement, currentValue);
     } else {
       ir.Primitive receiver = bodyBuilder.buildThis();
       bodyBuilder.buildDynamicSet(receiver, variableSelector, currentValue);
     }
 
     buildBody(bodyBuilder);
     assert(state.breakCollectors.last == breakCollector);
     assert(state.continueCollectors.last == continueCollector);
     state.breakCollectors.removeLast();
     state.continueCollectors.removeLast();
@@ skipping 1255 matching lines @@
 // TODO(johnniwinther): Support passing of [DartType] for the exception.
 class CatchClauseInfo {
   final LocalVariableElement exceptionVariable;
   final LocalVariableElement stackTraceVariable;
   final SubbuildFunction buildCatchBlock;
 
   CatchClauseInfo({this.exceptionVariable,
                    this.stackTraceVariable,
                    this.buildCatchBlock});
 }