Implementation of null-aware operators.

pkg/compiler/lib/src/tree/nodes.dart

 // Copyright (c) 2012, 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.
 
 part of tree;
 
 abstract class Visitor<R> {
   const Visitor();
 
   R visitNode(Node node);
@@ skipping 339 matching lines @@
  * A message send aka method invocation. In Dart, most operations can
  * (and should) be considered as message sends. Getters and setters
  * are just methods with a special syntax. Consequently, we model
  * property access, assignment, operators, and method calls with this
  * one node.
  */
 class Send extends Expression with StoredTreeElementMixin {
   final Node receiver;
   final Node selector;
   final NodeList argumentsNode;
+
+  /// Whether this is a conditinal send of the form `a?.b`.
+  final bool isConditional;
+
   Link<Node> get arguments => argumentsNode.nodes;
 
-  Send([this.receiver, this.selector, this.argumentsNode]);
-  Send.postfix(this.receiver, this.selector, [Node argument = null])
+  Send([this.receiver, this.selector, this.argumentsNode,
+      this.isConditional = false]);
+  Send.postfix(this.receiver, this.selector,
+      [Node argument = null, this.isConditional = false])
       : argumentsNode = (argument == null)
         ? new Postfix()
         : new Postfix.singleton(argument);
-  Send.prefix(this.receiver, this.selector, [Node argument = null])
+  Send.prefix(this.receiver, this.selector,
+      [Node argument = null, this.isConditional = false])
       : argumentsNode = (argument == null)
         ? new Prefix()
         : new Prefix.singleton(argument);
 
   Send asSend() => this;
 
   accept(Visitor visitor) => visitor.visitSend(this);
 
   visitChildren(Visitor visitor) {
     if (receiver != null) receiver.accept(visitor);
@@ skipping 13 matching lines @@
   bool get isFunctionObjectInvocation => selector == null;
   bool get isPrefix => argumentsNode is Prefix;
   bool get isPostfix => argumentsNode is Postfix;
   bool get isCall => !isOperator && !isPropertyAccess;
   bool get isIndex =>
       isOperator && identical(selector.asOperator().source, '[]');
   bool get isLogicalAnd =>
       isOperator && identical(selector.asOperator().source, '&&');
   bool get isLogicalOr =>
       isOperator && identical(selector.asOperator().source, '||');
+  bool get isIfNull =>
+      isOperator && identical(selector.asOperator().source, '??');
 
   bool get isTypeCast {
     return isOperator
         && identical(selector.asOperator().source, 'as');
   }
 
   bool get isTypeTest {
     return isOperator
         && identical(selector.asOperator().source, 'is');
   }
@@ skipping 23 matching lines @@
       return null;
     }
     if (!isPostfix && argumentsNode != null) {
       Token token = argumentsNode.getEndToken();
       if (token != null) return token;
     }
     if (selector != null) return selector.getEndToken();
     return getBeginToken();
   }
 
-  Send copyWithReceiver(Node newReceiver) {
+  Send copyWithReceiver(Node newReceiver, bool isConditional) {
     assert(receiver == null);
-    return new Send(newReceiver, selector, argumentsNode);
+    return new Send(newReceiver, selector, argumentsNode, isConditional);
   }
 }
 
 class Postfix extends NodeList {
   Postfix() : super(null, const Link<Node>());
   Postfix.singleton(Node argument) : super.singleton(argument);
 }
 
 class Prefix extends NodeList {
   Prefix() : super(null, const Link<Node>());
   Prefix.singleton(Node argument) : super.singleton(argument);
 }
 
 class SendSet extends Send {
   final Operator assignmentOperator;
-  SendSet(receiver, selector, this.assignmentOperator, argumentsNode)
-    : super(receiver, selector, argumentsNode);
+  SendSet(receiver, selector, this.assignmentOperator, argumentsNode,
+      [bool isConditional = false])
+    : super(receiver, selector, argumentsNode, isConditional);
   SendSet.postfix(receiver,
                   selector,
                   this.assignmentOperator,
-                  [Node argument = null])
-      : super.postfix(receiver, selector, argument);
+                  [Node argument = null, bool isConditional = false])
+      : super.postfix(receiver, selector, argument, isConditional);
   SendSet.prefix(receiver,
                  selector,
                  this.assignmentOperator,
-                 [Node argument = null])
-      : super.prefix(receiver, selector, argument);
+                 [Node argument = null, bool isConditional = false])
+      : super.prefix(receiver, selector, argument, isConditional);
 
   SendSet asSendSet() => this;
 
   accept(Visitor visitor) => visitor.visitSendSet(this);
 
+  /// Whether this is an if-null assignment of the form `a ??= b`.
+  bool get isIfNullAssignment =>
+      identical(assignmentOperator.source, '??=');
+
   visitChildren(Visitor visitor) {
     super.visitChildren(visitor);
     if (assignmentOperator != null) assignmentOperator.accept(visitor);
   }
 
-  Send copyWithReceiver(Node newReceiver) {
+  Send copyWithReceiver(Node newReceiver, bool isConditional) {
     assert(receiver == null);
     return new SendSet(newReceiver, selector, assignmentOperator,
-                       argumentsNode);
+                       argumentsNode, isConditional);
   }
 
   Token getBeginToken() {
     if (isPrefix) return assignmentOperator.getBeginToken();
     return super.getBeginToken();
   }
 
   Token getEndToken() {
     if (isPostfix) return assignmentOperator.getEndToken();
     return super.getEndToken();
@@ skipping 542 matching lines @@
   visitChildren(Visitor visitor) {}
 
   Token getBeginToken() => token;
 
   Token getEndToken() => token;
 }
 
 class Operator extends Identifier {
   static const COMPLEX_OPERATORS =
       const ["--", "++", '+=', "-=", "*=", "/=", "%=", "&=", "|=", "~/=", "^=",
-             ">>=", "<<="];
+             ">>=", "<<=", "??="];
 
   static const INCREMENT_OPERATORS = const <String>["++", "--"];
 
   Operator(Token token) : super(token);
 
   Operator asOperator() => this;
 
   accept(Visitor visitor) => visitor.visitOperator(this);
 }
 
@@ skipping 1182 matching lines @@
   Token getBeginToken() => token;
 
   Token getEndToken() => expression.getEndToken();
 }
 
 class Initializers {
   static bool isSuperConstructorCall(Send node) {
     return (node.receiver == null && node.selector.isSuper()) ||
            (node.receiver != null &&
             node.receiver.isSuper() &&
+            !node.isConditional &&
             node.selector.asIdentifier() != null);
   }
 
   static bool isConstructorRedirect(Send node) {
     return (node.receiver == null && node.selector.isThis()) ||
            (node.receiver != null &&
             node.receiver.isThis() &&
+            !node.isConditional &&
             node.selector.asIdentifier() != null);
   }
 }
 
 class GetDartStringVisitor extends Visitor<DartString> {
   const GetDartStringVisitor();
   DartString visitNode(Node node) => null;
   DartString visitStringJuxtaposition(StringJuxtaposition node)
       => node.dartString;
   DartString visitLiteralString(LiteralString node) => node.dartString;
@@ skipping 54 matching lines @@
 
   // VariableDefinitions.
   get metadata => null;
   get type => null;
 
   // Typedef.
   get typeParameters => null;
   get formals => null;
   get typedefKeyword => null;
 }