Use ConstExp for storing constants.

sdk/lib/_internal/compiler/implementation/cps_ir/cps_ir_builder.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;
 
 import 'cps_ir_nodes.dart' as ir;
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
@@ skipping 309 matching lines @@
   }
 
   ir.Primitive continueWithExpression(ir.Expression build(ir.Continuation k)) {
     ir.Parameter v = new ir.Parameter(null);
     ir.Continuation k = new ir.Continuation([v]);
     ir.Expression expression = build(k);
     add(new ir.LetCont(k, expression));
     return v;
   }
 
-  ir.Constant makeConst(ConstExp exp, Constant value) {
-    return new ir.Constant(exp, value);
+  ir.Constant makeConst(ConstExp exp) {
+    return new ir.Constant(exp);
   }
 
   ir.Constant makePrimConst(PrimitiveConstant value) {
-    return makeConst(new PrimitiveConstExp(value), value);
+    return makeConst(new PrimitiveConstExp(value));
   }
 
   // TODO(johnniwinther): Build constants directly through [ConstExp] when these
   // are created from analyzer2dart.
   ir.Node buildPrimConst(PrimitiveConstant constant) {
     assert(isOpen);
     ir.Node prim = makePrimConst(constant);
     add(new ir.LetPrim(prim));
     return prim;
   }
@@ skipping 117 matching lines @@
   // assigned in the delimited subexpression to their reaching definition ---
   // that is, the definition in effect at the hole in 'current'.  These are
   // used to determine if a join-point continuation needs to be passed
   // arguments, and what the arguments are.
 
   /// A stack of collectors for breaks.
   final List<JumpCollector> breakCollectors;
   /// A stack of collectors for continues.
   final List<JumpCollector> continueCollectors;
 
-  ConstExpBuilder constantBuilder;
-
   final List<ConstDeclaration> localConstants;
 
   FunctionElement currentFunction;
   final DetectClosureVariables closureLocals;
 
   /// Construct a top-level visitor.
   IrBuilderVisitor(TreeElements elements, this.compiler, this.sourceFile)
       : breakCollectors = <JumpCollector>[],
         continueCollectors = <JumpCollector>[],
         localConstants = <ConstDeclaration>[],
         closureLocals = new DetectClosureVariables(elements),
         super(elements) {
     constantSystem = compiler.backend.constantSystem;
-    constantBuilder = new ConstExpBuilder(this);
   }
 
   /// Construct a delimited visitor for visiting a subtree.
   ///
   /// The delimited visitor has its own compile-time environment mapping
   /// local variables to their values, which is initially a copy of the parent
   /// environment.  It has its own context for building an IR expression, so
   /// the built expression is not plugged into the parent's context.
   IrBuilderVisitor.delimited(IrBuilderVisitor parent)
       : compiler = parent.compiler,
         sourceFile = parent.sourceFile,
         breakCollectors = parent.breakCollectors,
         continueCollectors = parent.continueCollectors,
-        constantBuilder = parent.constantBuilder,
         localConstants = parent.localConstants,
         currentFunction = parent.currentFunction,
         closureLocals = parent.closureLocals,
         super(parent.elements) {
     constantSystem = parent.constantSystem;
     returnContinuation = parent.returnContinuation;
     environment = new Environment.from(parent.environment);
   }
 
   /// Construct a visitor for a recursive continuation.
   ///
   /// The recursive continuation builder has fresh parameters (i.e. SSA phis)
   /// for all the local variables in the parent, because the invocation sites
   /// of the continuation are not all known when the builder is created.  The
   /// recursive invocations will be passed values for all the local variables,
   /// which may be eliminated later if they are redundant---if they take on
   /// the same value at all invocation sites.
   IrBuilderVisitor.recursive(IrBuilderVisitor parent)
       : compiler = parent.compiler,
         sourceFile = parent.sourceFile,
         breakCollectors = parent.breakCollectors,
         continueCollectors = parent.continueCollectors,
-        constantBuilder = parent.constantBuilder,
         localConstants = parent.localConstants,
         currentFunction = parent.currentFunction,
         closureLocals = parent.closureLocals,
         super(parent.elements) {
     constantSystem = parent.constantSystem;
     returnContinuation = parent.returnContinuation;
     parent.environment.index2variable.forEach(createParameter);
   }
 
   /**
@@ skipping 18 matching lines @@
     _root = _current = null;
 
     FunctionSignature signature = element.functionSignature;
     signature.orderedForEachParameter((ParameterElement parameterElement) {
       createParameter(parameterElement,
                       isClosureVariable: isClosureVariable(parameterElement));
     });
 
     List<ConstExp> defaults = new List<ConstExp>();
     signature.orderedOptionalParameters.forEach((ParameterElement element) {
-      if (element.initializer != null) {
-        defaults.add(constantBuilder.visit(element.initializer));
-      } else {
-        defaults.add(new PrimitiveConstExp(constantSystem.createNull()));
-      }
+      defaults.add(getConstantForVariable(element));
     });
 
     visit(function.body);
     return buildFunctionDefinition(element, localConstants, defaults);
   }
 
   ir.Primitive visit(ast.Node node) => node.accept(this);
 
   // ==== Statements ====
   // Build(Block(stamements), C) = C'
@@ skipping 464 matching lines @@
     return null;
   }
 
   ir.Primitive visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(isOpen);
     if (node.modifiers.isConst) {
       for (ast.SendSet definition in node.definitions.nodes) {
         assert(!definition.arguments.isEmpty);
         assert(definition.arguments.tail.isEmpty);
         VariableElement element = elements[definition];
-        ConstExp value = constantBuilder.visit(definition.arguments.head);
+        ConstExp value = getConstantForVariable(element);
         localConstants.add(new ConstDeclaration(element, value));
       }
     } else {
       for (ast.Node definition in node.definitions.nodes) {
         Element element = elements[definition];
         ir.Primitive initialValue;
         // Definitions are either SendSets if there is an initializer, or
         // Identifiers if there is no initializer.
         if (definition is ast.SendSet) {
           assert(!definition.arguments.isEmpty);
@@ skipping 100 matching lines @@
   ir.Primitive visitLiteralNull(ast.LiteralNull node) {
     assert(isOpen);
     return translateConstant(node);
   }
 
   ir.Primitive visitLiteralString(ast.LiteralString node) {
     assert(isOpen);
     return translateConstant(node);
   }
 
-  Constant getConstantForNode(ast.Node node) {
-    Constant constant =
+  ConstExp getConstantForNode(ast.Node node) {
+    ConstExp constant =
         compiler.backend.constantCompilerTask.compileNode(node, elements);
     assert(invariant(node, constant != null,
         message: 'No constant computed for $node'));
     return constant;
   }
 
+  ConstExp getConstantForVariable(VariableElement element) {
+    ConstExp constant =
+        compiler.backend.constants.getConstantForVariable(element);
+    assert(invariant(element, constant != null,
+            message: 'No constant computed for $element'));
+    return constant;
+  }
+
   ir.Primitive visitLiteralList(ast.LiteralList node) {
     assert(isOpen);
     if (node.isConst) {
       return translateConstant(node);
     }
     List<ir.Primitive> values = node.elements.nodes.mapToList(visit);
     GenericType type = elements.getType(node);
     ir.Primitive result = new ir.LiteralList(type, values);
     add(new ir.LetPrim(result));
     return result;
@@ skipping 534 matching lines @@
     var it = node.parts.iterator;
     while (it.moveNext()) {
       ast.StringInterpolationPart part = it.current;
       arguments.add(visit(part.expression));
       arguments.add(visitLiteralString(part.string));
     }
     return continueWithExpression(
         (k) => new ir.ConcatenateStrings(k, arguments));
   }
 
-  ir.Primitive translateConstant(ast.Node node, [Constant value]) {
+  ir.Primitive translateConstant(ast.Node node, [ConstExp constant]) {
     assert(isOpen);
-    if (value == null) {
-      value = getConstantForNode(node);
+    if (constant == null) {
+      constant = getConstantForNode(node);
     }
-    ir.Primitive primitive = makeConst(constantBuilder.visit(node), value);
+    ir.Primitive primitive = makeConst(constant);
     add(new ir.LetPrim(primitive));
     return primitive;
   }
 
   ir.FunctionDefinition makeSubFunction(ast.FunctionExpression node) {
     return new IrBuilderVisitor(elements, compiler, sourceFile)
            .buildFunctionInternal(elements[node]);
   }
 
   ir.Primitive visitFunctionExpression(ast.FunctionExpression node) {
@@ skipping 33 matching lines @@
       }
       rethrow;
     }
   }
 
   void internalError(String reason, {ast.Node node}) {
     giveup(node);
   }
 }
 
-/// Translates constant expressions from the AST to the [ConstExp] language.
-class ConstExpBuilder extends ast.Visitor<ConstExp> {
-  final IrBuilderVisitor parent;
-  final TreeElements elements;
-  final ConstantSystem constantSystem;
-  final ConstantCompiler constantCompiler;
-
-  ConstExpBuilder(IrBuilderVisitor parent)
-      : this.parent = parent,
-        this.elements = parent.elements,
-        this.constantSystem = parent.constantSystem,
-        this.constantCompiler = parent.compiler.backend.constantCompilerTask;
-
-  Constant computeConstant(ast.Node node) {
-    return constantCompiler.compileNode(node, elements);
-  }
-
-  /// True if the given constant is small enough that inlining it is likely
-  /// to be profitable. Always false for non-primitive constants.
-  bool isSmallConstant(Constant constant) {
-    if (constant is BoolConstant || constant is NullConstant) {
-      return true;
-    }
-    if (constant is IntConstant) {
-      return -10 < constant.value && constant.value < 100;
-    }
-    if (constant is DoubleConstant) {
-      return constant.isZero || constant.isOne;
-    }
-    if (constant is StringConstant) {
-      ast.DartString string = constant.value;
-      if (string is ast.LiteralDartString) {
-        return string.length < 4;
-      }
-      if (string is ast.SourceBasedDartString) {
-        return string.length < 4;
-      }
-    }
-    return false;
-  }
-
-  ConstExp visit(ast.Node node) => node.accept(this);
-
-  ConstExp visitStringJuxtaposition(ast.StringJuxtaposition node) {
-    ConstExp first = visit(node.first);
-    ConstExp second = visit(node.second);
-    return new ConcatenateConstExp([first, second]);
-  }
-
-  ConstExp visitStringInterpolation(ast.StringInterpolation node) {
-    List<ConstExp> arguments = <ConstExp>[];
-    arguments.add(visitLiteralString(node.string));
-    var it = node.parts.iterator;
-    while (it.moveNext()) {
-      ast.StringInterpolationPart part = it.current;
-      arguments.add(visit(part.expression));
-      arguments.add(visitLiteralString(part.string));
-    }
-    return new ConcatenateConstExp(arguments);
-  }
-
-  ConstExp visitNewExpression(ast.NewExpression node) {
-    FunctionElement element = elements[node.send];
-    if (Elements.isUnresolved(element)) {
-      throw parent.giveup(node, 'const NewExpression: unresolved constructor');
-    }
-    Selector selector = elements.getSelector(node.send);
-    ast.Node selectorNode = node.send.selector;
-    GenericType type = elements.getType(node);
-    List<ConstExp> args = node.send.arguments.mapToList(visit, growable:false);
-    return new ConstructorConstExp(type, element, selector, args);
-  }
-
-  ConstExp visitNamedArgument(ast.NamedArgument node) {
-    return visit(node.expression);
-  }
-
-  ConstExp visitSend(ast.Send node) {
-    Element element = elements[node];
-    if (node.isOperator) {
-      return new PrimitiveConstExp(computeConstant(node));
-    }
-    if (Elements.isStaticOrTopLevelFunction(element)) {
-      return new FunctionConstExp(element);
-    }
-    if (Elements.isLocal(element) ||
-        Elements.isStaticOrTopLevelField(element)) {
-      // If the constant is small, inline it instead of using the declared const
-      Constant value = constantCompiler.getConstantForVariable(element);
-      if (isSmallConstant(value))
-        return new PrimitiveConstExp(value);
-      else
-        return new VariableConstExp(element);
-    }
-    DartType type = elements.getTypeLiteralType(node);
-    if (type != null) {
-      return new TypeConstExp(type);
-    }
-    throw "Unexpected constant Send: $node";
-  }
-
-  ConstExp visitParenthesizedExpression(ast.ParenthesizedExpression node) {
-    return visit(node.expression);
-  }
-
-  ConstExp visitLiteralList(ast.LiteralList node) {
-    List<ConstExp> values = node.elements.nodes.mapToList(visit);
-    GenericType type = elements.getType(node);
-    return new ListConstExp(type, values);
-  }
-
-  ConstExp visitLiteralMap(ast.LiteralMap node) {
-    List<ConstExp> keys = new List<ConstExp>();
-    List<ConstExp> values = new List<ConstExp>();
-    node.entries.nodes.forEach((ast.LiteralMapEntry node) {
-      keys.add(visit(node.key));
-      values.add(visit(node.value));
-    });
-    GenericType type = elements.getType(node);
-    return new MapConstExp(type, keys, values);
-  }
-
-  ConstExp visitLiteralSymbol(ast.LiteralSymbol node) {
-    return new SymbolConstExp(node.slowNameString);
-  }
-
-  ConstExp visitLiteralInt(ast.LiteralInt node) {
-    return new PrimitiveConstExp(constantSystem.createInt(node.value));
-  }
-
-  ConstExp visitLiteralDouble(ast.LiteralDouble node) {
-    return new PrimitiveConstExp(constantSystem.createDouble(node.value));
-  }
-
-  ConstExp visitLiteralString(ast.LiteralString node) {
-    return new PrimitiveConstExp(constantSystem.createString(node.dartString));
-  }
-
-  ConstExp visitLiteralBool(ast.LiteralBool node) {
-    return new PrimitiveConstExp(constantSystem.createBool(node.value));
-  }
-
-  ConstExp visitLiteralNull(ast.LiteralNull node) {
-    return new PrimitiveConstExp(constantSystem.createNull());
-  }
-
-  ConstExp visitConditional(ast.Conditional node) {
-    BoolConstant condition = computeConstant(node.condition);
-    return visit(condition.isTrue ? node.thenExpression : node.elseExpression);
-  }
-
-  ConstExp visitNode(ast.Node node) {
-    throw "Unexpected constant: $node";
-  }
-
-}
-
 /// Classifies local variables and local functions as 'closure variables'.
 /// A closure variable is one that is accessed from an inner function nested
 /// one or more levels inside the one that declares it.
 class DetectClosureVariables extends ast.Visitor {
   final TreeElements elements;
   DetectClosureVariables(this.elements);
 
   FunctionElement currentFunction;
   Set<Local> usedFromClosure = new Set<Local>();
   Set<FunctionElement> recursiveFunctions = new Set<FunctionElement>();
@@ skipping 22 matching lines @@
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     FunctionElement oldFunction = currentFunction;
     currentFunction = elements[node];
     visit(node.body);
     currentFunction = oldFunction;
   }
 
 }