Skip spurious constants in deferred computation.

pkg/compiler/lib/src/constants/expressions.dart

 // Copyright (c) 2014, 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.
 
 library dart2js.constants.expressions;
 
 import '../common.dart';
 import '../constants/constant_system.dart';
 import '../core_types.dart';
 import '../dart_types.dart';
@@ skipping 106 matching lines @@
     if (hashCode != other.hashCode) return false;
     return _equals(other);
   }
 
   String toString() {
     assertDebugMode('Use ConstantExpression.toDartText() or '
         'ConstantExpression.toStructuredText() instead of '
         'ConstantExpression.toString()');
     return toDartText();
   }
+
+  /// Returns `true` if this expression is implicitly constant, that is, that
+  /// it doesn't declare its constness with the 'const' keyword.
+  ///
+  /// Implicit constants are simple literals, like bool, int and string
+  /// literals, constant references and compositions of implicit constants.
+  /// Explicit constants are constructor constants, and constant map and list
+  /// literals.
+  bool get isImplicit => true;
+
+  /// Returns `true` if this expression is only potentially constant, that is,
+  /// if it contains positional or named references, used to define constant
+  /// constructors.
+  // TODO(johnniwinther): Maybe make this final if we use it outside assertions.
+  bool get isPotential => true;
 }
 
 /// A synthetic constant used to recover from errors.
 class ErroneousConstantExpression extends ConstantExpression {
   ConstantExpressionKind get kind => ConstantExpressionKind.ERRONEOUS;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     // Do nothing. This is an error.
   }
 
@@ skipping 39 matching lines @@
   accept(ConstantExpressionVisitor visitor, [context]) {
     throw "unsupported";
   }
 
   @override
   bool _equals(SyntheticConstantExpression other) {
     return value == other.value;
   }
 
   ConstantExpressionKind get kind => ConstantExpressionKind.SYNTHETIC;
+
+  @override
+  bool get isPotential => false;
+
+  @override
+  bool get isImplicit => false;
 }
 
 /// A boolean, int, double, string, or null constant.
 abstract class PrimitiveConstantExpression extends ConstantExpression {
   /// The primitive value of this contant expression.
   get primitiveValue;
 }
 
 /// Boolean literal constant.
 class BoolConstantExpression extends PrimitiveConstantExpression {
@@ skipping 219 matching lines @@
     if (type != other.type) return false;
     if (values.length != other.values.length) return false;
     for (int i = 0; i < values.length; i++) {
       if (values[i] != other.values[i]) return false;
     }
     return true;
   }
 
   @override
   DartType getKnownType(CoreTypes coreTypes) => type;
+
+  @override
+  bool get isImplicit => false;
+
+  @override
+  bool get isPotential => values.any((e) => e.isPotential);
 }
 
 /// Literal map constant.
 class MapConstantExpression extends ConstantExpression {
   final InterfaceType type;
   final List<ConstantExpression> keys;
   final List<ConstantExpression> values;
 
   MapConstantExpression(this.type, this.keys, this.values);
 
@@ skipping 49 matching lines @@
     if (values.length != other.values.length) return false;
     for (int i = 0; i < values.length; i++) {
       if (keys[i] != other.keys[i]) return false;
       if (values[i] != other.values[i]) return false;
     }
     return true;
   }
 
   @override
   DartType getKnownType(CoreTypes coreTypes) => type;
