Fine-grain field, getter, setter, and function access in IrBuilder.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
@@ skipping 247 matching lines @@
 }
 
 /// Invoke a method, operator, getter, setter, or index getter/setter.
 /// Converting a method to a function object is treated as a getter invocation.
 class InvokeMethod extends Expression implements Invoke {
   Reference<Primitive> receiver;
   Selector selector;
   CallingConvention callingConvention;
   final Reference<Continuation> continuation;
   final List<Reference<Primitive>> arguments;
+  final SourceInformation sourceInformation;
 
   InvokeMethod(Primitive receiver,
                Selector selector,
                Continuation continuation,
-               List<Primitive> arguments)
+               List<Primitive> arguments,
+               {SourceInformation sourceInformation})
       : this.internal(new Reference<Primitive>(receiver),
                       selector,
                       new Reference<Continuation>(continuation),
-                      _referenceList(arguments));
+                      _referenceList(arguments),
+                      sourceInformation);
 
   InvokeMethod.internal(this.receiver,
                         this.selector,
                         this.continuation,
                         this.arguments,
+                        this.sourceInformation,
                         [this.callingConvention = CallingConvention.DART]) {
     assert(isValid);
   }
 
   /// Returns whether the arguments match the selector under the given calling
   /// convention.
   ///
   /// This check is designed to be used in an assert, as it also checks that the
   /// selector, arguments, and calling convention have meaningful values.
   bool get isValid {
@@ skipping 964 matching lines @@
     processReference(node.target);
   }
 
   processTypeExpression(TypeExpression node) {}
   @override
   visitTypeExpression(TypeExpression node) {
     processTypeExpression(node);
     node.arguments.forEach(processReference);
   }
 }