Compute constants from IR nodes

pkg/compiler/lib/src/kernel/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 129 matching lines @@
       ir.StaticInvocation node);
 
   /// Compute the kind of foreign helper function called by [node], if any.
   ForeignKind getForeignKind(ir.StaticInvocation node);
 
   /// Computes the [InterfaceType] referenced by a call to the
   /// [JS_INTERCEPTOR_CONSTANT] function, if any.
   InterfaceType getInterfaceTypeForJsInterceptorCall(ir.StaticInvocation node);
 
   /// Computes the [ConstantValue] for the constant [expression].
-  ConstantValue getConstantValue(ir.Expression expression);
+  ConstantValue getConstantValue(ir.Expression expression,
+      {bool requireConstant: true});
 
   /// Returns the `noSuchMethod` [FunctionEntity] call from a
   /// `super.noSuchMethod` invocation within [cls].
   FunctionEntity getSuperNoSuchMethod(ClassEntity cls);
 
   /// Returns a [Spannable] for a message pointing to the IR [node] in the
   /// context of [member].
   Spannable getSpannable(MemberEntity member, ir.Node node);
 }
 
 /// Kinds of foreign functions.
 enum ForeignKind {
   JS,
   JS_BUILTIN,
   JS_EMBEDDED_GLOBAL,
   JS_INTERCEPTOR_CONSTANT,
   NONE,
 }
 
 abstract class KernelToElementMapMixin implements KernelToElementMap {
   DiagnosticReporter get reporter;
   native.BehaviorBuilder get nativeBehaviorBuilder;
-  ConstantValue computeConstantValue(ConstantExpression constant);
+  ConstantValue computeConstantValue(ConstantExpression constant,
+      {bool requireConstant: true});
 
   @override
   Name getName(ir.Name name) {
     return new Name(
         name.name, name.isPrivate ? getLibrary(name.library) : null);
   }
 
   @override
   CallStructure getCallStructure(ir.Arguments arguments) {
     int argumentCount = arguments.positional.length + arguments.named.length;
@@ skipping 49 matching lines @@
         irName.name, irName.isPrivate ? getLibrary(irName.library) : null);
     return new Selector.getter(name);
   }
 
   Selector getSetterSelector(ir.Name irName) {
     Name name = new Name(
         irName.name, irName.isPrivate ? getLibrary(irName.library) : null);
     return new Selector.setter(name);
   }
 
