Implementation of null-aware operators.

pkg/compiler/lib/src/typechecker.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 dart2js;
 
 class TypeCheckerTask extends CompilerTask {
   TypeCheckerTask(Compiler compiler) : super(compiler);
   String get name => "Type checker";
 
@@ skipping 1219 matching lines @@
 
         reshowTypePromotions(node, receiver, argument);
 
         checkAssignable(argument, argumentType, boolType);
         return boolType;
       } else if (identical(name, '!')) {
         checkAssignable(receiver, receiverType, boolType);
         return boolType;
       } else if (identical(name, '?')) {
         return boolType;
+      } else if (identical(name, '??')) {
+        final Node argument = node.arguments.head;
+        final DartType argumentType = analyze(argument);
+        return types.computeLeastUpperBound(receiverType, argumentType);
       }
       String operatorName = selector.source;
       if (identical(name, '-') && node.arguments.isEmpty) {
         operatorName = 'unary-';
       }
       assert(invariant(node,
                        identical(name, '+') || identical(name, '=') ||
                        identical(name, '-') || identical(name, '*') ||
                        identical(name, '/') || identical(name, '%') ||
                        identical(name, '~/') || identical(name, '|') ||
@@ skipping 148 matching lines @@
         return node.isPostfix ? element : result;
       }
     }
     return const DynamicType();
   }
 
   visitSendSet(SendSet node) {
     Element element = elements[node];
     Identifier selector = node.selector;
     final name = node.assignmentOperator.source;
-    if (identical(name, '=')) {
+    if (identical(name, '=') || identical(name, '??=')) {
       // e1 = value
       if (node.isIndex) {
          // base[key] = value
         final DartType base = analyze(node.receiver);
         final Node keyNode = node.arguments.head;
         final DartType key = analyze(keyNode);
         final Node valueNode = node.arguments.tail.head;
         final DartType value = analyze(valueNode);
         DartType indexSet = lookupMemberType(
             node, base, '[]=', MemberKind.OPERATOR);
+        DartType indexSetValue = const DynamicType();
         if (indexSet is FunctionType) {
           FunctionType indexSetType = indexSet;
           DartType indexSetKey = firstType(indexSetType.parameterTypes);
           checkAssignable(keyNode, key, indexSetKey);
-          DartType indexSetValue = secondType(indexSetType.parameterTypes);
+          indexSetValue = secondType(indexSetType.parameterTypes);
           checkAssignable(node.assignmentOperator, value, indexSetValue);
         }
-        return value;
+        return identical(name, '=') ? value
+            : types.computeLeastUpperBound(value, indexSetValue);
       } else {
         // target = value
         DartType target;
         if (analyzingInitializer) {
           // Field declaration `Foo target = value;` or initializer
           // `this.target = value`. Lookup the getter `target` in the class
           // members.
           target = computeAccessType(node, selector.source, element,
               MemberKind.GETTER, lookupClassMember: true);
         } else {
           // Normal assignment `target = value`.
           target = computeAccessType(
               node, selector.source, element, MemberKind.SETTER);
         }
         final Node valueNode = node.arguments.head;
         final DartType value = analyze(valueNode);
         checkAssignable(node.assignmentOperator, value, target);
-        return value;
+        return identical(name, '=') ? value
+            : types.computeLeastUpperBound(value, target);
       }
     } else if (identical(name, '++') || identical(name, '--')) {
       // e++ or e--
       String operatorName = identical(name, '++') ? '+' : '-';
       if (node.isIndex) {
         // base[key]++, base[key]--, ++base[key], or --base[key]
         return checkIndexAssignmentOperator(
             node, operatorName, node.assignmentOperator, intType);
       } else {
         // target++, target--, ++target, or --target
@@ skipping 400 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     compiler.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }