Add StringLengthConstantExpression

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 '../constants/constant_system.dart';
 import '../dart2jslib.dart' show assertDebugMode, Compiler;
 import '../dart_types.dart';
 import '../elements/elements.dart' show
@@ skipping 20 matching lines @@
   ERRONEOUS,
   FUNCTION,
   IDENTICAL,
   INT,
   INT_FROM_ENVIRONMENT,
   LIST,
   MAP,
   NULL,
   STRING,
   STRING_FROM_ENVIRONMENT,
+  STRING_LENGTH,
   SYMBOL,
   TYPE,
   UNARY,
   VARIABLE,
 
   POSITIONAL_REFERENCE,
   NAMED_REFERENCE,
 }
 
 /// Environment used for evaluating constant expressions.
@@ skipping 944 matching lines @@
            expression == other.expression;
   }
 
   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 ConstantValue value;
+  final ConstantExpression expression;
+
+  StringLengthConstantExpression(this.value, this.expression);
+
+  ConstantExpressionKind get kind => ConstantExpressionKind.STRING_LENGTH;
+
+  accept(ConstantExpressionVisitor visitor, [context]) {
+    return visitor.visitStringLength(this, context);
+  }
+
+  @override
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem) {
+    ConstantValue value = expression.evaluate(environment, constantSystem);
+    if (value.isString) {
+      StringConstantValue stringValue = value;
+      return constantSystem.createInt(stringValue.primitiveValue.length);
+    }
+    return new NonConstantValue();
+  }
+
+  ConstantExpression apply(NormalizedArguments arguments) {
+    return new StringLengthConstantExpression(
+        value,
+        expression.apply(arguments));
+  }
+
+  int get precedence => 15;
+
+  @override
+  int _computeHashCode() {
+    return 23 * expression.hashCode;
+  }
+
+  @override
+  bool _equals(StringLengthConstantExpression other) {
+    return expression == other.expression;
+  }
+}
+
 /// A constant conditional expression like `a ? b : c`.
 class ConditionalConstantExpression extends ConstantExpression {
   final ConstantValue value;
   final ConstantExpression condition;
   final ConstantExpression trueExp;
   final ConstantExpression falseExp;
 
   ConditionalConstantExpression(this.value,
                                 this.condition,
                                 this.trueExp,
@@ skipping 113 matching lines @@
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
     throw new UnsupportedError('NamedArgumentReference.evaluate');
   }
 }
 
 abstract class FromEnvironmentConstantExpression extends ConstantExpression {
   final ConstantValue value;
-  final String name;
+  final ConstantExpression name;
   final ConstantExpression defaultValue;
 
   FromEnvironmentConstantExpression(this.value, 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;
   }
 }
 
 /// A `const bool.fromEnvironment` constant.
 class BoolFromEnvironmentConstantExpression
     extends FromEnvironmentConstantExpression {
 
   BoolFromEnvironmentConstantExpression(
       ConstantValue value,
-      String name,
+      ConstantExpression name,
       ConstantExpression defaultValue)
       : super(value, name, defaultValue);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.BOOL_FROM_ENVIRONMENT;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitBoolFromEnvironment(this, context);
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
-    String text = environment.readFromEnvironment(name);
+    ConstantValue nameConstantValue =
+        name.evaluate(environment, constantSystem);
+    ConstantValue defaultConstantValue;
+    if (defaultValue != null) {
+      defaultConstantValue =
+          defaultValue.evaluate(environment, constantSystem);
+    } else {
+      defaultConstantValue = constantSystem.createBool(false);
+    }
+    if (!nameConstantValue.isString) {
+      return new NonConstantValue();
+    }
+    StringConstantValue nameStringConstantValue = nameConstantValue;
+    String text = environment.readFromEnvironment(
+        nameStringConstantValue.primitiveValue.slowToString());
     if (text == 'true') {
       return constantSystem.createBool(true);
     } else if (text == 'false') {
       return constantSystem.createBool(false);
     } else {
-      return defaultValue.evaluate(environment, constantSystem);
+      return defaultConstantValue;
     }
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new BoolFromEnvironmentConstantExpression(
-        null, name, defaultValue.apply(arguments));
+        null,
+        name.apply(arguments),
+        defaultValue != null ? defaultValue.apply(arguments) : null);
   }
 }
 
 /// A `const int.fromEnvironment` constant.
 class IntFromEnvironmentConstantExpression
     extends FromEnvironmentConstantExpression {
 
   IntFromEnvironmentConstantExpression(
       ConstantValue value,
-      String name,
+      ConstantExpression name,
       ConstantExpression defaultValue)
       : super(value, name, defaultValue);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.INT_FROM_ENVIRONMENT;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitIntFromEnvironment(this, context);
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
+    ConstantValue nameConstantValue =
+        name.evaluate(environment, constantSystem);
+    ConstantValue defaultConstantValue;
+    if (defaultValue != null) {
+      defaultConstantValue =
+          defaultValue.evaluate(environment, constantSystem);
+    } else {
+      defaultConstantValue = constantSystem.createNull();
+    }
+    if (!nameConstantValue.isString) {
+      return new NonConstantValue();
+    }
+    StringConstantValue nameStringConstantValue = nameConstantValue;
+    String text = environment.readFromEnvironment(
+        nameStringConstantValue.primitiveValue.slowToString());
     int value;
-    String text = environment.readFromEnvironment(name);
     if (text != null) {
       value = int.parse(text, onError: (_) => null);
     }
     if (value == null) {
-      return defaultValue.evaluate(environment, constantSystem);
+      return defaultConstantValue;
     } else {
       return constantSystem.createInt(value);
     }
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new IntFromEnvironmentConstantExpression(
-        null, name, defaultValue.apply(arguments));
+        null,
+        name.apply(arguments),
+        defaultValue != null ? defaultValue.apply(arguments) : null);
   }
 }
 
 /// A `const String.fromEnvironment` constant.
 class StringFromEnvironmentConstantExpression
     extends FromEnvironmentConstantExpression {
 
   StringFromEnvironmentConstantExpression(
       ConstantValue value,
-      String name,
+      ConstantExpression name,
       ConstantExpression defaultValue)
       : super(value, name, defaultValue);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.STRING_FROM_ENVIRONMENT;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitStringFromEnvironment(this, context);
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
-    String text = environment.readFromEnvironment(name);
+    ConstantValue nameConstantValue =
+        name.evaluate(environment, constantSystem);
+    ConstantValue defaultConstantValue;
+    if (defaultValue != null) {
+      defaultConstantValue =
+          defaultValue.evaluate(environment, constantSystem);
+    } else {
+      defaultConstantValue = constantSystem.createNull();
+    }
+    if (!nameConstantValue.isString) {
+      return new NonConstantValue();
+    }
+    StringConstantValue nameStringConstantValue = nameConstantValue;
+    String text = environment.readFromEnvironment(
+        nameStringConstantValue.primitiveValue.slowToString());
     if (text == null) {
-      return defaultValue.evaluate(environment, constantSystem);
+      return defaultConstantValue;
     } else {
       return constantSystem.createString(new DartString.literal(text));
     }
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new StringFromEnvironmentConstantExpression(
-        null, name, defaultValue.apply(arguments));
+        null,
+        name.apply(arguments),
+        defaultValue != null ? defaultValue.apply(arguments) : null);
   }
 }
 
 /// A constant expression referenced with a deferred prefix.
 /// For example `lib.C`.
 class DeferredConstantExpression extends ConstantExpression {
   final ConstantValue value;
   final ConstantExpression expression;
   final PrefixElement prefix;
 
   DeferredConstantExpression(this.value, this.expression, this.prefix);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.DEFERRED;
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
     return expression.evaluate(environment, constantSystem);
   }
 
   @override
   int _computeHashCode() {
     return 13 * expression.hashCode;
   }
 
