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

frog/leg/compile_time_constants.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 Constant implements Hashable {
   const Constant();
 
   bool isNull() => false;
   /** [isInt] implies [isNum]. */
   bool isInt() => false;
   /** [isDouble] implies [isNum]. */
   bool isDouble() => false;
   bool isBool() => false;
   bool isString() => false;
   /** [isList] implies [isObject]. */
   bool isList() => false;
   /** [isMap] implies [isObject]. */
   bool isMap() => false;
   bool isConstructedObject() => false;
 
   bool isNum() => isInt() || isDouble();
   bool isObject() => isList() || isMap() || isConstructedObject();
+  bool isTrue() {
+    if (!isBool()) return false;
+    BoolConstant boolConstant = this;
+    return boolConstant.value;
+  }
+  bool isFalse() {
+    if (!isBool()) return false;
+    BoolConstant boolConstant = this;
+    return !boolConstant.value;
+  }
 
   /**
    * Returns [:null:] if the operation is not supported on this constant.
    * The [op] operator is assumed to be a prefix operator.
    */
   Constant unaryFold(String op) => null;
 
   /**
    * Returns [:null:] if the operation is not supported on this constant, or
    * if the operation would have thrown an exception.
    */
   Constant binaryFold(String op, Constant other) {
     if (op == "==" || op == "===") {
       return new BoolConstant(this == other);
     } else if (op == "!=" || op == "!==") {
       return new BoolConstant(this != other);
     }
   }
 
-  abstract void writeJsCode(StringBuffer buffer,
-                            CompileTimeConstantHandler handler);
+  abstract void writeJsCode(StringBuffer buffer, ConstantHandler handler);
 }
 
 class PrimitiveConstant extends Constant {
-  // TODO(floitsch): this should be an abstract getter, but there is a bug in
-  // the VM.
-  get value() => null;
+  abstract get value();
   const PrimitiveConstant();
 
   bool operator ==(var other) {
     if (other is !PrimitiveConstant) return false;
     PrimitiveConstant otherPrimitive = other;
     // We use == instead of === so that DartStrings compare correctly. 
     return value == otherPrimitive.value;
   }
+
+  String toString() => value.toString();
 }
 
 class NullConstant extends PrimitiveConstant {
   const NullConstant();
   bool isNull() => true;
   get value() => null;
 
-  void writeJsCode(StringBuffer buffer, CompileTimeConstantHandler handler) {
+  void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     buffer.add("(void 0)");
   }
 
   // The magic constant has no meaning. It is just a random value.
   int hashCode() => 785965825;
 }
 
 class IntConstant extends PrimitiveConstant {
   final int value;
   // TODO(floitsch): cache the most common integer values.
   const IntConstant(this.value);
   bool isInt() => true;
 
-  void writeJsCode(StringBuffer buffer, CompileTimeConstantHandler handler) {
+  void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     buffer.add("($value)");
   }
 
   IntConstant unaryFold(String op) {
     if (op == "-") return new IntConstant(-value);
     if (op == "~") return new IntConstant(~value);
     return null;
   }
 
   Constant binaryFold(String op, Constant other) {
@@ skipping 17 matching lines @@
           case "-": return new IntConstant(value - right);
           case "*": return new IntConstant(value * right);
           case "%": return new IntConstant(value % right);
           case "~/": return new IntConstant(value ~/ right);
           case "|": return new IntConstant(value | right);
           case "&": return new IntConstant(value & right);
           case "^": return new IntConstant(value ^ right);        
           case "<<":
             // TODO(floitsch): find a better way to guard against shifts to the
             // left.
-            if (right > 100) null;
-            if (right < 0) null;
+            if (right > 100) return null;
+            if (right < 0) return null;
             return new IntConstant(value << right);
           case ">>":
             if (right < 0) return null;
             return new IntConstant(value >> right);
         }
       } else if (other.isDouble()) {
         double right = rightNum;
         switch (op) {
           case "+": return new DoubleConstant(value + right);
           case "-": return new DoubleConstant(value - right);
@@ skipping 18 matching lines @@
   }
 
   int hashCode() => value.hashCode();
 }
 
 class DoubleConstant extends PrimitiveConstant {
   final double value;
   const DoubleConstant(this.value);
   bool isDouble() => true;
 
-  void writeJsCode(StringBuffer buffer, CompileTimeConstantHandler handler) {
+  void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     if (value.isNaN()) {
       buffer.add("(0/0)");
     } else if (value == double.INFINITY) {
       buffer.add("(1/0)");
     } else if (value == -double.INFINITY) {
       buffer.add("(-1/0)");
     } else {
       buffer.add("($value)");        
     }
   }
@@ skipping 42 matching lines @@
   }
 
   int hashCode() => value.hashCode();
 }
 
 class BoolConstant extends PrimitiveConstant {
   final bool value;
   const BoolConstant(this.value);
   bool isBool() => true;
 
-  void writeJsCode(StringBuffer buffer, CompileTimeConstantHandler handler) {
+  void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     buffer.add(value ? "true" : "false");
   }
 
   BoolConstant unaryFold(String op) {
     if (op == "!") return new BoolConstant(!value);
     return null;
   }
 
   bool operator ==(var other) {
     if (other is !BoolConstant) return false;
@@ skipping 10 matching lines @@
   final DartString value;
   int _hashCode;
 
   StringConstant(this.value) {
     // TODO(floitsch): compute hashcode without calling toString() on the
     // DartString.
     _hashCode = value.toString().hashCode();
   }
   bool isString() => true;
 
-  void writeJsCode(StringBuffer buffer, CompileTimeConstantHandler handler) {
+  void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     buffer.add("'");
-    CompileTimeConstantHandler.writeEscapedString(value, buffer, (reason) {
+    ConstantHandler.writeEscapedString(value, buffer, (reason) {
       throw new CompilerCancelledException(reason);
     });
     buffer.add("'");
   }
 
   Constant binaryFold(String op, Constant other) {
     if (other.isString() && op == "+") {
       StringConstant otherString = other;
       DartString right = otherString.value;
       return new StringConstant(new ConsDartString(value, right));
@@ skipping 22 matching lines @@
   int _hashCode;
 
   ListConstant(Type type, this.entries) : super(type) {
     // TODO(floitsch): create a better hash. 
     int hash = 0;
     for (Constant input in entries) hash ^= input.hashCode();
     _hashCode = hash;
   }
   bool isList() => true;
 
-  void writeJsCode(StringBuffer buffer, CompileTimeConstantHandler handler) {
+  void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     // TODO(floitsch): we should not need to go through the compiler to make
     // the list constant.
-    buffer.add(handler.compiler.namer.ISOLATE);
-    buffer.add(".prototype.makeConstantList");
+    String isolatePrototype = "${handler.compiler.namer.ISOLATE}.prototype";
+    buffer.add("$isolatePrototype.makeConstantList");
     buffer.add("([");
     for (int i = 0; i < entries.length; i++) {
       if (i != 0) buffer.add(", ");
       Constant entry = entries[i];
       if (entry.isObject()) {
-        handler.getNameForConstant(entry);
+        String name = handler.getNameForConstant(entry);
+        buffer.add("$isolatePrototype.$name");
       } else {
         entry.writeJsCode(buffer, handler);
       }
     }
     buffer.add("])");
   }
 
   bool operator ==(var other) {
     if (other is !ListConstant) return false;
     ListConstant otherList = other;
@@ skipping 18 matching lines @@
     // TODO(floitsch): create a better hash. 
     int hash = 0;
     for (Constant field in fields) {
       hash ^= field.hashCode();
     }
     hash ^= type.element.hashCode();
     _hashCode = hash;
   }
   bool isConstructedObject() => true;
 
-  void writeJsCode(StringBuffer buffer, CompileTimeConstantHandler handler) {
+  void writeJsCode(StringBuffer buffer, ConstantHandler handler) {
     buffer.add("new ");
     buffer.add(handler.getJsConstructor(type.element));
     buffer.add("(");
     for (int i = 0; i < fields.length; i++) {
       if (i != 0) buffer.add(", ");
       Constant field = fields[i];
       // TODO(floitsch): share this code with the ListConstant.
       if (field.isObject()) {
         handler.getNameForConstant(field);
       } else {
@@ skipping 13 matching lines @@
     for (int i = 0; i < fields.length; i++) {
       if (fields[i] != other.fields[i]) return false;
     }
     return true;
   }
 
   int hashCode() => _hashCode;
 }
 
 /**
- * The [CompileTimeConstantHandler] keeps track of compile-time constants,
+ * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
  */
-class CompileTimeConstantHandler extends CompilerTask {
+class ConstantHandler extends CompilerTask {
   // Contains the initial value of fields. Must contain all static and global
   // initializations of used fields. May contain caches for instance fields.
   final Map<VariableElement, Dynamic> initialVariableValues;
 
   // Map from compile-time constants to their JS name.
   final Map<Constant, String> compiledConstants;
 
-  CompileTimeConstantHandler(Compiler compiler)
+  ConstantHandler(Compiler compiler)
       : initialVariableValues = new Map<VariableElement, Dynamic>(),
         compiledConstants = new Map<Constant, String>(),
         super(compiler);
-  String get name() => 'CompileTimeConstantHandler';
+  String get name() => 'ConstantHandler';
 
   void registerCompileTimeConstant(Constant constant) {
     Function ifAbsentThunk = (() => compiler.namer.getFreshGlobalName("CTC"));
     compiledConstants.putIfAbsent(constant, ifAbsentThunk);
   }
 
   /**
    * Compiles the initial value of the given field and stores it in an internal
    * map.
    *
    * [WorkItem] must contain a [VariableElement] refering to a global or
    * static field.
    */
   void compileWorkItem(WorkItem work) {
     assert(work.element.kind == ElementKind.FIELD
            || work.element.kind == ElementKind.PARAMETER);
     VariableElement element = work.element;
     // Shortcut if it has already been compiled.
     if (initialVariableValues.containsKey(element)) return;
     compileVariableWithDefinitions(element, work.resolutionTree);
   }
 
   compileVariable(VariableElement element) {
     if (initialVariableValues.containsKey(element)) {
       Constant result = initialVariableValues[element];
-      // TODO(floitsch): remove the following line once the rest of the
-      // compiler has been adapted.
-      if (!result.isObject()) return result.dynamic.value;
       return result;
     }
     // TODO(floitsch): keep track of currently compiling elements so that we
     // don't end up in an infinite loop: final x = y; final y = x;
     TreeElements definitions = compiler.analyzeElement(element);
     Constant constant =  compileVariableWithDefinitions(element, definitions);
-    // TODO(floitsch): remove the following line once the rest of the
-    // compiler has been adapted.
-    if (!constant.isObject()) return constant.dynamic.value;
     return constant;
   }
 
   compileVariableWithDefinitions(VariableElement element,
                                  TreeElements definitions) {
     return measure(() {
       Node node = element.parseNode(compiler);
       assert(node !== null);
       SendSet assignment = node.asSendSet();
       var value;
       if (assignment === null) {
         // No initial value.
         value = const NullConstant();
       } else {
         Node right = assignment.arguments.head;
         CompileTimeConstantEvaluator evaluator =
             new CompileTimeConstantEvaluator(this, definitions, compiler);
         value = evaluator.evaluate(right);
       }
       initialVariableValues[element] = value;
       return value;
     });
   }
 
   ConstructedConstant compileObjectConstruction(Node node,
                                                 Type type,
                                                 List arguments) {
     if (!arguments.isEmpty()) {
-      compiler.unimplemented("CompileTimeConstantHandler with arguments",
-                             node: node);
+      compiler.unimplemented("ConstantHandler with arguments", node: node);
     }
     ClassElement classElement = type.element;
     for (Element member in classElement.members) {
       if (Elements.isInstanceField(member)) {
-        compiler.unimplemented("CompileTimeConstantHandler with fields",
-                               node: node);
+        compiler.unimplemented("ConstantHandler with fields", node: node);
       }
     }
     if (classElement.superclass != compiler.coreLibrary.find(Types.OBJECT)) {
-      compiler.unimplemented("CompileTimeConstantHandler with super",
-                             node: node);
+      compiler.unimplemented("ConstantHandler with super", node: node);
     }
     compiler.registerInstantiatedClass(classElement);
     Constant constant = new ConstructedConstant(type, arguments);
     registerCompileTimeConstant(constant);
     return constant;
   }
 
   ListConstant compileListLiteral(Node node,
                                   Type type,
                                   List<Constant> arguments) {
@@ skipping 116 matching lines @@
       }
     }
   }
 
   String getJsConstructor(ClassElement element) {
     return compiler.namer.isolatePropertyAccess(element);
   }
 }
 
 class CompileTimeConstantEvaluator extends AbstractVisitor {
-  final CompileTimeConstantHandler constantHandler;
+  final ConstantHandler constantHandler;
   final TreeElements definitions;
   final Compiler compiler;
 
   CompileTimeConstantEvaluator(this.constantHandler,
                                this.definitions,
                                this.compiler);
 
   Constant evaluate(Node node) {
     return node.accept(this);
   }
@@ skipping 42 matching lines @@
   }
 
   // TODO(floitsch): provide better error-messages.
   visitSend(Send send) {
     Element element = definitions[send];
     if (Elements.isStaticOrTopLevelField(element)) {
       if (element.modifiers === null ||
           !element.modifiers.isFinal()) {
         error(send);
       }
-      // TODO(floitsch): compileVariable temporarily returns primitives, so
-      // that the rest of the compiler can be adapted incrementally. Therefore
-      // we have to get the constant from the hashtable instead of using the
-      // returned result directly.
-      constantHandler.compileVariable(element);
-      return constantHandler.initialVariableValues[element];
+      return constantHandler.compileVariable(element);
     } else if (send.isPrefix) {
       assert(send.isOperator);
       Constant receiverConstant = evaluate(send.receiver);
       Operator op = send.selector;
       Constant folded = receiverConstant.unaryFold(op.source.stringValue);
       if (folded === null) error(send);
       return folded;
     } else if (send.isOperator && !send.isPostfix) {
       assert(send.argumentCount() == 1);
       Constant left = evaluate(send.receiver);
@@ skipping 33 matching lines @@
                                                      arguments);
   }
 
   error(Node node) {
     // TODO(floitsch): get the list of constants that are currently compiled
     // and present some kind of stack-trace.
     MessageKind kind = MessageKind.NOT_A_COMPILE_TIME_CONSTANT;
     compiler.reportError(node, new CompileTimeConstantError(kind, const []));
   }
 }