[cfe] Handle bool.hasEnvironment constructor in constant evaluation

.fromEnvironment environment constructor handling is updated to read
the default value from the declaration instead of hardcoding it.

Closes #41051
Closes #40501

Change-Id: I8eb4018dc7d6bea466a645d7762702914d9887db
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/139642
Reviewed-by: Jens Johansen <[email protected]>
Commit-Queue: Johnni Winther <[email protected]>

Author: johnniwinther

pkg/front_end/lib/src/fasta/builder/formal_parameter_builder.dart

@@ -14,6 +14,7 @@ import 'package:_fe_analyzer_shared/src/parser/parser.dart'
     show FormalParameterKind;
 
 import 'package:_fe_analyzer_shared/src/scanner/scanner.dart' show Token;
+import 'package:front_end/src/fasta/builder/procedure_builder.dart';
 
 import 'package:kernel/ast.dart'
     show DynamicType, Expression, VariableDeclaration;
@@ -171,8 +172,9 @@ class FormalParameterBuilder extends ModifierBuilderImpl
     // needed to generated noSuchMethod forwarders.
     bool isConstConstructorParameter = false;
     if (parent is ConstructorBuilder) {
-      ConstructorBuilder constructorBuilder = parent;
-      isConstConstructorParameter = constructorBuilder.constructor.isConst;
+      isConstConstructorParameter = parent.isConst;
+    } else if (parent is ProcedureBuilder) {
+      isConstConstructorParameter = parent.isFactory && parent.isConst;
     }
     if ((isConstConstructorParameter || parent.isClassInstanceMember) &&
         initializerToken != null) {

pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart

@@ -1843,25 +1843,34 @@ class ConstantEvaluator extends RecursiveVisitor<Constant> {
     return reportInvalid(node, 'Variable get of a non-const variable.');
   }
 
+  /// Computes the constant for [expression] defined in the context of [member].
+  ///
+  /// This compute the constant as seen in the current evaluation mode even when
+  /// the constant is defined in a library compiled with the agnostic evaluation
+  /// mode.
+  Constant _evaluateExpressionInContext(Member member, Expression expression) {
+    StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+    _staticTypeContext = new StaticTypeContext(member, typeEnvironment);
+    Constant constant = runInsideContext(member, () {
+      Constant constant = _evaluateSubexpression(expression);
+      if (_staticTypeContext.nonNullableByDefaultCompiledMode ==
+              NonNullableByDefaultCompiledMode.Agnostic &&
+          evaluationMode == EvaluationMode.weak) {
+        constant = _weakener.visitConstant(constant) ?? constant;
+      }
+      return constant;
+    });
+    _staticTypeContext = oldStaticTypeContext;
+    return constant;
+  }
+
   @override
   Constant visitStaticGet(StaticGet node) {
     return withNewEnvironment(() {
       final Member target = node.target;
       if (target is Field) {
         if (target.isConst) {
-          StaticTypeContext oldStaticTypeContext = _staticTypeContext;
-          _staticTypeContext = new StaticTypeContext(target, typeEnvironment);
-          Constant constant = runInsideContext(target, () {
-            Constant constant = _evaluateSubexpression(target.initializer);
-            if (_staticTypeContext.nonNullableByDefaultCompiledMode ==
-                    NonNullableByDefaultCompiledMode.Agnostic &&
-                evaluationMode == EvaluationMode.weak) {
-              constant = _weakener.visitConstant(constant) ?? constant;
-            }
-            return constant;
-          });
-          _staticTypeContext = oldStaticTypeContext;
-          return constant;
+          return _evaluateExpressionInContext(target, target.initializer);
         }
         return report(
             node,
@@ -1932,6 +1941,77 @@ class ConstantEvaluator extends RecursiveVisitor<Constant> {
     return canonicalize(new StringConstant(concatenated.single.toString()));
   }
 
+  Constant _getFromEnvironmentDefaultValue(Procedure target) {
+    VariableDeclaration variable = target.function.namedParameters
+        .singleWhere((v) => v.name == 'defaultValue');
+    return variable.initializer != null
+        ? _evaluateExpressionInContext(target, variable.initializer)
+        : nullConstant;
+  }
+
+  Constant _handleFromEnvironment(
+      Procedure target, StringConstant name, Map<String, Constant> named) {
+    String value = environmentDefines[name.value];
+    Constant defaultValue = named["defaultValue"];
+    if (target.enclosingClass == coreTypes.boolClass) {
+      Constant boolConstant;
+      if (value == "true") {
+        boolConstant = trueConstant;
+      } else if (value == "false") {
+        boolConstant = falseConstant;
+      } else if (defaultValue != null) {
+        if (defaultValue is BoolConstant) {
+          boolConstant = makeBoolConstant(defaultValue.value);
+        } else if (defaultValue is NullConstant) {
+          boolConstant = nullConstant;
+        } else {
+          boolConstant = falseConstant;
+        }
+      } else {
+        boolConstant = _getFromEnvironmentDefaultValue(target);
+      }
+      return boolConstant;
+    } else if (target.enclosingClass == coreTypes.intClass) {
+      int intValue = value != null ? int.tryParse(value) : null;
+      Constant intConstant;
+      if (intValue != null) {
+        bool negated = value.startsWith('-');
+        intConstant = intFolder.makeIntConstant(intValue, unsigned: !negated);
+      } else if (defaultValue != null) {
+        if (intFolder.isInt(defaultValue)) {
+          intConstant = defaultValue;
+        } else {
+          intConstant = nullConstant;
+        }
+      } else {
+        intConstant = _getFromEnvironmentDefaultValue(target);
+      }
+      return canonicalize(intConstant);
+    } else if (target.enclosingClass == coreTypes.stringClass) {
+      Constant stringConstant;
+      if (value != null) {
+        stringConstant = canonicalize(new StringConstant(value));
+      } else if (defaultValue != null) {
+        if (defaultValue is StringConstant) {
+          stringConstant = defaultValue;
+        } else {
+          stringConstant = nullConstant;
+        }
+      } else {
+        stringConstant = _getFromEnvironmentDefaultValue(target);
+      }
+      return stringConstant;
+    }
+    throw new UnsupportedError(
+        'Unexpected fromEnvironment constructor: $target');
+  }
+
+  Constant _handleHasEnvironment(StringConstant name) {
+    return environmentDefines.containsKey(name.value)
+        ? trueConstant
+        : falseConstant;
+  }
+
   @override
   Constant visitStaticInvocation(StaticInvocation node) {
     final Procedure target = node.target;
@@ -1947,45 +2027,18 @@ class ConstantEvaluator extends RecursiveVisitor<Constant> {
     }
     if (target.kind == ProcedureKind.Factory) {
       if (target.isConst &&
-          target.name.name == "fromEnvironment" &&
           target.enclosingLibrary == coreTypes.coreLibrary &&
-          positionals.length == 1) {
+          positionals.length == 1 &&
+          (target.name.name == "fromEnvironment" ||
+              target.name.name == "hasEnvironment")) {
         if (environmentDefines != null) {
           // Evaluate environment constant.
           Constant name = positionals.single;
           if (name is StringConstant) {
-            String value = environmentDefines[name.value];
-            Constant defaultValue = named["defaultValue"];
-
-            if (target.enclosingClass == coreTypes.boolClass) {
-              Constant boolConstant = value == "true"
-                  ? trueConstant
-                  : value == "false"
-                      ? falseConstant
-                      : defaultValue is BoolConstant
-                          ? makeBoolConstant(defaultValue.value)
-                          : defaultValue is NullConstant
-                              ? nullConstant
-                              : falseConstant;
-              return boolConstant;
-            } else if (target.enclosingClass == coreTypes.intClass) {
-              int intValue = value != null ? int.tryParse(value) : null;
-              Constant intConstant;
-              if (intValue != null) {
-                bool negated = value.startsWith('-');
-                intConstant =
-                    intFolder.makeIntConstant(intValue, unsigned: !negated);
-              } else if (intFolder.isInt(defaultValue)) {
-                intConstant = defaultValue;
-              } else {
-                intConstant = nullConstant;
-              }
-              return canonicalize(intConstant);
-            } else if (target.enclosingClass == coreTypes.stringClass) {
-              value ??=
-                  defaultValue is StringConstant ? defaultValue.value : null;
-              if (value == null) return nullConstant;
-              return canonicalize(new StringConstant(value));
+            if (target.name.name == "fromEnvironment") {
+              return _handleFromEnvironment(target, name, named);
+            } else {
+              return _handleHasEnvironment(name);
             }
           } else if (name is NullConstant) {
             return report(node, messageConstEvalNullValue);

pkg/vm/bin/kernel_service.dart

@@ -250,12 +250,20 @@ class CompilerResult {
 // new String.fromEnvironment, since the VM currently does not support providing
 // the full (isolate specific) environment as a finite, static map.
 class EnvironmentMap extends UnmodifiableMapBase<String, String> {
+  @override
+  bool containsKey(Object key) {
+    return new bool.hasEnvironment(key);
+  }
+
   @override
   String operator [](Object key) {
     // The fromEnvironment constructor is specified to throw when called using
     // new. However, the VM implementation actually looks up the given name in
     // the environment.
-    return new String.fromEnvironment(key);
+    if (containsKey(key)) {
+      return new String.fromEnvironment(key);
+    }
+    return null;
   }
 
   @override