-  ConstantValue getConstantValue(ir.Expression node) {
-    ConstantExpression constant = new Constantifier(this).visit(node);
+  ConstantValue getConstantValue(ir.Expression node,
+      {bool requireConstant: true}) {
+    ConstantExpression constant =
+        new Constantifier(this, requireConstant: requireConstant).visit(node);
     if (constant == null) {
-      throw new UnsupportedError(
-          'No constant for ${DebugPrinter.prettyPrint(node)}');
+      if (requireConstant) {
+        throw new UnsupportedError(
+            'No constant for ${DebugPrinter.prettyPrint(node)}');
+      }
+      return null;
     }
-    return computeConstantValue(constant);
+    return computeConstantValue(constant, requireConstant: requireConstant);
   }
 
   /// Converts [annotations] into a list of [ConstantValue]s.
   List<ConstantValue> getMetadata(List<ir.Expression> annotations) {
     if (annotations.isEmpty) return const <ConstantValue>[];
     List<ConstantValue> metadata = <ConstantValue>[];
     annotations.forEach((ir.Expression node) {
       metadata.add(getConstantValue(node));
     });
     return metadata;
@@ skipping 283 matching lines @@
   ConstantExpression visit(ir.Expression node) {
     ConstantExpression constant = node.accept(this);
     if (constant == null && requireConstant) {
       throw new UnsupportedError(
           "No constant computed for $node (${node.runtimeType})");
     }
     return constant;
   }
 
   ConstantExpression defaultExpression(ir.Expression node) {
-    throw new UnimplementedError(
-        'Unimplemented constant expression $node (${node.runtimeType})');
+    if (requireConstant) {
+      throw new UnimplementedError(
+          'Unimplemented constant expression $node (${node.runtimeType})');
+    }
+    return null;
   }
 
   List<ConstantExpression> _computeList(List<ir.Expression> expressions) {
     List<ConstantExpression> list = <ConstantExpression>[];
     for (ir.Expression expression in expressions) {
       ConstantExpression constant = visit(expression);
       if (constant == null) return null;
       list.add(constant);
     }
     return list;
   }
 
   List<ConstantExpression> _computeArguments(ir.Arguments node) {
     List<ConstantExpression> arguments = <ConstantExpression>[];
     for (ir.Expression argument in node.positional) {
       ConstantExpression constant = visit(argument);
       if (constant == null) return null;
       arguments.add(constant);
     }
     for (ir.NamedExpression argument in node.named) {
       ConstantExpression constant = visit(argument.value);
       if (constant == null) return null;
       arguments.add(constant);
     }
     return arguments;
   }
 
   ConstructedConstantExpression _computeConstructorInvocation(
       ir.Constructor target, ir.Arguments arguments) {
+    List<ConstantExpression> expressions = _computeArguments(arguments);
+    if (expressions == null) return null;
     return new ConstructedConstantExpression(
         elementAdapter.createInterfaceType(
             target.enclosingClass, arguments.types),
         elementAdapter.getConstructor(target),
         elementAdapter.getCallStructure(arguments),
-        _computeArguments(arguments));
+        expressions);
   }
 
   @override
   ConstantExpression visitConstructorInvocation(ir.ConstructorInvocation node) {
     return _computeConstructorInvocation(node.target, node.arguments);
   }
 
   @override
   ConstantExpression visitVariableGet(ir.VariableGet node) {
     if (node.variable.parent is ir.FunctionNode) {
       ir.FunctionNode function = node.variable.parent;
       int index = function.positionalParameters.indexOf(node.variable);
       if (index != -1) {
         return new PositionalArgumentReference(index);
       } else {
         assert(function.namedParameters.contains(node.variable));
         return new NamedArgumentReference(node.variable.name);
       }
+    } else if (node.variable.isConst) {
+      return visit(node.variable.initializer);
     }
-    throw new UnimplementedError(
-        'Unimplemented constant expression $node (${node.runtimeType})');
+    return defaultExpression(node);
   }
 
   @override
   ConstantExpression visitStaticGet(ir.StaticGet node) {
-    if (node.target is ir.Field) {
+    ir.Member target = node.target;
+    if (target is ir.Field && target.isConst) {
       return new FieldConstantExpression(elementAdapter.getField(node.target));
     } else if (node.target is ir.Procedure) {
       FunctionEntity function = elementAdapter.getMethod(node.target);
       DartType type = elementAdapter.getFunctionType(node.target.function);
       return new FunctionConstantExpression(function, type);
     }
-    throw new UnimplementedError(
-        'Unexpected constant expression $node (${node.runtimeType})');
+    return defaultExpression(node);
   }
 
   @override
   ConstantExpression visitNullLiteral(ir.NullLiteral node) {
     return new NullConstantExpression();
   }
 
   @override
   ConstantExpression visitBoolLiteral(ir.BoolLiteral node) {
     return new BoolConstantExpression(node.value);
@@ skipping 14 matching lines @@
     return new StringConstantExpression(node.value);
   }
 
   @override
   ConstantExpression visitSymbolLiteral(ir.SymbolLiteral node) {
     return new SymbolConstantExpression(node.value);
   }
 
   @override
   ConstantExpression visitStringConcatenation(ir.StringConcatenation node) {
-    return new ConcatenateConstantExpression(_computeList(node.expressions));
+    List<ConstantExpression> expressions = _computeList(node.expressions);
+    if (expressions == null) return null;
+    return new ConcatenateConstantExpression(expressions);
   }
 
   @override
   ConstantExpression visitMapLiteral(ir.MapLiteral node) {
     if (!node.isConst) {
-      throw new UnimplementedError(
-          'Unexpected constant expression $node (${node.runtimeType})');
+      return defaultExpression(node);
     }
     DartType keyType = elementAdapter.getDartType(node.keyType);
     DartType valueType = elementAdapter.getDartType(node.valueType);
     List<ConstantExpression> keys = <ConstantExpression>[];
     List<ConstantExpression> values = <ConstantExpression>[];
     for (ir.MapEntry entry in node.entries) {
-      keys.add(visit(entry.key));
-      values.add(visit(entry.value));
+      ConstantExpression key = visit(entry.key);
+      if (key == null) return null;
+      keys.add(key);
+      ConstantExpression value = visit(entry.value);
+      if (value == null) return null;
+      values.add(value);
     }
     return new MapConstantExpression(
         _commonElements.mapType(keyType, valueType), keys, values);
   }
 
   @override
   ConstantExpression visitListLiteral(ir.ListLiteral node) {
     if (!node.isConst) {
-      throw new UnimplementedError(
-          'Unexpected constant expression $node (${node.runtimeType})');
+      return defaultExpression(node);
     }
     DartType elementType = elementAdapter.getDartType(node.typeArgument);
     List<ConstantExpression> values = <ConstantExpression>[];
-    for (ir.Expression value in node.expressions) {
-      values.add(visit(value));
+    for (ir.Expression expression in node.expressions) {
+      ConstantExpression value = visit(expression);
+      if (value == null) return null;
+      values.add(value);
     }
     return new ListConstantExpression(
         _commonElements.listType(elementType), values);
   }
 
   @override
+  ConstantExpression visitTypeLiteral(ir.TypeLiteral node) {
+    DartType type = elementAdapter.getDartType(node.type);
+    String name;
+    if (type.isDynamic) {
+      name = 'dynamic';
+    } else if (type is InterfaceType) {
+      name = type.element.name;
+    } else if (type.isFunctionType || type.isTypedef) {
+      // TODO(johnniwinther): Compute a name for the type literal? It is only
+      // used in error messages in the old SSA builder.
+      name = '?';
+    } else {
+      return defaultExpression(node);
+    }
+    return new TypeConstantExpression(type, name);
+  }
+
+  @override
+  ConstantExpression visitNot(ir.Not node) {
+    ConstantExpression expression = visit(node.operand);
+    if (expression == null) return null;
+    return new UnaryConstantExpression(UnaryOperator.NOT, expression);
+  }
+
+  @override
   ConstantExpression visitConditionalExpression(ir.ConditionalExpression node) {
     ConstantExpression condition = visit(node.condition);
+    if (condition == null) return null;
     ConstantExpression trueExp = visit(node.then);
+    if (trueExp == null) return null;
     ConstantExpression falseExp = visit(node.otherwise);
+    if (falseExp == null) return null;
     return new ConditionalConstantExpression(condition, trueExp, falseExp);
   }
 
   @override
   ConstantExpression visitPropertyGet(ir.PropertyGet node) {
     if (node.name.name != 'length') {
       throw new UnimplementedError(
           'Unexpected constant expression $node (${node.runtimeType})');
     }
     ConstantExpression receiver = visit(node.receiver);
+    if (receiver == null) return null;
     return new StringLengthConstantExpression(receiver);
   }
 
   @override
   ConstantExpression visitMethodInvocation(ir.MethodInvocation node) {
     // Method invocations are generally not constant expressions but unary
     // and binary expressions are encoded as method invocations in kernel.
     if (node.arguments.named.isNotEmpty) {
-      throw new UnimplementedError(
-          'Unexpected constant expression $node (${node.runtimeType})');
+      return defaultExpression(node);
     }
     if (node.arguments.positional.length == 0) {
       UnaryOperator operator;
       if (node.name.name == UnaryOperator.NEGATE.selectorName) {
         operator = UnaryOperator.NEGATE;
       } else {
         operator = UnaryOperator.parse(node.name.name);
       }
       if (operator != null) {
         ConstantExpression expression = visit(node.receiver);
+        if (expression == null) return null;
         return new UnaryConstantExpression(operator, expression);
       }
     }
     if (node.arguments.positional.length == 1) {
       BinaryOperator operator = BinaryOperator.parse(node.name.name);
       if (operator != null) {
         ConstantExpression left = visit(node.receiver);
+        if (left == null) return null;
         ConstantExpression right = visit(node.arguments.positional.single);
+        if (right == null) return null;
         return new BinaryConstantExpression(left, operator, right);
       }
     }
-    throw new UnimplementedError(
-        'Unexpected constant expression $node (${node.runtimeType})');
+    return defaultExpression(node);
   }
 
   @override
   ConstantExpression visitStaticInvocation(ir.StaticInvocation node) {
     MemberEntity member = elementAdapter.getMember(node.target);
     if (member == _commonElements.identicalFunction) {
       if (node.arguments.positional.length == 2 &&
           node.arguments.named.isEmpty) {
         ConstantExpression left = visit(node.arguments.positional[0]);
+        if (left == null) return null;
         ConstantExpression right = visit(node.arguments.positional[1]);
+        if (right == null) return null;
         return new IdenticalConstantExpression(left, right);
       }
     } else if (member.name == 'fromEnvironment' &&
         node.arguments.positional.length == 1) {
       ConstantExpression name = visit(node.arguments.positional.single);
+      if (name == null) return null;
       ConstantExpression defaultValue;
       if (node.arguments.named.length == 1) {
         if (node.arguments.named.single.name != 'defaultValue') {
-          throw new UnimplementedError(
-              'Unexpected constant expression $node (${node.runtimeType})');
+          return defaultExpression(node);
         }
         defaultValue = visit(node.arguments.named.single.value);
+        if (defaultValue == null) return null;
       }
       if (member.enclosingClass == _commonElements.boolClass) {
         return new BoolFromEnvironmentConstantExpression(name, defaultValue);
       } else if (member.enclosingClass == _commonElements.intClass) {
         return new IntFromEnvironmentConstantExpression(name, defaultValue);
       } else if (member.enclosingClass == _commonElements.stringClass) {
         return new StringFromEnvironmentConstantExpression(name, defaultValue);
       }
     }
-    throw new UnimplementedError(
-        'Unexpected constant expression $node (${node.runtimeType})');
+    return defaultExpression(node);
   }
 
   @override
   ConstantExpression visitLogicalExpression(ir.LogicalExpression node) {
     BinaryOperator operator = BinaryOperator.parse(node.operator);
     if (operator != null) {
       ConstantExpression left = visit(node.left);
+      if (left == null) return null;
       ConstantExpression right = visit(node.right);
+      if (right == null) return null;
       return new BinaryConstantExpression(left, operator, right);
     }
-    throw new UnimplementedError(
-        'Unexpected constant expression $node (${node.runtimeType})');
+    return defaultExpression(node);
   }
 
   @override
   ConstantExpression visitLet(ir.Let node) {
     ir.Expression body = node.body;
     if (body is ir.ConditionalExpression) {
       ir.Expression condition = body.condition;
       if (condition is ir.MethodInvocation) {
         ir.Expression receiver = condition.receiver;
         ir.Expression otherwise = body.otherwise;
         if (condition.name.name == BinaryOperator.EQ.name &&
             receiver is ir.VariableGet &&
             condition.arguments.positional.single is ir.NullLiteral &&
             otherwise is ir.VariableGet) {
           if (receiver.variable == node.variable &&
               otherwise.variable == node.variable) {
             // We have <left> ?? <right> encoded as:
             //    let #1 = <left> in #1 == null ? <right> : #1
             ConstantExpression left = visit(node.variable.initializer);
+            if (left == null) return null;
             ConstantExpression right = visit(body.then);
+            if (right == null) return null;
             // TODO(johnniwinther): Remove [IF_NULL] binary constant expression
             // when the resolver is removed; then we no longer need the
             // expressions to be structurally equivalence for equivalence
             // testing.
             return new BinaryConstantExpression(
                 left, BinaryOperator.IF_NULL, right);
           }
         }
       }
     }
-    throw new UnimplementedError(
-        'Unexpected constant expression $node (${node.runtimeType})');
+    return defaultExpression(node);
   }
 
   /// 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>{};
     int parameterIndex = 0;
-    node.function.positionalParameters
-        .forEach((ir.VariableDeclaration parameter) {
+    for (ir.VariableDeclaration parameter
+        in node.function.positionalParameters) {
       if (parameterIndex >= node.function.requiredParameterCount) {
+        ConstantExpression defaultValue;
         if (parameter.initializer != null) {
-          defaultValues[parameterIndex] = parameter.initializer.accept(this);
+          defaultValue = parameter.initializer.accept(this);
         } else {
-          defaultValues[parameterIndex] = new NullConstantExpression();
+          defaultValue = new NullConstantExpression();
         }
+        if (defaultValue == null) return null;
+        defaultValues[parameterIndex] = defaultValue;
       }
       parameterIndex++;
-    });
-    node.function.namedParameters.forEach((ir.VariableDeclaration parameter) {
-      defaultValues[parameter.name] = parameter.initializer.accept(this);
-    });
+    }
+    for (ir.VariableDeclaration parameter in node.function.namedParameters) {
+      ConstantExpression defaultValue = parameter.initializer.accept(this);
+      if (defaultValue == null) return null;
+      defaultValues[parameter.name] = defaultValue;
+    }
 
     bool isRedirecting = node.initializers.length == 1 &&
         node.initializers.single is ir.RedirectingInitializer;
 
     Map<FieldEntity, ConstantExpression> fieldMap =
         <FieldEntity, ConstantExpression>{};
 
     void registerField(ir.Field field, ConstantExpression constant) {
       fieldMap[elementAdapter.getField(field)] = constant;
     }
@@ skipping 94 matching lines @@
   /// Call to notify that [member] is no longer being inlined.
   void leaveInlinedMember(MemberEntity member);
 
   /// Returns the [Local] for [node].
   Local getLocal(ir.VariableDeclaration node);
 
   /// Returns the [JumpTarget] for the branch in [node].
   // TODO(johnniwinther): Split this by kind of [node]?
   JumpTarget getJumpTarget(ir.TreeNode node, {bool isContinueTarget: false});
 }