Implementation of null-aware operators.

pkg/compiler/lib/src/elements/elements.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.
 
 library elements;
 
 
 import '../constants/expressions.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
@@ skipping 514 matching lines @@
   static bool isNativeOrExtendsNative(ClassElement element) {
     if (element == null) return false;
     if (element.isNative) return true;
     assert(element.resolutionState == STATE_DONE);
     return isNativeOrExtendsNative(element.superclass);
   }
 
   static bool isInstanceSend(Send send, TreeElements elements) {
     Element element = elements[send];
     if (element == null) return !isClosureSend(send, element);
-    return isInstanceMethod(element) || isInstanceField(element);
+    return isInstanceMethod(element) || isInstanceField(element)
+      || send.isConditional;

[Siggi Cherem (dart-lang), 2015/05/22 03:50:49]

this is because `A?.foo` is equivalent to `(A).foo`

[Johnni Winther, 2015/05/22 12:39:48]

Ack. Format like this:

return isInstanceMethod(element) || 
       isInstanceField(element) || 
       send.isConditional;

[Siggi Cherem (dart-lang), 2015/05/22 19:49:54]

Done.

   }
 
   static bool isClosureSend(Send send, Element element) {
     if (send.isPropertyAccess) return false;
     if (send.receiver != null) return false;
     Node selector = send.selector;
     // this().
     if (selector.isThis()) return true;
     // (o)() or foo()().
     if (element == null && selector.asIdentifier() == null) return true;
@@ skipping 87 matching lines @@
     } else if (identical(name, 'unary-')) {
       return r'operator$negate';
     } else {
       return name;
     }
   }
 
   static String constructOperatorNameOrNull(String op, bool isUnary) {
     if (isMinusOperator(op)) {
       return isUnary ? 'unary-' : op;
-    } else if (isUserDefinableOperator(op)) {
+    } else if (isUserDefinableOperator(op) || op == '??') {
       return op;
     } else {
       return null;
     }
   }
 
   static String constructOperatorName(String op, bool isUnary) {
     String operatorName = constructOperatorNameOrNull(op, isUnary);
     if (operatorName == null) throw 'Unhandled operator: $op';
     else return operatorName;
   }
 
   static String mapToUserOperatorOrNull(String op) {
     if (identical(op, '!=')) return '==';
     if (identical(op, '*=')) return '*';
     if (identical(op, '/=')) return '/';
     if (identical(op, '%=')) return '%';
     if (identical(op, '~/=')) return '~/';
     if (identical(op, '+=')) return '+';
     if (identical(op, '-=')) return '-';
     if (identical(op, '<<=')) return '<<';
     if (identical(op, '>>=')) return '>>';
     if (identical(op, '&=')) return '&';
     if (identical(op, '^=')) return '^';
     if (identical(op, '|=')) return '|';
+    if (identical(op, '??=')) return '??';
 
     return null;
   }
 
   static String mapToUserOperator(String op) {
     String userOperator = mapToUserOperatorOrNull(op);
     if (userOperator == null) throw 'Unhandled operator: $op';
     else return userOperator;
   }
 
@@ skipping 967 matching lines @@
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }