Implementation of null-aware operators.

pkg/compiler/lib/src/resolution/operators.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.operators;
 
 import '../elements/elements.dart';
 
 enum UnaryOperatorKind {
   NOT,
@@ skipping 48 matching lines @@
   SHR,
   GTEQ,
   GT,
   LTEQ,
   LT,
   AND,
   OR,
   XOR,
   LOGICAL_AND,
   LOGICAL_OR,
+  IF_NULL,
 }
 
 class BinaryOperator {
   final BinaryOperatorKind kind;
   final String name;
 
   const BinaryOperator._(this.kind, this.name);
 
   /// `true` if this operator can be implemented through an `operator [name]`
   /// method.
@@ skipping 75 matching lines @@
       const BinaryOperator._(BinaryOperatorKind.XOR, '^');
 
   /// The logical && operator.
   static const BinaryOperator LOGICAL_AND =
       const _LogicalOperator(BinaryOperatorKind.LOGICAL_AND, '&&');
 
   /// The binary | operator.
   static const BinaryOperator LOGICAL_OR =
       const _LogicalOperator(BinaryOperatorKind.LOGICAL_OR, '||');
 
+  /// The if-null ?? operator.
+  static const BinaryOperator IF_NULL =
+      const _LogicalOperator(BinaryOperatorKind.IF_NULL, '??');
+
   static BinaryOperator parse(String value) {
     switch (value) {
       case '==': return EQ;
       case '!=': return NOT_EQ;
       case '[]': return INDEX;
       case '*': return MUL;
       case '/': return DIV;
       case '%': return MOD;
       case '~/': return IDIV;
       case '+': return ADD;
       case '-': return SUB;
       case '<<': return SHL;
       case '>>': return SHR;
       case '>=': return GTEQ;
       case '>': return GT;
       case '<=': return LTEQ;
       case '<': return LT;
       case '&': return AND;
       case '^': return XOR;
       case '|': return OR;
       case '&&': return LOGICAL_AND;
       case '||': return LOGICAL_OR;
+      case '??': return IF_NULL;
       default: return null;
     }
   }
 }
 
 /// The operator !=, which is not user definable operator but instead is a
 /// negation of a call to user definable operator, namely ==.
 class _NotEqualsOperator extends BinaryOperator {
   const _NotEqualsOperator() : super._(BinaryOperatorKind.NOT_EQ, '!=');
 
   bool get isUserDefinable => false;
 
   String get selectorName => '==';
 }
 
 /// The operators && and || which are not user definable operators but control
 /// structures.
 class _LogicalOperator extends BinaryOperator {
   const _LogicalOperator(BinaryOperatorKind kind, String name)
       : super._(kind, name);
 
   bool get isUserDefinable => false;
 
   String get selectorName => null;
 }
 
 enum AssignmentOperatorKind {
   ASSIGN,
+  IF_NULL,
   ADD,
   SUB,
   MUL,
   DIV,
   IDIV,
   MOD,
   SHL,
   SHR,
   AND,
   OR,
@@ skipping 13 matching lines @@
     return binaryOperator != null ? binaryOperator.selectorName: null;
   }
 
   String toString() => name;
 
   /// The = operator.
   static const AssignmentOperator ASSIGN =
       const AssignmentOperator._(AssignmentOperatorKind.ASSIGN, '=',
                                  null, isUserDefinable: false);
 
+  /// The ??= operator.
+  static const AssignmentOperator IF_NULL =
+      const AssignmentOperator._(AssignmentOperatorKind.IF_NULL, '??=',
+                                 BinaryOperator.IF_NULL,
+                                 isUserDefinable: false);
+
   /// The += assignment operator.
   static const AssignmentOperator ADD =
       const AssignmentOperator._(AssignmentOperatorKind.ADD, '+=',
                                  BinaryOperator.ADD);
 
   /// The -= assignment operator.
   static const AssignmentOperator SUB =
       const AssignmentOperator._(AssignmentOperatorKind.SUB, '-=',
                                  BinaryOperator.SUB);
 
@@ skipping 38 matching lines @@
                                  BinaryOperator.OR);
 
   /// The ^= assignment operator.
   static const AssignmentOperator XOR =
       const AssignmentOperator._(AssignmentOperatorKind.XOR, '^=',
                                  BinaryOperator.XOR);
 
   static AssignmentOperator parse(String value) {
     switch (value) {
       case '=': return ASSIGN;
+      case '??=': return IF_NULL;
       case '*=': return MUL;
       case '/=': return DIV;
       case '%=': return MOD;
       case '~/=': return IDIV;
       case '+=': return ADD;
       case '-=': return SUB;
       case '<<=': return SHL;
       case '>>=': return SHR;
       case '&=': return AND;
       case '^=': return XOR;
@@ skipping 27 matching lines @@
   static const IncDecOperator DEC =
       const IncDecOperator._(IncDecOperatorKind.DEC, '--', BinaryOperator.SUB);
 
   static IncDecOperator parse(String value) {
     switch (value) {
       case '++': return INC;
       case '--': return DEC;
       default: return null;
     }
   }
-}
+}