fix #27784 and fix #27785, fromEnvironment constants in DDC

pkg/dev_compiler/lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, 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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 107 matching lines @@
   final ClassElement _jsArray;
 
   final ClassElement boolClass;
   final ClassElement intClass;
   final ClassElement interceptorClass;
   final ClassElement nullClass;
   final ClassElement numClass;
   final ClassElement objectClass;
   final ClassElement stringClass;
 
-  ConstFieldVisitor _constField;
+  ConstFieldVisitor _constants;
 
   /// The current function body being compiled.
   FunctionBody _currentFunction;
 
   /// Helper class for emitting elements in the proper order to allow
   /// JS to load the module.
   ElementLoader _loader;
 
   BuildUnit _buildUnit;
 
@@ skipping 130 matching lines @@
     var nodes = new HashMap<Element, AstNode>.identity();
     var sdkBootstrappingFns = new List<FunctionElement>();
     for (var unit in compilationUnits) {
       if (_isDartRuntime(unit.element.library)) {
         sdkBootstrappingFns.addAll(unit.element.functions);
       }
       _collectElements(unit, nodes);
     }
     _loader = new ElementLoader(nodes);
     if (compilationUnits.isNotEmpty) {
-      _constField = new ConstFieldVisitor(types,
+      _constants = new ConstFieldVisitor(context,
           dummySource: compilationUnits.first.element.source);
     }
 
     // Add implicit dart:core dependency so it is first.
     emitLibraryName(dartCoreLibrary);
 
     // Emit SDK bootstrapping functions first, if any.
     sdkBootstrappingFns.forEach(_emitDeclaration);
 
     // Visit each compilation unit and emit its code.
@@ skipping 1823 matching lines @@
       [ConstructorDeclaration ctor]) {
     bool isConst = ctor != null && ctor.constKeyword != null;
     if (isConst) _loader.startTopLevel(cls.element);
 
     // Run field initializers if they can have side-effects.
     var fields = new Map<FieldElement, JS.Expression>();
     var unsetFields = new Map<FieldElement, VariableDeclaration>();
     for (var declaration in fieldDecls) {
       for (var fieldNode in declaration.fields.variables) {
         var element = fieldNode.element;
-        if (_constField.isFieldInitConstant(fieldNode)) {
+        if (_constants.isFieldInitConstant(fieldNode)) {
           unsetFields[element as FieldElement] = fieldNode;
         } else {
           fields[element as FieldElement] = _visitInitializer(fieldNode);
         }
       }
     }
 
     // Initialize fields from `this.fieldName` parameters.
     if (ctor != null) {
       for (var p in ctor.parameters.parameters) {
@@ skipping 1626 matching lines @@
   JS.Statement _emitConstantStaticField(ClassElement classElem,
       VariableDeclaration field, Set<FieldElement> staticFieldOverrides) {
     PropertyInducingElement element = field.element;
     assert(element.isStatic);
 
     _loader.startCheckingReferences();
     JS.Expression jsInit = _visitInitializer(field);
     bool isLoaded = _loader.finishCheckingReferences();
 
     bool eagerInit =
-        isLoaded && (field.isConst || _constField.isFieldInitConstant(field));
+        isLoaded && (field.isConst || _constants.isFieldInitConstant(field));
 
     var fieldName = field.name.name;
     if (eagerInit &&
         !JS.invalidStaticFieldName(fieldName) &&
         !staticFieldOverrides.contains(element)) {
       return annotate(
           js.statement('#.# = #;', [
             _emitTopLevelName(classElem),
             _emitMemberName(fieldName, isStatic: true),
             jsInit
           ]),
           field,
           field.element);
     }
 
     // This means it should be treated as a lazy field.
     // TODO(jmesserly): we're throwing away the initializer expression,
     // which will force us to regenerate it.
     return null;
   }
 
   /// Emits a top-level field.
   JS.ModuleItem _emitTopLevelField(VariableDeclaration field) {
     TopLevelVariableElement element = field.element;
     assert(element.isStatic);
 
     bool eagerInit;
     JS.Expression jsInit;
-    if (field.isConst || _constField.isFieldInitConstant(field)) {
+    if (field.isConst || _constants.isFieldInitConstant(field)) {
       // If the field is constant, try and generate it at the top level.
       _loader.startTopLevel(element);
       jsInit = _visitInitializer(field);
       _loader.finishTopLevel(element);
       eagerInit = _loader.isLoaded(element);
     } else {
       // TODO(jmesserly): we're visiting the initializer here, and again
       // later on when we emit lazy fields. That seems busted.
       jsInit = _visitInitializer(field);
       eagerInit = false;
@@ skipping 144 matching lines @@
     assert(args.single is JS.ObjectInitializer);
     return args.single;
   }
 
   @override
   visitInstanceCreationExpression(InstanceCreationExpression node) {
     var element = node.staticElement;
     var constructor = node.constructorName;
     var name = constructor.name;
     var type = constructor.type.type;
+    if (node.isConst &&
+        element?.name == 'fromEnvironment' &&
+        element.library.isDartCore) {
+      var value = node.accept(_constants.constantVisitor);
+
+      if (value == null || value.isNull) {
+        return new JS.LiteralNull();
+      }
+      if (value.isUnknown) {
+        return type == types.boolType
+            ? js.boolean(false)

[vsm, 2016/11/16 19:16:22]

Can you add a comment explaining this case?  When would we have value.isUnknown
and why is it falsy?  Should it be a static error?

[Jennifer Messerly, 2016/11/16 20:11:48]

Sure, as best as I can. Unfortunately behavior of -D options is more or less
undocumented. :(

but it seems to follow from:
https://api.dartlang.org/stable/1.20.1/dart-core/bool/bool.fromEnvironment.html

+            : new JS.LiteralNull();
+      }
+      if (value.type == types.boolType) {
+        var boolValue = value.toBoolValue();
+        return boolValue != null ? js.boolean(boolValue) : new JS.LiteralNull();
+      }
+      if (value.type == types.intType) {
+        var intValue = value.toIntValue();
+        return intValue != null ? js.number(intValue) : new JS.LiteralNull();
+      }
+      if (value.type == types.stringType) {
+        var stringValue = value.toStringValue();
+        return stringValue != null
+            ? js.escapedString(stringValue)
+            : new JS.LiteralNull();
+      }
+      throw new StateError('failed to evaluate $node');
+    }
     return _emitInstanceCreationExpression(
         element, type, name, node.argumentList, node.isConst);
   }
 
   /// True if this type is built-in to JS, and we use the values unwrapped.
   /// For these types we generate a calling convention via static
   /// "extension methods". This allows types to be extended without adding
   /// extensions directly on the prototype.
   bool isPrimitiveType(DartType t) =>
       typeIsPrimitiveInJS(t) || t == types.stringType;
@@ skipping 1622 matching lines @@
   var targetIdentifier = target as SimpleIdentifier;
 
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = (target.root as CompilationUnit).element.library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }