Handle ?? in Constantifier

pkg/compiler/lib/src/kernel/ir_element_map.dart

 // Copyright (c) 2017, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
@@ skipping 701 matching lines @@
     BinaryOperator operator = BinaryOperator.parse(node.operator);
     if (operator != null) {
       ConstantExpression left = visit(node.left);
       ConstantExpression right = visit(node.right);
       return new BinaryConstantExpression(left, operator, right);
     }
     throw new UnimplementedError(
         'Unexpected constant expression $node (${node.runtimeType})');
   }
 
+  @override
+  ConstantExpression visitLet(ir.Let node) {
+    if (node.body is ir.ConditionalExpression) {
+      ir.ConditionalExpression conditional = node.body;

[sra1, 2017/05/08 15:58:52]

The conversion here (implicit as-check in strong mode) is a bit of an
anti-pattern

It would be better to name node.body and rely on type inference:

    ir.Expression body = node.body;
    if (body is ir.ConditionalExpression) {
      ir.Expression condition = body.condition;
      if (condition is ir.MethodInvocation) {
        ...

[Johnni Winther, 2017/05/09 10:20:25]

OK, I'll rewrite it.

+      if (conditional.condition is ir.MethodInvocation) {
+        ir.MethodInvocation methodInvocation = conditional.condition;
+        if (methodInvocation.name.name == BinaryOperator.EQ.name &&
+            methodInvocation.receiver is ir.VariableGet &&
+            methodInvocation.arguments.positional.single is ir.NullLiteral &&
+            conditional.otherwise is ir.VariableGet) {
+          ir.VariableGet variableGet1 = methodInvocation.receiver;
+          ir.VariableGet variableGet2 = conditional.otherwise;
+          if (variableGet1.variable == node.variable &&
+              variableGet2.variable == node.variable) {
+            // We have <left> ?? <right> encoded as:
+            //    let #1 = <left> in #1 == null ? <right> : #1
+            ConstantExpression left = visit(node.variable.initializer);
+            ConstantExpression right = visit(conditional.then);
+            return new BinaryConstantExpression(
+                left, BinaryOperator.IF_NULL, right);

[Siggi Cherem (dart-lang), 2017/05/05 18:13:37]

nothing to change here, but I just wonder if it is worth desugaring. Since the
subexpressions are constants with no side-effects, we can also do `left == null
? right : left`.

[Johnni Winther, 2017/05/08 09:01:06]

I'd like the expressions to be structurally equivalence at least until we delete
the old front end.

[sra1, 2017/05/08 15:58:52]

It would be nice to have a TODO that explains this so we can fix it up later.

[Johnni Winther, 2017/05/09 10:20:25]

Will add a TODO

+          }
+        }
+      }
+    }
+    throw new UnimplementedError(
+        'Unexpected constant expression $node (${node.runtimeType})');
+  }
+
   /// Compute the [ConstantConstructor] corresponding to the const constructor
   /// [node].
   ConstantConstructor computeConstantConstructor(ir.Constructor node) {
     assert(node.isConst);
     ir.Class cls = node.enclosingClass;
     InterfaceType type = elementAdapter.elementEnvironment
         .getThisType(elementAdapter.getClass(cls));
 
     Map<dynamic, ConstantExpression> defaultValues =
         <dynamic, ConstantExpression>{};
@@ skipping 48 matching lines @@
     }
     if (isRedirecting) {
       return new RedirectingGenerativeConstantConstructor(
           defaultValues, superConstructorInvocation);
     } else {
       return new GenerativeConstantConstructor(
           type, defaultValues, fieldMap, superConstructorInvocation);
     }
   }
 }