Add StringLengthConstantExpression

pkg/compiler/lib/src/compile_time_constants.dart

 // Copyright (c) 2012, 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.compile_time_constant_evaluator;
 
 import 'constant_system_dart.dart';
 import 'constants/constant_system.dart';
 import 'constants/expressions.dart';
 import 'constants/values.dart';
@@ skipping 517 matching lines @@
       } else if (Elements.isClass(element) || Elements.isTypedef(element)) {
         assert(elements.isTypeLiteral(send));
         result = makeTypeConstant(elements.getTypeLiteralType(send));
       } else if (send.receiver != null) {
         if (send.selector.asIdentifier().source == "length") {
           AstConstant left = evaluate(send.receiver);
           if (left != null && left.value.isString) {
             StringConstantValue stringConstantValue = left.value;
             DartString string = stringConstantValue.primitiveValue;
             IntConstantValue length = constantSystem.createInt(string.length);
-            result = new VariableConstantExpression(length, element);
+            result =
+                new StringLengthConstantExpression(length, left.expression);
           }
         }
         // Fall through to error handling.
       } else if (!Elements.isUnresolved(element)
                  && element.isVariable
                  && element.isConst) {
         ConstantExpression variableExpression =
             handler.compileConstant(element);
         if (variableExpression != null) {
           result = new VariableConstantExpression(variableExpression.value,
@@ skipping 324 matching lines @@
     }
 
     String name =
         firstArgument.primitiveValue.slowToString();
     String value =
         compiler.fromEnvironment(name);
 
     AstConstant createEvaluatedConstant(ConstantValue value) {
 
       ConstantExpression expression;
+      ConstantExpression name = concreteArguments[0].expression;
+      ConstantExpression defaultValue;
+      if (concreteArguments.length > 1) {
+        defaultValue = concreteArguments[1].expression;
+      }
       if (constructor == compiler.intEnvironment) {
         expression = new IntFromEnvironmentConstantExpression(
-            value, name, normalizedArguments[1].expression);
+            value, name, defaultValue);
       } else if (constructor == compiler.boolEnvironment) {
         expression = new BoolFromEnvironmentConstantExpression(
-            value, name, normalizedArguments[1].expression);
+            value, name, defaultValue);
       } else if (constructor == compiler.stringEnvironment) {
         expression = new StringFromEnvironmentConstantExpression(
-            value, name, normalizedArguments[1].expression);
+            value, name, defaultValue);
       }
       return new AstConstant(context, node, expression);
     }
 
     if (value == null) {
       return createEvaluatedConstant(defaultValue);
     } else if (constructor == compiler.intEnvironment) {
       int number = int.parse(value, onError: (_) => null);
       return createEvaluatedConstant(
           (number == null)
@@ skipping 325 matching lines @@
   ErroneousAstConstant(Element element, Node node)
       : super(element, node, new ErroneousConstantExpression());
 }
 
 // TODO(johnniwinther): Avoid the need for this hack.
 TreeElements _analyzeElementEagerly(Compiler compiler, AstElement element) {
   WorldImpact worldImpact = compiler.analyzeElement(element.declaration);
   compiler.enqueuer.resolution.applyImpact(element.declaration, worldImpact);
   return element.resolvedAst.elements;
 }