Implement fromEnvironment on bool, int, String in dart2js.

sdk/lib/_internal/compiler/implementation/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.
 
 part of dart2js;
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
@@ skipping 616 matching lines @@
     // constructor to ensure the redirectionTarget has been computed
     // correctly.  Find a way to avoid this.
     compiler.analyzeElement(constructor.declaration);
 
     InterfaceType type = elements.getType(node);
     List<Constant> evaluateArguments(FunctionElement constructor) {
       Selector selector = elements.getSelector(send);
       return evaluateArgumentsToConstructor(
           node, selector, send.arguments, constructor);
     }
-    return makeConstructedConstant(node, type, constructor, evaluateArguments);
+
+    if (constructor == compiler.intEnvironment
+        || constructor == compiler.boolEnvironment
+        || constructor == compiler.stringEnvironment) {
+      List<Constant> arguments = evaluateArguments(constructor);
+      var firstArgument = arguments[0];
+      Constant defaultValue = arguments[1];
+
+      if (firstArgument is NullConstant) {
+        compiler.reportFatalError(
+            send.arguments.head, MessageKind.NULL_NOT_ALLOWED);
+      }
+
+      if (firstArgument is! StringConstant) {
+        DartType type = defaultValue.computeType(compiler);
+        compiler.reportFatalError(
+            send.arguments.head, MessageKind.NOT_ASSIGNABLE.error,
+            {'fromType': type, 'toType': compiler.stringClass.rawType});
+      }
+
+      if (constructor == compiler.intEnvironment
+          && !(defaultValue is NullConstant || defaultValue is IntConstant)) {
+        DartType type = defaultValue.computeType(compiler);
+        compiler.reportFatalError(
+            send.arguments.tail.head, MessageKind.NOT_ASSIGNABLE.error,
+            {'fromType': type, 'toType': compiler.intClass.rawType});
+      }
+
+      if (constructor == compiler.boolEnvironment
+          && !(defaultValue is NullConstant || defaultValue is BoolConstant)) {
+        DartType type = defaultValue.computeType(compiler);
+        compiler.reportFatalError(
+            send.arguments.tail.head, MessageKind.NOT_ASSIGNABLE.error,
+            {'fromType': type, 'toType': compiler.boolClass.rawType});
+      }
+
+      if (constructor == compiler.stringEnvironment
+          && !(defaultValue is NullConstant
+               || defaultValue is StringConstant)) {
+        DartType type = defaultValue.computeType(compiler);
+        compiler.reportFatalError(
+            send.arguments.tail.head, MessageKind.NOT_ASSIGNABLE.error,
+            {'fromType': type, 'toType': compiler.stringClass.rawType});
+      }
+
+      String value =
+          compiler.fromEnvironment(firstArgument.value.slowToString());
+
+      if (value == null) {
+        return defaultValue;
+      } else if (constructor == compiler.intEnvironment) {
+        int number = int.parse(value, onError: (_) => null);

[Lasse Reichstein Nielsen, 2013/10/31 06:58:20]

It should be fine to just do:
  return constantSystem.createInt(
      int.parse(value, onError: (_) => defaultValue));

[ngeoffray, 2013/10/31 07:41:18]

Done.

+        return (number == null)

[Søren Gjesse, 2013/10/30 15:21:49]

Re-reading the specification non-parseable integer returns the default value, so
this is the right thing I guess. The VM implementation throws in this case, but
I can change that.

[Lasse Reichstein Nielsen, 2013/10/31 06:58:20]

I'm open to changing it. I was working on the assumption that we wanted as few
errors as possible.

+            ? defaultValue
+            : constantSystem.createInt(number);
+      } else if (constructor == compiler.boolEnvironment) {
+        return (value == 'true')
+            ? constantSystem.createBool(true)
+            : constantSystem.createBool(false);
+      } else {
+        assert(constructor == compiler.stringEnvironment);
+        return constantSystem.createString(new DartString.literal(value), node);
+      }
+    } else {
+      return makeConstructedConstant(
+          node, type, constructor, evaluateArguments);
+    }
   }
 
   Constant makeConstructedConstant(
       Spannable node, InterfaceType type, FunctionElement constructor,
       List<Constant> getArguments(FunctionElement constructor)) {
     if (constructor.isRedirectingFactory) {
       type = constructor.computeTargetType(compiler, type);
     }
 
     // The redirection chain of this element may not have been resolved through
@@ skipping 233 matching lines @@
           if (fieldValue == null) {
             // Use the default value.
             fieldValue = handler.compileConstant(field);
           }
           jsNewArguments.add(fieldValue);
         },
         includeSuperAndInjectedMembers: true);
     return jsNewArguments;
   }
 }