Reapply "Refactor constant part." (r4958) with fixes.

frog/leg/ssa/builder.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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 840 matching lines @@
     //                           the emitter.
     List<HInstruction> constructorArguments = <HInstruction>[];
     ClassElement element = classElement;
     while (element != null) {
       for (Element member in element.members) {
         if (member.isInstanceMember() && member.kind == ElementKind.FIELD) {
           HInstruction value;
           if (localsHandler.hasValueForDirectLocal(member)) {
             value = localsHandler.readLocal(member);
           } else {
-            var fieldValue =
-                compiler.compileTimeConstantHandler.compileVariable(member);
-            // TODO(floitsch): this constant should be treated like all
-            // other constants and should be at the top of the graph.
-            value = new HLiteral.internal(fieldValue, HType.UNKNOWN);
-            add(value);
+            Constant fieldValue =
+                compiler.constantHandler.compileVariable(member);
+            value = graph.addConstant(fieldValue);
           }
           constructorArguments.add(value);
         }
       }
       element = element.superclass;
     }
     HForeignNew newObject = new HForeignNew(classElement, constructorArguments);
     add(newObject);
     // Generate calls to the constructor bodies.
     for (int index = constructors.length - 1; index >= 0; index--) {
@@ skipping 432 matching lines @@
     visit(node.receiver);
     HNot not = new HNot(popBoolified());
     push(not);
   }
 
   void visitUnary(Send node, Operator op) {
     assert(node.argumentsNode is Prefix);
     visit(node.receiver);
     assert(op.token.kind !== PLUS_TOKEN);
     HInstruction operand = pop();
+    // See if we can constant-fold right away. This avoids rewrites later on.
+    if (operand is HConstant) {
+      HConstant typedOperand = operand;
+      Constant constant = typedOperand.constant;
+      Constant folded = constant.unaryFold(op.source.stringValue);
+      if (folded !== null) {
+        stack.add(graph.addConstant(folded));
+        return;
+      }      
+    }
     HInstruction target =
         new HStatic(interceptors.getPrefixOperatorInterceptor(op));
     add(target);
     switch (op.source.stringValue) {
-      case "-":
-        // TODO(kasperl): Avoid calling visit(node.receiver) above.
-        if ((operand is HLiteral) && (operand.value is double)) {
-          stack.add(graph.addNewLiteralDouble(-operand.value));
-        } else if ((operand is HLiteral) && (operand.value is int)) {
-          stack.add(graph.addNewLiteralInt(-operand.value));
-        } else {
-          push(new HNegate(target, operand));
-        }
-        break;
+      case "-": push(new HNegate(target, operand)); break;
       case "~": push(new HBitNot(target, operand)); break;
       default: unreachable();
     }
   }
 
   void visitBinary(HInstruction left, Operator op, HInstruction right) {
     Element element = interceptors.getOperatorInterceptor(op);
     assert(element != null);
     HInstruction target = new HStatic(element);
     add(target);
@@ skipping 287 matching lines @@
         for (int i = 0; i < selector.namedArguments.length; i++) {
           SourceString name = selector.namedArguments[i];
           if (name == parameter.name) {
             foundIndex = i;
             break;
           }
         }
         if (foundIndex != -1) {
           list.add(namedArguments[foundIndex]);
         } else {
-          // TODO(kasperl): This needs more work. Ideally these
-          // constants should be treated like any other constant and
-          // canonicalized by the graph methods.
-          var constant = compiler.compileVariable(parameter);
-          push(new HLiteral.internal(constant, HType.UNKNOWN));
-          list.add(pop());
+          Constant constant = compiler.compileVariable(parameter);
+          list.add(graph.addConstant(constant)); 
         }
       }
     }
   }
 
   void addGenericSendArgumentsToList(Link<Node> link, List<HInstruction> list) {
     for (; !link.isEmpty(); link = link.tail) {
       visit(link.head);
       list.add(pop());
     }
@@ skipping 214 matching lines @@
           HInstruction index;
           bool isCompoundAssignment = op.source.stringValue.endsWith('=');
           // Compound assignments are considered as being prefix.
           bool isPrefix = !node.isPostfix;
           Element getter = elements[node.selector];
           if (isCompoundAssignment) {
             value = pop();
             index = pop();
           } else {
             index = pop();
-            value = graph.addNewLiteralInt(1);
+            value = graph.addConstantInt(1);
           }
           HStatic indexMethod = new HStatic(interceptors.getIndexInterceptor());
           add(indexMethod);
           HInstruction left = new HIndex(indexMethod, receiver, index);
           add(left);
           Element opElement = elements[op];
           visitBinary(left, op, value);
           HInstruction assign = new HIndexAssign(
               target, receiver, index, pop());
           add(assign);
@@ skipping 20 matching lines @@
       Element element = elements[node];
       bool isCompoundAssignment = !node.arguments.isEmpty();
       bool isPrefix = !node.isPostfix;  // Compound assignments are prefix.
       generateGetter(node, elements[node.selector]);
       HInstruction left = pop();
       HInstruction right;
       if (isCompoundAssignment) {
         visit(node.argumentsNode);
         right = pop();
       } else {
-        right = graph.addNewLiteralInt(1);
+        right = graph.addConstantInt(1);
       }
       visitBinary(left, op, right);
       HInstruction operation = pop();
       assert(operation !== null);
       generateSetter(node, element, operation);
       if (!isPrefix) {
         pop();
         stack.add(left);
       }
     }
   }
 
   void visitLiteralInt(LiteralInt node) {
-    stack.add(graph.addNewLiteralInt(node.value));
+    stack.add(graph.addConstantInt(node.value));
   }
 
   void visitLiteralDouble(LiteralDouble node) {
-    stack.add(graph.addNewLiteralDouble(node.value));
+    stack.add(graph.addConstantDouble(node.value));
   }
 
   void visitLiteralBool(LiteralBool node) {
-    stack.add(graph.addNewLiteralBool(node.value));
+    stack.add(graph.addConstantBool(node.value));
   }
 
   void visitLiteralString(LiteralString node) {
-    stack.add(graph.addNewLiteralString(node.dartString));
+    stack.add(graph.addConstantString(node.dartString));
   }
 
   void visitLiteralStringJuxtaposition(LiteralStringJuxtaposition node) {
     visitLiteralString(node);
   }
 
   void visitLiteralNull(LiteralNull node) {
-    stack.add(graph.addNewLiteralNull());
+    stack.add(graph.addConstantNull());
   }
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty(); link = link.tail) {
       if (isAborted()) {
         compiler.reportWarning(link.head, 'dead code');
       } else {
         visit(link.head);
       }
     }
   }
 
   void visitParenthesizedExpression(ParenthesizedExpression node) {
     visit(node.expression);
   }
 
   visitOperator(Operator node) {
     // Operators are intercepted in their surrounding Send nodes.
     unreachable();
   }
 
   visitReturn(Return node) {
     HInstruction value;
     if (node.expression === null) {
-      value = graph.addNewLiteralNull();
+      value = graph.addConstantNull();
     } else {
       visit(node.expression);
       value = pop();
     }
     close(new HReturn(value)).addSuccessor(graph.exit);
   }
 
   visitThrow(Throw node) {
     if (node.expression === null) {
       HInstruction exception = rethrowableException;
       if (exception === null) {
-        exception = graph.addNewLiteralNull();
+        exception = graph.addConstantNull();
         compiler.reportError(node,
                              'throw without expression outside catch block');
       }
       close(new HThrow(exception, isRethrow: true));
     } else {
       visit(node.expression);
       close(new HThrow(pop()));
     }
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     compiler.internalError('visiting type annotation in SSA builder',
                            node: node);
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
     for (Link<Node> link = node.definitions.nodes;
          !link.isEmpty();
          link = link.tail) {
       Node definition = link.head;
       if (definition is Identifier) {
-        HInstruction initialValue = graph.addNewLiteralNull();
+        HInstruction initialValue = graph.addConstantNull();
         localsHandler.updateLocal(elements[definition], initialValue);
       } else {
         assert(definition is SendSet);
         visitSendSet(definition);
         pop();  // Discard value.
       }
     }
   }
 
   visitLiteralList(LiteralList node) {
@@ skipping 263 matching lines @@
     handleThen() {
       if (cases.head.statements.nodes.isEmpty()) {
         compiler.unimplemented('fall-through', node: cases.head);
       }
       visit(cases.head.statements);
       cases = cases.tail;
     }
     handleElse() {
       if (cases.isEmpty()) return;
       if (cases.head is DefaultCase) {
-        stack.add(graph.addNewLiteralBool(true));
+        stack.add(graph.addConstantBool(true));
         if (!cases.tail.isEmpty()) {
           compiler.unimplemented('default case not last', node: cases.head);
         }
       } else {
         SwitchCase switchCase = cases.head;
         visit(switchCase.expression);
         HInstruction caseExpression = pop();
         Element equalsHelper = compiler.findHelper(const SourceString('eq'));
         HInstruction target = new HStatic(equalsHelper);
         add(target);
@@ skipping 11 matching lines @@
 
     if (isAborted()) {
       compiler.unimplemented("SsaBuilder for loop with aborting body",
                              node: node);
     }
 
     HBasicBlock bodyExitBlock = close(new HGoto());
     HBasicBlock conditionBlock = addNewBlock();
     bodyExitBlock.addSuccessor(conditionBlock);
     open(conditionBlock);
-    stack.add(graph.addNewLiteralBool(false));
+    stack.add(graph.addConstantBool(false));
 
     conditionBlock = close(new HLoopBranch(popBoolified(),
                                            HLoopBranch.DO_WHILE_LOOP));
 
     conditionBlock.addSuccessor(loopEntryBlock);  // The back-edge.
     loopEntryBlock.postProcessLoopHeader();
 
     endLoop(loopEntryBlock, conditionBlock, breakHandler);
   }
 
@@ skipping 30 matching lines @@
         new HInvokeStatic(Selector.INVOCATION_1, inputs);
       add(unwrappedException);
 
       tryInstruction.exception = exception;
       Link<Node> link = node.catchBlocks.nodes;
 
       void pushCondition(CatchBlock catchBlock) {
         VariableDefinitions declaration = catchBlock.formals.nodes.head;
         HInstruction condition = null;
         if (declaration.type == null) {
-          condition = graph.addNewLiteralTrue();
+          condition = graph.addConstantBool(true);
           stack.add(condition);
         } else {
           Element typeElement = elements[declaration.type];
           if (typeElement == null) {
             compiler.cancel('Catch with unresolved type', node: catchBlock);
           }
           condition = new HIs(typeElement, unwrappedException, nullOk: true);
           push(condition);
         }
       }
@@ skipping 49 matching lines @@
   visitCatchBlock(CatchBlock node) {
     visit(node.block);
   }
 
   visitTypedef(Typedef node) {
     compiler.unimplemented('SsaBuilder.visitTypedef', node: node);
   }
 
   generateUnimplemented(String reason, [bool isExpression = false]) {
     DartString string = new DartString.literal(reason);
-    HInstruction message = graph.addNewLiteralString(string);
+    HInstruction message = graph.addConstantString(string);
 
     // Normally, we would call [close] here. However, then we hit
     // another unimplemented feature: aborting loop body. Simply
     // calling [add] does not work as it asserts that the instruction
     // isn't a control flow instruction. So we inline parts of [add].
     current.addAfter(current.last, new HThrow(message));
     if (isExpression) {
-      stack.add(graph.addNewLiteralNull());
+      stack.add(graph.addConstantNull());
     }
   }
 }