+  ConstantExpression apply(NormalizedArguments arguments) {
+    return new DeferredConstantExpression(
+        value, expression.apply(arguments), prefix);
+  }
+
   @override
   bool _equals(DeferredConstantExpression other) {
     return expression == other.expression;
   }
 
   @override
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitDeferred(this, context);
   }
 }
@@ skipping 14 matching lines @@
   R visitMap(MapConstantExpression exp, A context);
   R visitConstructed(ConstructedConstantExpression exp, A context);
   R visitConcatenate(ConcatenateConstantExpression exp, A context);
   R visitSymbol(SymbolConstantExpression exp, A context);
   R visitType(TypeConstantExpression exp, A context);
   R visitVariable(VariableConstantExpression exp, A context);
   R visitFunction(FunctionConstantExpression exp, A context);
   R visitBinary(BinaryConstantExpression exp, A context);
   R visitIdentical(IdenticalConstantExpression exp, A context);
   R visitUnary(UnaryConstantExpression exp, A context);
+  R visitStringLength(StringLengthConstantExpression exp, A context);
   R visitConditional(ConditionalConstantExpression exp, A context);
   R visitBoolFromEnvironment(BoolFromEnvironmentConstantExpression exp,
                              A context);
   R visitIntFromEnvironment(IntFromEnvironmentConstantExpression exp,
                             A context);
   R visitStringFromEnvironment(StringFromEnvironmentConstantExpression exp,
                                A context);
   R visitDeferred(DeferredConstantExpression exp, A context);
 
   R visitPositional(PositionalArgumentReference exp, A context);
   R visitNamed(NamedArgumentReference exp, A context);
 }
 
 /// Represents the declaration of a constant [element] with value [expression].
 // TODO(johnniwinther): Where does this class belong?
 class ConstDeclaration {
   final VariableElement element;
   final ConstantExpression expression;
 
   ConstDeclaration(this.element, this.expression);
 }
 
 class ConstExpPrinter extends ConstantExpressionVisitor {
   final StringBuffer sb = new StringBuffer();
 
   void write(ConstantExpression parent,
-        ConstantExpression child,
-        {bool leftAssociative: true}) {
+             ConstantExpression child,
+             {bool leftAssociative: true}) {
     if (child.precedence < parent.precedence ||
         !leftAssociative && child.precedence == parent.precedence) {
       sb.write('(');
       child.accept(this);
       sb.write(')');
     } else {
       child.accept(this);
     }
   }
 
@@ skipping 75 matching lines @@
       sb.write(': ');
       visit(exp.values[index]);
     }
     sb.write('}');
   }
 
   @override
   void visitConstructed(ConstructedConstantExpression exp, [_]) {
     sb.write('const ');
     sb.write(exp.target.enclosingClass.name);
+    writeTypeArguments(exp.type);
     if (exp.target.name != '') {
       sb.write('.');
       sb.write(exp.target.name);
     }
-    writeTypeArguments(exp.type);
     sb.write('(');
     bool needsComma = false;
 
     int namedOffset = exp.callStructure.positionalArgumentCount;
     for (int index = 0; index < namedOffset; index++) {
       if (needsComma) {
         sb.write(', ');
       }
       visit(exp.arguments[index]);
       needsComma = true;
@@ skipping 62 matching lines @@
     sb.write(')');
   }
 
   @override
   void visitUnary(UnaryConstantExpression exp, [_]) {
     sb.write(exp.operator);
     write(exp, exp.expression);
   }
 
   @override
+  void visitStringLength(StringLengthConstantExpression exp, [_]) {
+    write(exp, exp.expression, leftAssociative: false);
+    sb.write('.length');
+  }
+
+  @override
   void visitConditional(ConditionalConstantExpression exp, [_]) {
     write(exp, exp.condition, leftAssociative: false);
     sb.write(' ? ');
     write(exp, exp.trueExp);
     sb.write(' : ');
     write(exp, exp.falseExp);
   }
 
   @override
   void visitPositional(PositionalArgumentReference exp, [_]) {
@@ skipping 10 matching lines @@
   @override
   void visitDeferred(DeferredConstantExpression exp, context) {
     sb.write(exp.prefix.deferredImport.prefix.source);
     sb.write('.');
     write(exp, exp.expression);
   }
 
   @override
   void visitBoolFromEnvironment(BoolFromEnvironmentConstantExpression exp,
                                 [_]) {
-    sb.write('const bool.fromEnvironment("${exp.name}", defaultValue: ');
-    visit(exp.defaultValue);
+    sb.write('const bool.fromEnvironment(');
+    visit(exp.name);
+    if (exp.defaultValue != null) {
+      sb.write(', defaultValue: ');
+      visit(exp.defaultValue);
+    }
     sb.write(')');
   }
 
   @override
   void visitIntFromEnvironment(IntFromEnvironmentConstantExpression exp, [_]) {
-    sb.write('const int.fromEnvironment("${exp.name}", defaultValue: ');
-    visit(exp.defaultValue);
+    sb.write('const int.fromEnvironment(');
+    visit(exp.name);
+    if (exp.defaultValue != null) {
+      sb.write(', defaultValue: ');
+      visit(exp.defaultValue);
+    }
     sb.write(')');
   }
 
   @override
   void visitStringFromEnvironment(StringFromEnvironmentConstantExpression exp,
                                   [_]) {
-    sb.write('const String.fromEnvironment("${exp.name}", defaultValue: ');
-    visit(exp.defaultValue);
+    sb.write('const String.fromEnvironment(');
+    visit(exp.name);
+    if (exp.defaultValue != null) {
+      sb.write(', defaultValue: ');
+      visit(exp.defaultValue);
+    }
     sb.write(')');
   }
 
   String toString() => sb.toString();
 }