Implement ?? as compile-time constant in VM.

runtime/vm/parser.cc

Index: runtime/vm/parser.cc
diff --git a/runtime/vm/parser.cc b/runtime/vm/parser.cc
index 28777b271e0e835818d86f2bf029a6b8c9c47c75..dad1bc226edce0ae74673560adfac76184cd88f0 100644
--- a/runtime/vm/parser.cc
+++ b/runtime/vm/parser.cc
@@ -10502,6 +10502,16 @@ AstNode* Parser::OptimizeBinaryOpNode(intptr_t op_pos,
     // 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());