Clean up handling of constants in the CPS backend.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 533 matching lines @@
     return irBuilder.buildConditional(
         build(node.condition),
         subbuild(node.thenExpression),
         subbuild(node.elseExpression));
   }
 
   // For all simple literals:
   // Build(Literal(c), C) = C[let val x = Constant(c) in [], x]
   ir.Primitive visitLiteralBool(ast.LiteralBool node) {
     assert(irBuilder.isOpen);
-    return translateConstant(node);
+    return irBuilder.buildBooleanConstant(node.value);
   }
 
   ir.Primitive visitLiteralDouble(ast.LiteralDouble node) {
     assert(irBuilder.isOpen);
-    return translateConstant(node);
+    return irBuilder.buildDoubleConstant(node.value);
   }
 
   ir.Primitive visitLiteralInt(ast.LiteralInt node) {
     assert(irBuilder.isOpen);
-    return translateConstant(node);
+    return irBuilder.buildIntegerConstant(node.value);
   }
 
   ir.Primitive visitLiteralNull(ast.LiteralNull node) {
     assert(irBuilder.isOpen);
-    return translateConstant(node);
+    return irBuilder.buildNullConstant();
   }
 
   ir.Primitive visitLiteralString(ast.LiteralString node) {
     assert(irBuilder.isOpen);
-    return translateConstant(node);
+    return irBuilder.buildDartStringConstant(node.dartString);
   }
 
   ConstantExpression getConstantForNode(ast.Node node) {
     ConstantExpression constant =
-        compiler.backend.constantCompilerTask.compileNode(node, elements);
+        compiler.backend.constants.getConstantForNode(node, elements);
     assert(invariant(node, constant != null,
         message: 'No constant computed for $node'));
     return constant;
   }
 
   ConstantExpression getConstantForVariable(VariableElement element) {
     ConstantExpression constant =
         compiler.backend.constants.getConstantForVariable(element);
     assert(invariant(element, constant != null,
             message: 'No constant computed for $element'));
@@ skipping 93 matching lines @@
   /// Returns `true` if [node] is a super call.
   // TODO(johnniwinther): Remove the need for this.
   bool isSuperCall(ast.Send node) {
     return node != null && node.receiver != null && node.receiver.isSuper();
   }
 
   @override
   ir.Primitive handleConstantGet(
       ast.Node node,
       ConstantExpression constant, _) {
-    return irBuilder.buildConstantLiteral(constant);
+    return irBuilder.buildConstant(constant);
   }
 
   /// If [node] is null, returns this.
   /// Otherwise visits [node] and returns the result.
   ir.Primitive translateReceiver(ast.Expression node) {
     return node != null ? visit(node) : irBuilder.buildThis();
   }
 
   @override
   ir.Primitive handleDynamicGet(
       ast.Send node,
       ast.Node receiver,
       Selector selector,
       _) {
     return irBuilder.buildDynamicGet(
         translateReceiver(receiver),
         selector);
   }
 
   @override
   ir.Primitive visitDynamicTypeLiteralGet(
       ast.Send node,
       ConstantExpression constant,
       _) {
-    return irBuilder.buildConstantLiteral(constant);
+    return irBuilder.buildConstant(constant);
   }
 
   @override
+  ir.Primitive visitLocalVariableGet(
+      ast.Send node,
+      LocalVariableElement element,
+      _) {
+    return element.isConst
+        ? irBuilder.buildConstant(getConstantForVariable(element))
+        : irBuilder.buildLocalVariableGet(element);
+  }
+
+  @override
   ir.Primitive handleLocalGet(
       ast.Send node,
       LocalElement element,
       _) {
-    if (element.isConst) {
-      return translateConstant(node);
-    }
     return irBuilder.buildLocalVariableGet(element);
   }
 
   @override
   ir.Primitive visitLocalFunctionGet(
       ast.Send node,
       LocalFunctionElement function,
       _) {
     return irBuilder.buildLocalFunctionGet(function);
   }
 
   @override
-  ir.Primitive handleStaticFieldGet(
-      ast.Send node,
-      FieldElement field,
-      _) {
-    if (field.isConst) {
-      return translateConstant(node);
-    }
-    return irBuilder.buildStaticFieldGet(field,
-        sourceInformation: sourceInformationBuilder.buildGet(node));
+  ir.Primitive handleStaticFieldGet(ast.Send node, FieldElement field, _) {
+    return field.isConst
+        ? irBuilder.buildConstant(getConstantForVariable(field))
+        : irBuilder.buildStaticFieldGet(field,
+              sourceInformation: sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive handleStaticFunctionGet(
       ast.Send node,
       MethodElement function,
       _) {
     // TODO(karlklose): support foreign functions.
     if (function.isForeign(compiler.backend)) {
       return giveup(node, 'handleStaticFunctionGet: foreign: $function');
     }
-    return translateConstant(node);
+    return giveup(node, 'handleStaticFunctionGet: $function');
   }
 
   @override
   ir.Primitive handleStaticGetterGet(
       ast.Send node,
       FunctionElement getter,
       _) {
     return irBuilder.buildStaticGetterGet(getter);
   }
 
@@ skipping 245 matching lines @@
         translateDynamicArguments(arguments, callStructure));
   }
 
   @override
   ir.Primitive handleConstantInvoke(
       ast.Send node,
       ConstantExpression constant,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
-    return translateCallInvoke(
-        irBuilder.buildConstantLiteral(constant),
-        arguments,
-        callStructure);
+    ir.Primitive target = irBuilder.buildConstant(constant);
+    return translateCallInvoke(target, arguments, callStructure);
   }
 
   @override
   ir.Primitive handleDynamicInvoke(
       ast.Send node,
       ast.Node receiver,
       ast.NodeList arguments,
       Selector selector,
       _) {
     return irBuilder.buildDynamicInvocation(
@@ skipping 51 matching lines @@
         sourceInformation: sourceInformationBuilder.buildCall(node));
   }
 
   @override
   ir.Primitive handleStaticGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
+    if (getter.isForeign(compiler.backend)) {
+      return giveup(node, 'handleStaticGetterInvoke: foreign: $getter');
+    }
     ir.Primitive target = irBuilder.buildStaticGetterGet(getter);
     return irBuilder.buildCallInvocation(target,
         callStructure,
         translateDynamicArguments(arguments, callStructure));
   }
 
   @override
   ir.Primitive visitSuperFieldInvoke(
       ast.Send node,
       FieldElement field,
@@ skipping 125 matching lines @@
 
   ir.Primitive translatePrefixPostfix(
       {ir.Primitive getValue(),
        op.IncDecOperator operator,
        void setValue(ir.Primitive value),
        bool isPrefix}) {
     ir.Primitive value = getValue();
     Selector operatorSelector =
         new Selector.binaryOperator(operator.selectorName);
     List<ir.Primitive> arguments =
-        <ir.Primitive>[irBuilder.buildIntegerLiteral(1)];
+        <ir.Primitive>[irBuilder.buildIntegerConstant(1)];
     arguments = normalizeDynamicArguments(
         operatorSelector.callStructure, arguments);
     ir.Primitive result =
         irBuilder.buildDynamicInvocation(value, operatorSelector, arguments);
     setValue(result);
     return isPrefix ? result : value;
   }
 
   ir.Primitive translateCompound(
       {ir.Primitive getValue(),
@@ skipping 506 matching lines @@
     while (it.moveNext()) {
       ast.StringInterpolationPart part = it.current;
       arguments.add(visit(part.expression));
       arguments.add(visitLiteralString(part.string));
     }
     return irBuilder.buildStringConcatenation(arguments);
   }
 
   ir.Primitive translateConstant(ast.Node node) {
     assert(irBuilder.isOpen);
-    return irBuilder.buildConstantLiteral(getConstantForNode(node));
+    return irBuilder.buildConstant(getConstantForNode(node));
   }
 
   ir.Primitive visitThrow(ast.Throw node) {
     assert(irBuilder.isOpen);
     // This function is not called for throw expressions occurring as
     // statements.
     return irBuilder.buildNonTailThrow(visit(node.expression));
   }
 
   ir.RootNode nullIfGiveup(ir.RootNode action()) {
@@ skipping 628 matching lines @@
     ClassElement enclosingClass = constructor.enclosingClass.implementation;
     enclosingClass.forEachInstanceField((ClassElement c, FieldElement field) {
       if (field.initializer != null) {
         fieldValues[field] = inlineExpression(field, field.initializer);
       } else {
         if (Elements.isNativeOrExtendsNative(c)) {
           // Native field is initialized elsewhere.
         } else {
           // Fields without an initializer default to null.
           // This value will be overwritten below if an initializer is found.
-          fieldValues[field] = irBuilder.buildNullLiteral();
+          fieldValues[field] = irBuilder.buildNullConstant();
         }
       }
     });
     // Evaluate initializing parameters, e.g. `Foo(this.x)`.
     constructor.functionSignature.orderedForEachParameter(
         (ParameterElement parameter) {
       if (parameter.isInitializingFormal) {
         InitializingFormalElement fieldParameter = parameter;
         fieldValues[fieldParameter.fieldElement] =
             irBuilder.buildLocalVariableGet(parameter);
@@ skipping 69 matching lines @@
           value = arguments[translatedIndex];
         }
       } else if (index < arguments.length) {
         value = arguments[index];
       }
       // Load default if argument was not provided.
       if (value == null) {
         if (param.initializer != null) {
           value = inlineExpression(target, param.initializer);
         } else {
-          value = irBuilder.buildNullLiteral();
+          value = irBuilder.buildNullConstant();
         }
       }
       irBuilder.declareLocalVariable(param, initialValue: value);
       index++;
     });
   }
 
   /**
    * Returns the constructor body associated with the given constructor or
    * creates a new constructor body, if none can be found.
@@ skipping 127 matching lines @@
         elements);
     DartCapturedVariables variables = _analyzeCapturedVariables(node);
     tryStatements = variables.tryStatements;
     IrBuilder builder = getBuilderFor(element);
     return withBuilder(builder, () => _makeFunctionBody(element, node));
   }
 
   /// Creates a primitive for the default value of [parameter].
   ir.Primitive translateDefaultValue(ParameterElement parameter) {
     if (parameter.initializer == null) {
-      return irBuilder.buildNullLiteral();
+      return irBuilder.buildNullConstant();
     } else {
       return inlineConstant(parameter.executableContext, parameter.initializer);
     }
   }
 
   /// Inserts default arguments and normalizes order of named arguments.
   List<ir.Primitive> normalizeStaticArguments(
       CallStructure callStructure,
       FunctionElement target,
       List<ir.Primitive> arguments) {
@@ skipping 190 matching lines @@
   }
 }
 
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends ir.RecursiveVisitor {
   processReference(ir.Reference reference) {
     reference.unlink();
   }
 }