Compute constants from IR nodes

pkg/compiler/lib/src/ssa/kernel_ast_adapter.dart

 // Copyright (c) 2016, 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 'package:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../compiler.dart';
@@ skipping 68 matching lines @@
     for (LocalFunctionElement localFunction in kernel.localFunctions.keys) {
       _nodeToElement[kernel.localFunctions[localFunction]] = localFunction;
     }
     for (TypeVariableElement typeVariable in kernel.typeParameters.keys) {
       _nodeToElement[kernel.typeParameters[typeVariable]] = typeVariable;
     }
     _typeConverter = new DartTypeConverter(this);
   }
 
   @override
-  ConstantValue computeConstantValue(ConstantExpression constant) {
-    return _compiler.constants.getConstantValue(constant);
+  ConstantValue computeConstantValue(ConstantExpression constant,
+      {bool requireConstant: true}) {
+    _compiler.backend.constants.evaluate(constant);
+    ConstantValue value =
+        _compiler.backend.constants.getConstantValue(constant);
+    if (value == null && requireConstant) {
+      throw new UnsupportedError(
+          'No constant value for ${constant.toStructuredText()}');
+    }
+    return value;
   }
 
   /// Called to find the corresponding Kernel element for a particular Element
   /// before traversing over it with a Kernel visitor.
   ir.Node getInitialKernelNode(MemberElement originTarget) {
     ir.Node target;
     if (originTarget.isPatch) {
       originTarget = originTarget.origin;
     }
     if (originTarget is MethodElement) {
@@ skipping 40 matching lines @@
 
   void assertAtResolvedAstFor(ir.Node node) {
     assert(invariant(getElement(node),
         _resolvedAst.element == getElement(node).declaration));
   }
 
   Compiler get _compiler => _backend.compiler;
   TreeElements get elements => _resolvedAst.elements;
   DiagnosticReporter get reporter => _compiler.reporter;
 
-  ConstantValue getConstantForSymbol(ir.SymbolLiteral node) {
-    if (kernel.syntheticNodes.contains(node)) {
-      return _backend.constantSystem
-          .createSymbol(_compiler.commonElements, node.value);
-    }
-    ast.Node astNode = getNode(node);
-    ConstantValue constantValue = _backend.constants
-        .getConstantValueForNode(astNode, _resolvedAst.elements);
-    assert(invariant(astNode, constantValue != null,
-        message: 'No constant computed for $node'));
-    return constantValue;
-  }
-
   // TODO(johnniwinther): Use the more precise functions below.
   Element getElement(ir.Node node) {
     Element result = _nodeToElement[node];
     assert(invariant(CURRENT_ELEMENT_SPANNABLE, result != null,
         message: "No element found for $node."));
     return result;
   }
 
   ConstructorElement getConstructor(ir.Member node) =>
       getElement(node).declaration;
@@ skipping 48 matching lines @@
       return _syntheticLocals.putIfAbsent(
           variable, () => new SyntheticLocal("x", null, null));
     }
     return getElement(variable) as LocalElement;
   }
 
   FunctionSignature getFunctionSignature(ir.FunctionNode function) {
     return getElement(function).asFunctionElement().functionSignature;
   }
 
-  ConstantValue getConstantFor(ir.Node node) {
-    // Some `null`s are not mapped when they correspond to errors, e.g. missing
-    // `const` initializers.
-    if (node is ir.NullLiteral) return new NullConstantValue();
-
-    ConstantValue constantValue =
-        _backend.constants.getConstantValueForNode(getNode(node), elements);
-    assert(invariant(getNode(node), constantValue != null,
-        message: 'No constant computed for $node'));
-    return constantValue;
-  }
-
-  ConstantValue getConstantForParameterDefaultValue(ir.Node defaultExpression) {
-    // TODO(27394): Evaluate constant expressions in ir.Node domain.
-    // In the interim, expand the Constantifier and do this:
-    //
-    //     ConstantExpression constantExpression =
-    //         defaultExpression.accept(new Constantifier(this));
-    //     assert(constantExpression != null);
-    ConstantExpression constantExpression =
-        kernel.parameterInitializerNodeToConstant[defaultExpression];
-    if (constantExpression == null) return null;
-    return _backend.constants.getConstantValue(constantExpression);
-  }
-
-  ConstantValue getConstantForType(ir.DartType irType) {
-    ResolutionDartType type = getDartType(irType);
-    return _backend.constantSystem
-        .createType(_compiler.commonElements, type.asRaw());
-  }
-
   // Is the member a lazy initialized static or top-level member?
   bool isLazyStatic(ir.Member member) {
     if (member is ir.Field) {
       FieldElement field = _nodeToElement[member];
       return field.constant == null;
     }
     return false;
   }
 
   KernelJumpTarget getJumpTarget(ir.TreeNode node,
@@ skipping 412 matching lines @@
   TypeMask selectorTypeOf(Selector selector, TypeMask mask) {
     return TypeMaskFactory.inferredTypeForSelector(
         selector, mask, _globalInferenceResults);
   }
 
   TypeMask typeFromNativeBehavior(
       native.NativeBehavior nativeBehavior, ClosedWorld closedWorld) {
     return TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
   }
 }