Handle more unqualified SendSets

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 59 matching lines @@
   /// Compiles the compile-time constant for the value [metadata], or reports an
   /// error if the value is not a compile-time constant.
   ///
   /// Depending on implementation, the constant compiler might also compute
   /// the compile-time constant for the backend interpretation of constants.
   ///
   /// The returned constant is always of the frontend interpretation.
   ConstantExpression compileMetadata(MetadataAnnotation metadata,
                                      Node node,
                                      TreeElements elements);
+
+  /// Evaluates [constant] and caches the result.
+  // TODO(johnniwinther): Remove when all constants are evaluated.
+  void evaluate(ConstantExpression constant);
 }
 
 /// A [BackendConstantEnvironment] provides access to constants needed for
 /// backend implementation.
 abstract class BackendConstantEnvironment extends ConstantEnvironment {
   /// Returns the compile-time constant value associated with [node].
   ///
   /// Depending on implementation, the constant might be stored in [elements].
   ConstantValue getConstantValueForNode(Node node, TreeElements elements);
 
@@ skipping 60 matching lines @@
 
   @override
   ConstantExpression getConstantForVariable(VariableElement element) {
     return initialVariableValues[element.declaration];
   }
 
   ConstantExpression compileConstant(VariableElement element) {
     return compileVariable(element, isConst: true);
   }
 
+  @override
+  void evaluate(ConstantExpression constant) {
+    constantValueMap.putIfAbsent(constant, () {
+      return constant.evaluate(
+          new _CompilerEnvironment(compiler),
+          constantSystem);
+    });
+  }
+
   ConstantExpression compileVariable(VariableElement element,
                                      {bool isConst: false}) {
 
     if (initialVariableValues.containsKey(element.declaration)) {
       ConstantExpression result = initialVariableValues[element.declaration];
       return result;
     }
     AstElement currentElement = element.analyzableElement;
     return compiler.withCurrentElement(currentElement, () {
       // TODO(johnniwinther): Avoid this eager analysis.
@@ skipping 1165 matching lines @@
           // TODO(johnniwinther): Return a [NonConstantValue] instead.
           new ErroneousConstantExpression(), new NullConstantValue());
 }
 
 // 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;
 }
+
+class _CompilerEnvironment implements Environment {
+  final Compiler compiler;
+
+  _CompilerEnvironment(this.compiler);
+
+  @override
+  String readFromEnvironment(String name) {
+    return compiler.fromEnvironment(name);
+  }
+}