Add support for null-aware operators to the CPS-IR.

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/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
@@ skipping 2005 matching lines @@
 
   /// Creates a type test or type cast of [receiver] against [type].
   ///
   /// Set [isTypeTest] to `true` to create a type test and furthermore set
   /// [isNotCheck] to `true` to create a negated type test.
   ir.Primitive buildTypeOperator(ir.Primitive receiver,
                                  DartType type,
                                  {bool isTypeTest: false,
                                   bool isNotCheck: false});
 
+  /// Creates a type test checking whether [value] is null.
+  ir.Primitive buildChecknull(ir.Primitive value);
+
   /// Create a lazy and/or expression. [leftValue] is the value of the left
   /// operand and [buildRightValue] is called to process the value of the right
   /// operand in the context of its own [IrBuilder].
   ir.Primitive buildLogicalOperator(
       ir.Primitive leftValue,
       ir.Primitive buildRightValue(IrBuilder builder),
       {bool isLazyOr: false}) {
     // e0 && e1 is translated as if e0 ? (e1 == true) : false.
     // e0 || e1 is translated as if e0 ? true : (e1 == true).
     // The translation must convert both e0 and e1 to booleans and handle
@@ skipping 280 matching lines @@
                                  DartType type,
                                  {bool isTypeTest: false,
                                   bool isNotCheck: false}) {
     assert(isOpen);
     assert(isTypeTest != null);
     assert(!isNotCheck || isTypeTest);
     ir.Primitive check = _continueWithExpression(
             (k) => new ir.TypeOperator(receiver, type, k, isTypeTest: isTypeTest));
     return isNotCheck ? buildNegation(check) : check;
   }
+
+  @override
+  ir.Primitive buildCheckNull(ir.Primitive value) {

[Johnni Winther, 2015/05/29 10:23:24]

Move the implementation to IrBuilder.

[Siggi Cherem (dart-lang), 2015/05/29 18:14:05]

After addressing Kevin's comment, this moved just to the JsIrBuilder - the plain
IrBuilder declares the 2 operations, but the DartIrBuilder throws on both

+    assert(isOpen);
+    return addPrimitive(new ir.Identical(value, buildNullConstant()));

[Kevin Millikin (Google), 2015/05/29 11:02:03]

Identical is a 'JS specific' IR primitive, which means that it probably doesn't
work for dart2dart.  Either something will be unimplemented or we will hit an
assertion failure.

In dart2dart we would want to support .? and ?? in the output anyway, which
would either require supporting them directly in the CPS IR or desugaring them
and then recognizing them later.  Both of those choices are a lot of work.

Instead, just giveup in dart mode by throwing an informative string.

[Siggi Cherem (dart-lang), 2015/05/29 18:14:05]

Great points - I moved most of the implementation to the JsIrBuilder and made
the dart version throw.

[Siggi Cherem (dart-lang), 2015/05/29 19:02:02]

Just synced and noticed that DartIrBuilder is gone, nice!... I've kept the
implementation in the JsIrBuilder subclass for now though.

+  }
 }
 
 /// State shared between JsIrBuilders within the same function.
 ///
 /// Note that this is not shared between builders of nested functions.
 class JsIrBuilderSharedState {
   /// Maps boxed locals to their location. These locals are not part of
   /// the environment.
   final Map<Local, ClosureLocation> boxedVariables = {};
 
@@ skipping 352 matching lines @@
     assert(isTypeTest != null);
     assert(!isNotCheck || isTypeTest);
     ir.Primitive interceptor =
         addPrimitive(new ir.Interceptor(receiver, program.interceptedClasses));
     ir.Primitive check = _continueWithExpression(
             (k) => new ir.TypeOperator(interceptor, type, k,
                                        isTypeTest: isTypeTest));
     return isNotCheck ? buildNegation(check) : check;
   }
 
+  @override
+  ir.Primitive buildCheckNull(ir.Primitive value) {

[Johnni Winther, 2015/05/29 10:23:24]

Remove this.

[Siggi Cherem (dart-lang), 2015/05/29 18:14:05]

Acknowledged.

+    assert(isOpen);
+    return addPrimitive(new ir.Identical(value, buildNullConstant()));

[Kevin Millikin (Google), 2015/05/29 11:02:03]

This is completely safe, but since buildNullConstant() has the side effect of
emitting part of a CPS term, I normally write:

ir.Primitive right = buildNullConstant();
return addPrimitive(new ir.Identical(value, right));

[Siggi Cherem (dart-lang), 2015/05/29 18:14:05]

Done.

+  }
 }
 
 
 /// Location of a variable relative to a given closure.
 class ClosureLocation {
   /// If not `null`, this location is [box].[field].
   /// The location of [box] can be obtained separately from an
   /// enclosing [ClosureEnvironment] or [ClosureScope].
   /// If `null`, then the location is [field] on the enclosing function object.
   final BoxLocal box;
@@ skipping 61 matching lines @@
 }
 
 /// Synthetic parameter to a JavaScript factory method that takes the type
 /// argument given for the type variable [variable].
 class TypeInformationParameter implements Local {
   final TypeVariableElement variable;
   final ExecutableElement executableContext;
   TypeInformationParameter(this.variable, this.executableContext);
   String get name => variable.name;
 }