Split TypedSelector into Selector and TypeMask.

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 '../compile_time_constants.dart' show BackendConstantEnvironment;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart' show ConstantValue, PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
 import '../tree/tree.dart' as ast;
+import '../types/types.dart' show TypeMask;
 import '../closure.dart' hide ClosureScope;
 import '../universe/universe.dart' show SelectorKind;
 import 'cps_ir_nodes.dart' as ir;
 import 'cps_ir_builder_task.dart' show DartCapturedVariables,
     GlobalProgramInformation;
 
 /// A mapping from variable elements to their compile-time values.
 ///
 /// Map elements denoted by parameters and local variables to the
 /// [ir.Primitive] that is their value.  Parameters and locals are
@@ skipping 620 matching lines @@
                                  List<ir.Primitive> arguments) {
     assert(target.isInstanceMember);
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.InvokeMethodDirectly(
             buildThis(), target, selector, arguments, k));
   }
 
   ir.Primitive _buildInvokeDynamic(ir.Primitive receiver,
                                    Selector selector,
+                                   TypeMask mask,
                                    List<ir.Primitive> arguments,
                                    {SourceInformation sourceInformation}) {
     assert(isOpen);
     return _continueWithExpression(
-        (k) => new ir.InvokeMethod(receiver, selector, arguments, k,
+        (k) => new ir.InvokeMethod(receiver, selector, mask, arguments, k,
             sourceInformation: sourceInformation));
   }
 
   ir.Primitive _buildInvokeCall(ir.Primitive target,
                                 CallStructure callStructure,
+                                TypeMask mask,
                                 List<ir.Definition> arguments,
                                 {SourceInformation sourceInformation}) {
     Selector selector = callStructure.callSelector;
-    return _buildInvokeDynamic(target, selector, arguments,
+    return _buildInvokeDynamic(target, selector, mask, arguments,
         sourceInformation: sourceInformation);
   }
 
 
   /// Create a [ir.Constant] from [constant] and add it to the CPS term.
   // TODO(johnniwinther): Remove [value] when [ConstantValue] can be computed
   // directly from [constant].
   ir.Constant buildConstant(ConstantExpression constant, ConstantValue value) {
     assert(isOpen);
     return addPrimitive(new ir.Constant(constant, value));
@@ skipping 234 matching lines @@
     _buildInvokeSuper(method, new Selector.indexSet(),
         <ir.Primitive>[index, value]);
     return value;
   }
 
   /// Create a dynamic invocation on [receiver] where the method name and
   /// argument structure are defined by [selector] and the argument values are
   /// defined by [arguments].
   ir.Primitive buildDynamicInvocation(ir.Primitive receiver,
                                       Selector selector,
+                                      TypeMask mask,
                                       List<ir.Primitive> arguments) {
-    return _buildInvokeDynamic(receiver, selector, arguments);
+    return _buildInvokeDynamic(receiver, selector, mask, arguments);
   }
 
   /// Create an if-null expression. This is equivalent to a conditional
   /// expression whose result is either [value] if [value] is not null, or
   /// `right` if [value] is null. Only when [value] is null, [buildRight] is
   /// evaluated to produce the `right` value.
   ir.Primitive buildIfNull(ir.Primitive value,
                            ir.Primitive buildRight(IrBuilder builder));
 
   /// Create a conditional send. This is equivalent to a conditional expression
   /// that checks if [receiver] is null, if so, it returns null, otherwise it
   /// evaluates the [buildSend] expression.
   ir.Primitive buildIfNotNullSend(ir.Primitive receiver,
                                   ir.Primitive buildSend(IrBuilder builder));
 
   /// Create a dynamic getter invocation on [receiver] where the getter name is
   /// defined by [selector].
-  ir.Primitive buildDynamicGet(ir.Primitive receiver, Selector selector) {
+  ir.Primitive buildDynamicGet(ir.Primitive receiver,
+                               Selector selector,
+                               TypeMask mask) {
     assert(selector.isGetter);
-    return _buildInvokeDynamic(receiver, selector, const <ir.Primitive>[]);
+    return _buildInvokeDynamic(
+        receiver, selector, mask, const <ir.Primitive>[]);
   }
 
   /// Create a dynamic setter invocation on [receiver] where the setter name and
   /// argument are defined by [selector] and [value], respectively.
   ir.Primitive buildDynamicSet(ir.Primitive receiver,
                                Selector selector,
+                               TypeMask mask,
                                ir.Primitive value) {
     assert(selector.isSetter);
-    _buildInvokeDynamic(receiver, selector, <ir.Primitive>[value]);
+    _buildInvokeDynamic(receiver, selector, mask, <ir.Primitive>[value]);
     return value;
   }
 
   /// Create a dynamic index set invocation on [receiver] with the provided
   /// [index] and [value].
   ir.Primitive  buildDynamicIndexSet(ir.Primitive receiver,
+                                     TypeMask mask,
                                      ir.Primitive index,
                                      ir.Primitive value) {
     _buildInvokeDynamic(
-        receiver, new Selector.indexSet(), <ir.Primitive>[index, value]);
+        receiver, new Selector.indexSet(), mask, <ir.Primitive>[index, value]);
     return value;
   }
 
   ir.Primitive _buildLocalGet(LocalElement element);
 
   /// Create a read access of the [local] variable or parameter.
   ir.Primitive buildLocalVariableGet(LocalElement local) {
     // TODO(johnniwinther): Separate function access from variable access.
     return _buildLocalGet(local);
   }
@@ skipping 113 matching lines @@
 
   /// Create a string concatenation of the [arguments].
   ir.Primitive buildStringConcatenation(List<ir.Primitive> arguments) {
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.ConcatenateStrings(arguments, k));
   }
 
   /// Create an invocation of the `call` method of [functionExpression], where
   /// the structure of arguments are given by [callStructure].
+  // TODO(johnniwinther): This should take a [TypeMask].
   ir.Primitive buildCallInvocation(
       ir.Primitive functionExpression,
       CallStructure callStructure,
       List<ir.Definition> arguments,
       {SourceInformation sourceInformation}) {
-    return _buildInvokeCall(functionExpression, callStructure, arguments,
+    return _buildInvokeCall(functionExpression, callStructure, null, arguments,
         sourceInformation: sourceInformation);
   }
 
   /// Creates an if-then-else statement with the provided [condition] where the
   /// then and else branches are created through the [buildThenPart] and
   /// [buildElsePart] functions, respectively.
   ///
   /// An if-then statement is created if [buildElsePart] is a no-op.
   // TODO(johnniwinther): Unify implementation with [buildConditional] and
   // [_buildLogicalOperator].
@@ skipping 230 matching lines @@
   ///        variable element, and [variableSelector] defines its write access,
   ///     3) `v` is an instance variable in which case [variableSelector]
   ///        defines its write access.
   /// [buildBody] creates the body, `b`, of the loop. The jump [target] is used
   /// to identify which `break` and `continue` statements that have this for-in
   /// statement as their target.
   void buildForIn({SubbuildFunction buildExpression,
                    SubbuildFunction buildVariableDeclaration,
                    Element variableElement,
                    Selector variableSelector,
+                   TypeMask variableMask,
+                   TypeMask currentMask,
+                   TypeMask iteratorMask,
+                   TypeMask moveNextMask,
                    SubbuildFunction buildBody,
                    JumpTarget target,
                    ClosureScope closureScope}) {
     // The for-in loop
     //
     // for (a in e) s;
     //
     // Is compiled analogously to:
     //
     // it = e.iterator;
     // while (it.moveNext()) {
     //   var a = it.current;
     //   s;
     // }
 
     // Fill the current hole with:
     // let prim expressionReceiver = [[e]] in
     // let cont iteratorInvoked(iterator) =
     //     [ ]
     // in expressionReceiver.iterator () iteratorInvoked
     ir.Primitive expressionReceiver = buildExpression(this);
     List<ir.Primitive> emptyArguments = <ir.Primitive>[];
     ir.Parameter iterator = new ir.Parameter(null);
     ir.Continuation iteratorInvoked = new ir.Continuation([iterator]);
     add(new ir.LetCont(iteratorInvoked,
         new ir.InvokeMethod(expressionReceiver,
             new Selector.getter("iterator", null),
+            iteratorMask,
             emptyArguments,
             iteratorInvoked)));
 
     // Fill with:
     // let cont loop(x, ...) =
     //     let cont moveNextInvoked(condition) =
     //         [ ]
     //     in iterator.moveNext () moveNextInvoked
     // in loop(v, ...)
     JumpCollector loop = new BackwardJumpCollector(environment, target: target);
     addRecursiveContinuation(loop);
     ir.Parameter condition = new ir.Parameter(null);
     ir.Continuation moveNextInvoked = new ir.Continuation([condition]);
     add(new ir.LetCont(moveNextInvoked,
         new ir.InvokeMethod(iterator,
             new Selector.call("moveNext", null, 0),
+            moveNextMask,
             emptyArguments,
             moveNextInvoked)));
 
     // As a delimited term, build:
     // <<BODY>> =
     //   _enterScope();
     //   [[variableDeclaration]]
     //   let cont currentInvoked(currentValue) =
     //       [[a = currentValue]];
     //       [ ]
     //   in iterator.current () currentInvoked
     IrBuilder bodyBuilder = makeDelimitedBuilder();
     bodyBuilder._enterScope(closureScope);
     if (buildVariableDeclaration != null) {
       buildVariableDeclaration(bodyBuilder);
     }
     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),
+        new ir.InvokeMethod(
+            iterator,
+            new Selector.getter("current", null),
+            currentMask,
             emptyArguments, currentInvoked)));
     // TODO(sra): Does this cover all cases? The general setter case include
     // super.
     // TODO(johnniwinther): Extract this as a provided strategy.
     if (Elements.isLocal(variableElement)) {
       bodyBuilder.buildLocalVariableSet(variableElement, currentValue);
     } else if (Elements.isErroneous(variableElement)) {
       bodyBuilder.buildErroneousInvocation(variableElement,
           new Selector.setter(variableElement.name, variableElement.library),
           <ir.Primitive>[currentValue]);
     } else if (Elements.isStaticOrTopLevel(variableElement)) {
       if (variableElement.isField) {
         bodyBuilder.buildStaticFieldSet(variableElement, currentValue);
       } else {
         bodyBuilder.buildStaticSetterSet(variableElement, currentValue);
       }
     } else {
       ir.Primitive receiver = bodyBuilder.buildThis();
       assert(receiver != null);
-      bodyBuilder.buildDynamicSet(receiver, variableSelector, currentValue);
+      bodyBuilder.buildDynamicSet(
+          receiver, variableSelector, variableMask, currentValue);
     }
 
     // Translate the body in the hole in the delimited term above, and add
     // a jump to the loop if control flow is live after the body.
     JumpCollector breakCollector =
         new ForwardJumpCollector(environment, target: target);
     state.breakCollectors.add(breakCollector);
     state.continueCollectors.add(loop);
     buildBody(bodyBuilder);
     assert(state.breakCollectors.last == breakCollector);
@@ skipping 1077 matching lines @@
   final DartType type;
   final LocalVariableElement exceptionVariable;
   final LocalVariableElement stackTraceVariable;
   final SubbuildFunction buildCatchBlock;
 
   CatchClauseInfo({this.type,
                    this.exceptionVariable,
                    this.stackTraceVariable,
                    this.buildCatchBlock});
 }