+
+  @override
+  bool get isImplicit => false;
+
+  @override
+  bool get isPotential {
+    return keys.any((e) => e.isPotential) || values.any((e) => e.isPotential);
+  }
 }
 
 /// Invocation of a const constructor.
 class ConstructedConstantExpression extends ConstantExpression {
   final InterfaceType type;
   final ConstructorElement target;
   final CallStructure callStructure;
   final List<ConstantExpression> arguments;
 
   ConstructedConstantExpression(
@@ skipping 60 matching lines @@
   @override
   bool _equals(ConstructedConstantExpression other) {
     if (type != other.type) return false;
     if (target != other.target) return false;
     if (callStructure != other.callStructure) return false;
     for (int i = 0; i < arguments.length; i++) {
       if (arguments[i] != other.arguments[i]) return false;
     }
     return true;
   }
+
+  @override
+  bool get isImplicit => false;
+
+  @override
+  bool get isPotential {
+    return arguments.any((e) => e.isPotential);
+  }
 }
 
 /// String literal with juxtaposition and/or interpolations.
 class ConcatenateConstantExpression extends ConstantExpression {
   final List<ConstantExpression> expressions;
 
   ConcatenateConstantExpression(this.expressions);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.CONCATENATE;
 
@@ skipping 59 matching lines @@
   bool _equals(ConcatenateConstantExpression other) {
     if (expressions.length != other.expressions.length) return false;
     for (int i = 0; i < expressions.length; i++) {
       if (expressions[i] != other.expressions[i]) return false;
     }
     return true;
   }
 
   @override
   DartType getKnownType(CoreTypes coreTypes) => coreTypes.stringType;
+
+  @override
+  bool get isPotential {
+    return expressions.any((e) => e.isPotential);
+  }
 }
 
 /// Symbol literal.
 class SymbolConstantExpression extends ConstantExpression {
   final String name;
 
   SymbolConstantExpression(this.name);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.SYMBOL;
 
@@ skipping 225 matching lines @@
     return 13 * operator.hashCode + 17 * left.hashCode + 19 * right.hashCode;
   }
 
   @override
   bool _equals(BinaryConstantExpression other) {
     return operator == other.operator &&
         left == other.left &&
         right == other.right;
   }
 
+  @override
+  bool get isPotential {
+    return left.isPotential || right.isPotential;
+  }
+
   static const Map<BinaryOperatorKind, int> PRECEDENCE_MAP = const {
     BinaryOperatorKind.EQ: 6,
     BinaryOperatorKind.NOT_EQ: 6,
     BinaryOperatorKind.LOGICAL_AND: 5,
     BinaryOperatorKind.LOGICAL_OR: 4,
     BinaryOperatorKind.XOR: 9,
     BinaryOperatorKind.AND: 10,
     BinaryOperatorKind.OR: 8,
     BinaryOperatorKind.SHR: 11,
     BinaryOperatorKind.SHL: 11,
@@ skipping 53 matching lines @@
     return 17 * left.hashCode + 19 * right.hashCode;
   }
 
   @override
   bool _equals(IdenticalConstantExpression other) {
     return left == other.left && right == other.right;
   }
 
   @override
   DartType getKnownType(CoreTypes coreTypes) => coreTypes.boolType;
+
+  @override
+  bool get isPotential {
+    return left.isPotential || right.isPotential;
+  }
 }
 
 /// A unary constant expression like `-a`.
 class UnaryConstantExpression extends ConstantExpression {
   final UnaryOperator operator;
   final ConstantExpression expression;
 
   UnaryConstantExpression(this.operator, this.expression) {
     assert(PRECEDENCE_MAP[operator.kind] != null);
   }
@@ skipping 33 matching lines @@
   @override
   bool _equals(UnaryConstantExpression other) {
     return operator == other.operator && expression == other.expression;
   }
 
   @override
   DartType getKnownType(CoreTypes coreTypes) {
     return expression.getKnownType(coreTypes);
   }
 
+  @override
+  bool get isPotential {
+    return expression.isPotential;
+  }
+
   static const Map<UnaryOperatorKind, int> PRECEDENCE_MAP = const {
     UnaryOperatorKind.NOT: 14,
     UnaryOperatorKind.COMPLEMENT: 14,
     UnaryOperatorKind.NEGATE: 14,
   };
 }
 
 /// A string length constant expression like `a.length`.
 class StringLengthConstantExpression extends ConstantExpression {
   final ConstantExpression expression;
@@ skipping 35 matching lines @@
     return 23 * expression.hashCode;
   }
 
   @override
   bool _equals(StringLengthConstantExpression other) {
     return expression == other.expression;
   }
 
   @override
   DartType getKnownType(CoreTypes coreTypes) => coreTypes.intType;
