Add ConstantConstructor to ConstantExpression system.

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 737 matching lines @@
         evaluateArgumentsToConstructor(
           node, callStructure, send.arguments, constructor.implementation,
           compileArgument: (node) => concreteArgumentMap[node]);
     List<AstConstant> concreteArguments =
         concreteArgumentMap.values.toList();
 
     if (constructor == compiler.intEnvironment ||
         constructor == compiler.boolEnvironment ||
         constructor == compiler.stringEnvironment) {
 
-      AstConstant createEvaluatedConstant(ConstantValue value) {
-        return new AstConstant(
-            context, node, new ConstructedConstantExpression(
-                value,
-                type,
-                constructor,
-                elements.getSelector(send).callStructure,
-                concreteArguments.map((e) => e.expression).toList()));
-      }
-
       var firstArgument = normalizedArguments[0].value;
       ConstantValue defaultValue = normalizedArguments[1].value;
 
       if (firstArgument.isNull) {
         compiler.reportError(
             send.arguments.head, MessageKind.NULL_NOT_ALLOWED);
         return null;
       }
 
       if (!firstArgument.isString) {
@@ skipping 24 matching lines @@
 
       if (constructor == compiler.stringEnvironment &&
           !(defaultValue.isNull || defaultValue.isString)) {
         DartType type = defaultValue.getType(compiler.coreTypes);
         compiler.reportError(
             send.arguments.tail.head, MessageKind.NOT_ASSIGNABLE,
             {'fromType': type, 'toType': compiler.stringClass.rawType});
         return null;
       }
 
+      String name =
+          firstArgument.primitiveValue.slowToString();
       String value =
-          compiler.fromEnvironment(firstArgument.primitiveValue.slowToString());
+          compiler.fromEnvironment(name);
+
+      AstConstant createEvaluatedConstant(ConstantValue value) {
+
+        ConstantExpression expression;
+        if (constructor == compiler.intEnvironment) {
+          expression = new IntFromEnvironmentConstantExpression(
+              value, name, normalizedArguments[1].expression);
+        } else if (constructor == compiler.boolEnvironment) {
+          expression = new BoolFromEnvironmentConstantExpression(
+              value, name, normalizedArguments[1].expression);
+        } else if (constructor == compiler.stringEnvironment) {
+          expression = new StringFromEnvironmentConstantExpression(
+              value, name, normalizedArguments[1].expression);
+        }
+        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)
                 ? defaultValue
                 : constantSystem.createInt(number));
       } else if (constructor == compiler.boolEnvironment) {
@@ skipping 323 matching lines @@
   ConstantValue get value => expression.value;
 
   String toString() => expression.toString();
 }
 
 /// A synthetic constant used to recover from errors.
 class ErroneousAstConstant extends AstConstant {
   ErroneousAstConstant(Element element, Node node)
       : super(element, node, new ErroneousConstantExpression());
 }