Compile Time Constants cycle check

compiler/javatests/com/google/dart/compiler/resolver/ResolverTestCase.java

 // Copyright (c) 2011, 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.
 
 package com.google.dart.compiler.resolver;
 
 import com.google.common.base.Joiner;
 import com.google.common.base.Splitter;
 import com.google.common.collect.Lists;
 import com.google.dart.compiler.DartCompilationError;
@@ skipping 31 matching lines @@
   @Override
   public void setUp() {
     resetParseErrors();
   }
 
   @Override
   public void tearDown() {
     resetParseErrors();
   }
 
+  private static CoreTypeProvider setupTypeProvider(DartUnit unit, TestCompilerContext context, Scope scope) {
+    new TopLevelElementBuilder().exec(unit, context);
+    new TopLevelElementBuilder().fillInUnitScope(unit, context, scope);
+    ClassElement object = (ClassElement) scope.findElement(null, "Object");
+    assertNotNull("Cannot resolve Object", object);
+    return new MockCoreTypeProvider(object);
+  }
+
   static Scope resolve(DartUnit unit, TestCompilerContext context) {
     Scope scope = new Scope("library", null);
-    new TopLevelElementBuilder().exec(unit, context);
-    new TopLevelElementBuilder().fillInUnitScope(unit, context, scope);
-    ClassElement object = (ClassElement) scope.findElement(null, "Object");
-    assertNotNull("Cannot resolve Object", object);
-    CoreTypeProvider typeProvider = new MockCoreTypeProvider(object);
+    CoreTypeProvider typeProvider = setupTypeProvider(unit, context, scope);
     new SupertypeResolver().exec(unit, context, scope, typeProvider);
     new MemberBuilder().exec(unit, context, scope, typeProvider);
     new Resolver(context, scope, typeProvider).exec(unit);
     return scope;
   }
 
+  static Scope resolveCompileTimeConst (DartUnit unit, TestCompilerContext context) {
+    Scope scope = new Scope("library", null);
+    CoreTypeProvider typeProvider = setupTypeProvider(unit, context, scope);
+    new SupertypeResolver().exec(unit, context, scope, typeProvider);
+    new MemberBuilder().exec(unit, context, scope, typeProvider);
+    // Substitute the lightweight CTConst resolver
+    new CompileTimeConstantResolver().exec(unit, context, scope, typeProvider);
+    new CompileTimeConstantAnalyzer(typeProvider, context).exec(unit);
+    return scope;
+  }
+
+
   static DartClass makeClass(String name, DartTypeNode supertype, String... typeParameters) {
     return makeClass(name, supertype, Collections.<DartTypeNode>emptyList(), typeParameters);
   }
 
   static DartClass makeClass(String name, DartTypeNode supertype, List<DartTypeNode> interfaces,
       String... typeParameters) {
     List<DartTypeParameter> parameterNodes = new ArrayList<DartTypeParameter>();
     for (String parameter : typeParameters) {
       parameterNodes.add(makeTypeVariable(parameter));
     }
@@ skipping 283 matching lines @@
       for (String line : Splitter.on("\n").split(source)) {
         System.out.println(String.format(" %02d: %s", count++, line));
       }
     }
   }
   /**
    * For debugging.
    */
   protected void printEncountered(List<DartCompilationError> encountered) {
     for (DartCompilationError error : encountered) {
-      ErrorCode errorCode = (ErrorCode) error.getErrorCode();
+      ErrorCode errorCode = error.getErrorCode();
       String msg =
           String.format(
               "%s > %s (%d:%d)",
               errorCode.toString(),
               error.getMessage(),
               error.getLineNumber(),
               error.getColumnNumber());
       System.out.println(msg);
     }
   }
 
   /**
    * Convenience method to parse and resolve a code snippet, then test for error codes.
-   * 
+   *
    * @return resolve errors.
    */
   protected List<DartCompilationError> resolveAndTest(String source, ErrorCode... errorCodes) {
     // parse DartUnit
     DartUnit unit = parseUnit(source);
     if (parseErrors.size() != 0) {
       printSource(source);
       printEncountered(parseErrors);
       assertEquals("Expected no errors in parse step:", 0, parseErrors.size());
     }
     // prepare for recording resolving errors
     resetParseErrors();
     final List<DartCompilationError> resolveErrors = Lists.newArrayList();
     TestCompilerContext ctx =  new TestCompilerContext() {
       @Override
       public void onError(DartCompilationError event) {
         resolveErrors.add(event);
       }
     };
     // resolve and check errors
     resolve(unit, ctx);
     checkExpectedErrors(resolveErrors, errorCodes, source);
     return resolveErrors;
   }
+
+  /**
+   * Convenience method to parse and resolve a code snippet, then test for error codes.
+   *
+   * @return resolve errors.
+   */
+  protected List<DartCompilationError> resolveAndTestCtConst(String source, ErrorCode... errorCodes) {
+    // parse DartUnit
+    DartUnit unit = parseUnit(source);
+    if (parseErrors.size() != 0) {
+      printSource(source);
+      printEncountered(parseErrors);
+      assertEquals("Expected no errors in parse step:", 0, parseErrors.size());
+    }
+    // prepare for recording resolving errors
+    resetParseErrors();
+    final List<DartCompilationError> resolveErrors = Lists.newArrayList();
+    TestCompilerContext ctx =  new TestCompilerContext() {
+      @Override
+      public void onError(DartCompilationError event) {
+        resolveErrors.add(event);
+      }
+    };
+    // resolve and check errors
+    resolveCompileTimeConst(unit, ctx);
+    checkExpectedErrors(resolveErrors, errorCodes, source);
+    return resolveErrors;
+  }
 }