+
+  @override
+  bool get isPotential {
+    return expression.isPotential;
+  }
 }
 
 /// A constant conditional expression like `a ? b : c`.
 class ConditionalConstantExpression extends ConstantExpression {
   final ConstantExpression condition;
   final ConstantExpression trueExp;
   final ConstantExpression falseExp;
 
   ConditionalConstantExpression(this.condition, this.trueExp, this.falseExp);
 
@@ skipping 53 matching lines @@
 
   @override
   DartType getKnownType(CoreTypes coreTypes) {
     DartType trueType = trueExp.getKnownType(coreTypes);
     DartType falseType = falseExp.getKnownType(coreTypes);
     if (trueType == falseType) {
       return trueType;
     }
     return null;
   }
+
+  @override
+  bool get isPotential {
+    return condition.isPotential || trueExp.isPotential || falseExp.isPotential;
+  }
 }
 
 /// A reference to a position parameter.
 class PositionalArgumentReference extends ConstantExpression {
   final int index;
 
   PositionalArgumentReference(this.index);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.POSITIONAL_REFERENCE;
@@ skipping 16 matching lines @@
   int _computeHashCode() => 13 * index.hashCode;
 
   @override
   bool _equals(PositionalArgumentReference other) => index == other.index;
 
   @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     throw new UnsupportedError('PositionalArgumentReference.evaluate');
   }
+
+  @override
+  bool get isPotential {
+    return true;
+  }
 }
 
 /// A reference to a named parameter.
 class NamedArgumentReference extends ConstantExpression {
   final String name;
 
   NamedArgumentReference(this.name);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.NAMED_REFERENCE;
@@ skipping 16 matching lines @@
   int _computeHashCode() => 13 * name.hashCode;
 
   @override
   bool _equals(NamedArgumentReference other) => name == other.name;
 
   @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     throw new UnsupportedError('NamedArgumentReference.evaluate');
   }
+
+  @override
+  bool get isPotential {
+    return true;
+  }
 }
 
 abstract class FromEnvironmentConstantExpression extends ConstantExpression {
   final ConstantExpression name;
   final ConstantExpression defaultValue;
 
   FromEnvironmentConstantExpression(this.name, this.defaultValue);
 
   @override
   int _computeHashCode() {
     return 13 * name.hashCode + 17 * defaultValue.hashCode;
   }
 
   @override
   bool _equals(FromEnvironmentConstantExpression other) {
     return name == other.name && defaultValue == other.defaultValue;
   }
+
+  @override
+  bool get isImplicit {
+    return false;
+  }
+
+  @override
+  bool get isPotential {
+    return name.isPotential ||
+        (defaultValue != null && defaultValue.isPotential);
+  }
 }
 
 /// A `const bool.fromEnvironment` constant.
 class BoolFromEnvironmentConstantExpression
     extends FromEnvironmentConstantExpression {
   BoolFromEnvironmentConstantExpression(
       ConstantExpression name, ConstantExpression defaultValue)
       : super(name, defaultValue);
 
   ConstantExpressionKind get kind {
@@ skipping 213 matching lines @@
 
   @override
   bool _equals(DeferredConstantExpression other) {
     return expression == other.expression;
   }
 
   @override
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitDeferred(this, context);
   }
+
+  @override
+  bool get isPotential {
+    return expression.isPotential;
+  }
 }
 
 abstract class ConstantExpressionVisitor<R, A> {
   const ConstantExpressionVisitor();
 
   R visit(ConstantExpression constant, A context) {
     return constant.accept(this, context);
   }
 
   R visitBool(BoolConstantExpression exp, A context);
@@ skipping 288 matching lines @@
     visit(exp.name);
     if (exp.defaultValue != null) {
       sb.write(', defaultValue: ');
       visit(exp.defaultValue);
     }
     sb.write(')');
   }
 
   String toString() => sb.toString();
 }