Implementation of null-aware operators.

pkg/compiler/lib/src/resolution/send_structure.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.send_structure;
 
 import 'access_semantics.dart';
 import 'operators.dart';
 import 'semantic_visitor.dart';
 import '../dart_types.dart';
@@ skipping 41 matching lines @@
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.errorInvalidAssert(
         node,
         node.argumentsNode,
         arg);
   }
 
   String toString() => 'invalid assert';
 }
 
+/// The structure for a [Send] of the form `a ?? b`.
+class IfNullStructure<R, A> implements SendStructure<R, A> {
+  const IfNullStructure();
+
+  R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
+    return visitor.visitIfNull(
+        node,
+        node.receiver,
+        node.arguments.single,
+        arg);
+  }
+
+  String toString() => '??';
+}
+
 /// The structure for a [Send] of the form `a && b`.
 class LogicalAndStructure<R, A> implements SendStructure<R, A> {
   const LogicalAndStructure();
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitLogicalAnd(
         node,
         node.receiver,
         node.arguments.single,
         arg);
@@ skipping 82 matching lines @@
 
   /// The [CallStructure] of the invocation.
   // TODO(johnniwinther): Store this directly for static invocations.
   CallStructure get callStructure => selector.callStructure;
 
   InvokeStructure(this.semantics, this.selector);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
+        if (node.isConditional) {
+          return visitor.visitIfNotNullDynamicPropertyInvoke(
+              node,
+              node.receiver,
+              node.argumentsNode,
+              selector,
+              arg);
+        }
         return visitor.visitDynamicPropertyInvoke(
             node,
             node.receiver,
             node.argumentsNode,
             selector,
             arg);
       case AccessKind.LOCAL_FUNCTION:
         return visitor.visitLocalFunctionInvoke(
             node,
             semantics.element,
@@ skipping 243 matching lines @@
   final AccessSemantics semantics;
 
   /// The [Selector] for the getter invocation.
   final Selector selector;
 
   GetStructure(this.semantics, this.selector);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
+        if (node.isConditional) {
+          return visitor.visitIfNotNullDynamicPropertyGet(
+              node,
+              node.receiver,
+              selector,
+              arg);
+        }
         return visitor.visitDynamicPropertyGet(
             node,
             node.receiver,
             selector,
             arg);
       case AccessKind.LOCAL_FUNCTION:
         return visitor.visitLocalFunctionGet(
             node,
             semantics.element,
             arg);
@@ skipping 134 matching lines @@
   final AccessSemantics semantics;
 
   /// The [Selector] for the setter invocation.
   final Selector selector;
 
   SetStructure(this.semantics, this.selector);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
-          return visitor.visitDynamicPropertySet(
+        if (node.isConditional) {
+          return visitor.visitIfNotNullDynamicPropertySet(
             node,
             node.receiver,
             selector,
             node.arguments.single,
             arg);
+        }
+        return visitor.visitDynamicPropertySet(
+          node,
+          node.receiver,
+          selector,
+          node.arguments.single,
+          arg);
       case AccessKind.LOCAL_FUNCTION:
         return visitor.visitLocalFunctionSet(
             node,
             semantics.element,
             node.arguments.single,
             arg);
       case AccessKind.LOCAL_VARIABLE:
         return visitor.visitLocalVariableSet(
             node,
             semantics.element,
@@ skipping 653 matching lines @@
   final Selector setterSelector;
 
   CompoundStructure(this.semantics,
                     this.operator,
                     this.getterSelector,
                     this.setterSelector);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
+        if (node.isConditional) {
+          return visitor.visitIfNotNullDynamicPropertyCompound(
+              node,
+              node.receiver,
+              operator,
+              node.arguments.single,
+              getterSelector,
+              setterSelector,
+              arg);
+        }
         return visitor.visitDynamicPropertyCompound(
             node,
             node.receiver,
             operator,
             node.arguments.single,
             getterSelector,
             setterSelector,
             arg);
       case AccessKind.LOCAL_FUNCTION:
         return visitor.visitLocalFunctionCompound(
@@ skipping 397 matching lines @@
   final Selector setterSelector;
 
   PrefixStructure(this.semantics,
                   this.operator,
                   this.getterSelector,
                   this.setterSelector);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
+        if (node.isConditional) {
+          return visitor.visitIfNotNullDynamicPropertyPrefix(
+              node,
+              node.receiver,
+              operator,
+              getterSelector,
+              setterSelector,
+              arg);
+        }
         return visitor.visitDynamicPropertyPrefix(
             node,
             node.receiver,
             operator,
             getterSelector,
             setterSelector,
             arg);
       case AccessKind.LOCAL_FUNCTION:
         return visitor.visitLocalFunctionPrefix(
             node,
@@ skipping 288 matching lines @@
   final Selector setterSelector;
 
   PostfixStructure(this.semantics,
                    this.operator,
                    this.getterSelector,
                    this.setterSelector);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
+        if (node.isConditional) {
+          return visitor.visitIfNotNullDynamicPropertyPostfix(
+              node,
+              node.receiver,
+              operator,
+              getterSelector,
+              setterSelector,
+              arg);
+        }
         return visitor.visitDynamicPropertyPostfix(
             node,
             node.receiver,
             operator,
             getterSelector,
             setterSelector,
             arg);
       case AccessKind.LOCAL_FUNCTION:
         return visitor.visitLocalFunctionPostfix(
             node,
@@ skipping 535 matching lines @@
   final ConstructorElement constructor;
   final Selector selector;
 
   ThisConstructorInvokeStructure(this.constructor, this.selector);
 
   R dispatch(SemanticDeclarationVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitThisConstructorInvoke(
         node, constructor, node.argumentsNode, selector, arg);
   }
 }