Avoid cyclic computations in compile-time constants.

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;
   bool isBool() => false;
   bool isTrue() => false;
@@ skipping 435 matching lines @@
 }
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
  */
 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;
+  final Map<VariableElement, Constant> initialVariableValues;
 
   // Map from compile-time constants to their JS name.
   final Map<Constant, String> compiledConstants;
 
+  // The set of variable elements that are in the process of being computed.
+  final Set<VariableElement> pendingVariables;
+
   ConstantHandler(Compiler compiler)
       : initialVariableValues = new Map<VariableElement, Dynamic>(),
         compiledConstants = new Map<Constant, String>(),
+        pendingVariables = new Set<Constant>(),
         super(compiler);
   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);
+    assert(pendingVariables.isEmpty());
   }
 
   compileVariable(VariableElement element) {
     if (initialVariableValues.containsKey(element)) {
       Constant result = initialVariableValues[element];
       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);
     return constant;
   }
 
   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 = new NullConstant();
       } else {
+        if (pendingVariables.contains(element)) {
+          MessageKind kind = MessageKind.CYCLIC_COMPILE_TIME_CONSTANTS;
+          compiler.reportError(node,
+                               new CompileTimeConstantError(kind, const []));
+        }
+        pendingVariables.add(element);
+
         Node right = assignment.arguments.head;
         CompileTimeConstantEvaluator evaluator =
             new CompileTimeConstantEvaluator(this, definitions, compiler);
         value = evaluator.evaluate(right);
+
+        pendingVariables.remove(element);
       }
       initialVariableValues[element] = value;
       return value;
     });
   }
 
   /**
    * Returns a [List] of static non final fields that need to be initialized.
    * The list must be evaluated in order since the fields might depend on each
    * other.
@@ skipping 472 matching lines @@
     return constant;
   }
 
   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 []));
   }
 }