Refactor constant part.

frog/leg/ssa/codegen.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 SsaCodeGeneratorTask extends CompilerTask {
   SsaCodeGeneratorTask(Compiler compiler) : super(compiler);
   String get name() => 'SSA code generator';
 
   String generate(WorkItem work, HGraph graph) {
     return measure(() {
@@ skipping 619 matching lines @@
     // We can't use 'visitArguments', since our arguments start at input[0].
     List<HInstruction> inputs = node.inputs;
     for (int i = 0; i < inputs.length; i++) {
       if (i != 0) buffer.add(', ');
       use(inputs[i], JSPrecedence.ASSIGNMENT_PRECEDENCE);
     }
     buffer.add(')');
     endExpression(JSPrecedence.MEMBER_PRECEDENCE);
   }
 
-  visitLiteral(HLiteral node) {
-    if (node.isLiteralNull()) {
-      beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
-      buffer.add("void 0");
-      endExpression(JSPrecedence.PREFIX_PRECEDENCE);
-    } else if (node.value is num) {
-      int precedence = JSPrecedence.PRIMARY_PRECEDENCE;
-      if (node.value < 0 ||
-          expectedPrecedence == JSPrecedence.MEMBER_PRECEDENCE) {
-        // Negative constants are really unary minus operator expressions.
-        // If the constant appear as a MemberExpression, it might be subject
-        // to the '.' operator, which shouldn't be put next to a number
-        // literal. It might be mistaken for a decimal point. Setting
-        // precedence to PREFIX_PRECEDENCE forces parentheses in this case.
-        precedence = JSPrecedence.PREFIX_PRECEDENCE;
-      }
-      beginExpression(precedence);
-      buffer.add(node.value);
-      endExpression(precedence);
-    } else if (node.isLiteralString()) {
-      DartString string = node.value;
-      buffer.add("'");
-      CompileTimeConstantHandler.writeEscapedString(string, buffer,
-                                                    (String reason) {
-        compiler.cancel(reason, instruction: node);
-      });
-      buffer.add("'");
+  visitConstant(HConstant node) {
+    // TODO(floitsch): the compile-time constant handler and the codegen
+    // need to work together to avoid the parenthesis. See r4928 for an
+    // implementation that still dealt with precedence.
+    ConstantHandler handler = compiler.constantHandler;
+    String name = handler.getNameForConstant(node.constant);
+    if (name === null) {
+      assert(!node.constant.isObject());
+      node.constant.writeJsCode(buffer, handler);
     } else {
-      buffer.add(node.value);
+      buffer.add(compiler.namer.CURRENT_ISOLATE);
+      buffer.add(".");
+      buffer.add(name);      
     }
   }
 
   visitLoopBranch(HLoopBranch node) {
     HBasicBlock branchBlock = currentBlock;
     handleLoopCondition(node);
     List<HBasicBlock> dominated = currentBlock.dominatedBlocks;
     // For a do while loop, the body has already been visited.
     if (!node.isDoWhile()) {
       visitBasicBlock(dominated[0]);
@@ skipping 20 matching lines @@
     buffer.add(parameterNames[node.element]);
   }
 
   visitPhi(HPhi node) {
     unreachable();
   }
 
   visitReturn(HReturn node) {
     assert(node.inputs.length == 1);
     HInstruction input = node.inputs[0];
-    if (input.isLiteralNull()) {
+    if (input.isConstantNull()) {
       buffer.add('return;\n');
     } else {
       buffer.add('return ');
       use(node.inputs[0], JSPrecedence.EXPRESSION_PRECEDENCE);
       buffer.add(';\n');
     }
   }
 
   visitThis(HThis node) {
     buffer.add('this');
@@ skipping 658 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endElse(HIf node) {
     if (node.elseBlock.hasBailouts()) {
       endBailoutSwitch();
     }
   }
 }