Make ?? a compile-time constant operator.

runtime/vm/parser.cc

 // 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.
 
 #include "vm/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED
 
 #include "lib/invocation_mirror.h"
@@ skipping 10534 matching lines @@
           BinaryOpNode* old = lhs->AsBinaryOpNode();
           BinaryOpWithMask32Node* binop = new(Z) BinaryOpWithMask32Node(
               old->token_pos(), old->kind(), old->left(), old->right(), val);
           return binop;
         }
       }
     }
   }
   if (binary_op == Token::kIFNULL) {
     // Handle a ?? b.
+    if (lhs->IsPotentiallyConst()) {

[hausner, 2015/12/02 18:29:37]

This is a bit more complicated.

You need to use lhs->EvalConstExpr() to determine whether the expression is a
compile-time const. If that returns non-NULL, use FoldConstExpr() to evaluate
the expression to get the actual value.

Also, background compilation has recently made all this more complex. The
optimizing compiler runs in another thread and must not evaluate dart code.
Thus, you probably have to cache the evaluated constant, similar to the code
used in, for example, ParseExternalInitializedField(). 
 

[Lasse Reichstein Nielsen, 2015/12/04 12:11:46]

Tried to do that.

Still doesn't work for const constructor initializer lists (but I guess there is
special code for that since it's only potentially constant).

+      // If we know at compile time whether the lhs is null
+      // and side-effect free, just reduce it to either the lhs or rhs.
+      // This enables ?? to be compile-time constant.
+      const Object* left_expr = lhs->EvalConstExpr();
+      if (left_expr != NULL) {
+        if (left_expr->IsNull()) return rhs;
+        return lhs;
+      }
+    }
+    // Otherwise create a temporary variable for the lhs so we can both
+    // check it against null and return it if necessary.
     LetNode* result = new(Z) LetNode(op_pos);
     LocalVariable* left_temp = result->AddInitializer(lhs);
     const intptr_t no_pos = Scanner::kNoSourcePos;
     LiteralNode* null_operand =
         new(Z) LiteralNode(no_pos, Instance::ZoneHandle(Z));
     LoadLocalNode* load_left_temp = new(Z) LoadLocalNode(no_pos, left_temp);
     ComparisonNode* null_compare =
         new(Z) ComparisonNode(no_pos,
                               Token::kNE_STRICT,
                               load_left_temp,
@@ skipping 3856 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED