Implement ?? as compile-time constant in VM.

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 10484 matching lines @@
               old->token_pos(), old->kind(), old->left(), old->right(), val);
           return binop;
         }
       }
     }
   }
   if (binary_op == Token::kIFNULL) {
     // Handle a ?? b.
     LetNode* result = new(Z) LetNode(op_pos);
     LocalVariable* left_temp = result->AddInitializer(lhs);
+    left_temp->set_is_final();
+    if ((lhs->IsPotentiallyConst()) && (lhs->EvalConstExpr() != NULL)) {

[hausner, 2016/01/12 20:46:47]

The first test, IsPotentiallyConst(), is not needed. That check is only used in
constructor initializer expressions. It is essentially a much more permissive
version of EvalConstExpr().

[hausner, 2016/01/12 21:48:35]

On second thought: you also need to check that rhs is a constant expression.

If both sides are constants, would it not make more sense to evaluate the lhs ??
rhs expression right here and cache the result, rather than the rhs value? The
return value from this branch would then be a LiteralNode with the calculated
(or cache-retrieved) value.

[Lasse Reichstein Nielsen, 2016/01/13 13:40:35]

Done. 
I still set left_temp to final below because that is necessary to handle the
potentially constant expressions correctly (they are not both constant here, but
will eventually be when invoked with "const").

+      Instance& expr_value = Instance::ZoneHandle(Z);
+      intptr_t lhs_pos = lhs->token_pos();
+      if (!GetCachedConstant(lhs_pos, &expr_value)) {
+        expr_value = EvaluateConstExpr(lhs_pos, lhs).raw();
+        CacheConstantValue(lhs_pos, expr_value);
+      }
+      left_temp->SetConstValue(expr_value);
+    }
     const intptr_t no_pos = Scanner::kNoSourcePos;
     LiteralNode* null_operand =
         new(Z) LiteralNode(no_pos, Object::null_instance());
     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,
                               null_operand);
     result->AddNode(new(Z) ConditionalExprNode(op_pos,
@@ skipping 3871 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED