Issue 4543. Use complete Resolver before constants analyzer

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

 // 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.
 
 package com.google.dart.compiler.resolver;
 
 import static com.google.dart.compiler.common.ErrorExpectation.errEx;
 
 import com.google.common.base.Joiner;
 
@@ skipping 63 matching lines @@
             "}",
             "class A {",
             " var f1 = new Val(1);",
             " var f2 = this;",
             " var f3 = new Val(f1);",
             "}",
             "class B extends A {",
             " var f2 = new Val(f3);",
             "}",
             ""),
-        errEx(ResolverErrorCode.CANNOT_USE_THIS_IN_INSTANCE_FIELD_INITIALIZER, 8, 11, 4),
+        errEx(ResolverErrorCode.THIS_OUTSIDE_OF_METHOD, 8, 11, 4),
         errEx(ResolverErrorCode.CANNOT_USE_INSTANCE_FIELD_IN_INSTANCE_FIELD_INITIALIZER, 9, 19, 2),
         errEx(ResolverErrorCode.CANNOT_USE_INSTANCE_FIELD_IN_INSTANCE_FIELD_INITIALIZER, 12, 19, 2));
   }
 
   /**
    * We can reference top-level fields, because they are static.
    * <p>
    * http://code.google.com/p/dart/issues/detail?id=4400
    */
   public void test_instanceVariable_nonConstInitializer_topLevelField() {
@@ skipping 50 matching lines @@
   public void test_constConstructor_superInvocation() throws Exception {
     resolveAndTestCtConstExpectErrors(
         Joiner.on("\n").join(
             "// filler filler filler filler filler filler filler filler filler filler",
             "class Object {}",
             "class A {",
             "  final v;",
             "  const A(this.v);",
             "}",
             "class B extends A {",
-            "  const A() : super(generateValue());",
+            "  const B() : super(generateValue());",
             "  static generateValue() => 42;",
             "}",
             ""),
         errEx(ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION, 8, 21, 15));
   }
 
   /**
    * At compile time we "trust" user that parameter will have correct type.
    */
   public void test_constConstructor_constInitializerValue_plusDynamic() {
@@ skipping 37 matching lines @@
             "   c = 1 & null,",
             "   d = ~null,",
             "   e = -null;",
             "}",
             ""));
   }
 
   public void test_nonConstantExpressions() {
     resolveAndTestCtConstExpectErrors(
         Joiner.on("\n").join(
-            "class Object {}",
             "var x = 0;",
             "const c1 = const {'$x' : 1};",
             "const c2 = const {'key': []};",
-            "const c3 = const [new Object()];"),
-            errEx(ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION, 3, 21, 1),
-            errEx(ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION, 4, 26,2),
-            errEx(ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION, 5, 19, 12));
+            "const c3 = const [new Object()];",
+            "class Object {}",
+            "class String {}",
+            ""),
+            errEx(ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION, 2, 21, 1),
+            errEx(ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION, 3, 26,2),
+            errEx(ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION, 4, 19, 12));
   }
 
   public void test_expressionsWithNull() {
     resolveAndTestCtConst(Joiner.on("\n").join(
         "class Object {}",
         "var b = null === '';"));
   }
 
   public void test_parameterDefaultValue_inLocalFunction() {
     resolveAndTestCtConstExpectErrors(
         Joiner.on("\n").join(
             "// filler filler filler filler filler filler filler filler filler filler",
-            "class Object {}",
             "main() {",
             " int x = 1;",
             " void func([var y = x]) {}",
             "}",
+            "class Object {}",
+            "class int {}",
             ""),
-        errEx(ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION, 5, 21, 1));
+        errEx(ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION, 4, 21, 1));
   }
 
   public void test_stringInterpolation_referenceConstVar_num() {
     resolveAndTestCtConstExpectErrors(Joiner.on("\n").join(
         "// filler filler filler filler filler filler filler filler filler filler",
         "class Object {}",
         "final a = 'aaa';",
         "final v = '$a';",
         ""));
   }
@@ skipping 14 matching lines @@
         "final a = false;",
         "final v = '$a';",
         ""));
   }
 
   public void test_stringInterpolation_referenceConstVar_Object() {
     resolveAndTestCtConstExpectErrors(
         Joiner.on("\n").join(
             "// filler filler filler filler filler filler filler filler filler filler",
             "class Object {}",
-            "final a = const Object();",
+            "class C {",
+            "  const C();",
+            "}",
+            "final a = const C();",
             "final v = '$a';",
             ""),
-        errEx(ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION_STRING_NUMBER_BOOL, 4, 13, 1));
+        errEx(ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION_STRING_NUMBER_BOOL, 7, 13, 1));
   }
 
   public void test_stringInterpolation_inMethod() {
     resolveAndTestCtConstExpectErrors(Joiner.on("\n").join(
         "// filler filler filler filler filler filler filler filler filler filler",
         "class Object {}",
         "class Conster {",
         "  const Conster(this.value);",
         "  final value;",
         "}",
@@ skipping 97 matching lines @@
     resolveAndTestCtConstExpectErrors(
         Joiner.on("\n").join(
             "// filler filler filler filler filler filler filler filler filler filler",
             "class Object {}",
             "class A {",
             "  m() {}",
             "  static final V1 = m;",
             "}",
             "final V2 = A.m;",
             ""),
+        errEx(ResolverErrorCode.ILLEGAL_METHOD_ACCESS_FROM_STATIC, 5, 21, 1),
+        errEx(ResolverErrorCode.NOT_A_STATIC_METHOD, 7, 14, 1),
         errEx(ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION, 5, 21, 1),
         errEx(ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION, 7, 12, 3));
   }
 
   public void testConstantBinaryExpression12() {
     // Multiple binary expressions
     resolveAndTestCtConst(Joiner.on("\n").join(
         "class Object {}",
         "class A {",
         "  static final INT_LIT = 5;",
@@ skipping 254 matching lines @@
         "  static final person = 'earthling';",
         "  static final s = 'Hello ${foo()}!';",
         "}"),
         ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION,
         ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION_STRING_NUMBER_BOOL);
   }
 
   public void testConstantTypedLiteralAssign1() {
     resolveAndTestCtConst(Joiner.on("\n").join(
         "class Object {}",
+        "class String {}",
         "class List<T> {}",
         "class Map<K,V> {}",
         "class A {",
         "  static final aList = const[1, 2, 3];", // array literal
         "  static final map = const { '1': 'one', '2': 'banana' };", // map literal
         "  static final val = aList[2];",
         "}"));
   }
 
   public void testConstantTypedLiteralAssign2() {
@@ skipping 15 matching lines @@
         "  static foo() { return 1; }",
         "  // const array literal contains non-const member",
         "  static final aList = const [foo(), 2, 3];",
         "}"),
         ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION);
   }
 
   public void testConstantTypedLiteralAssign4() {
     resolveAndTestCtConst(Joiner.on("\n").join(
         "class Object {}",
+        "class String {}",
         "class Map<K,V> {}",
         "class A {",
         "  // map literal is not const",
         "  static final aMap = { '1': 'one', '2': 'banana' };",
         "}"),
         ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION);
   }
   public void testConstantTypedLiteralAssign5() {
     resolveAndTestCtConst(Joiner.on("\n").join(
         "class Object {}",
@@ skipping 241 matching lines @@
             "interface int {}",
             "class A {",
             "  static final int value7 = ('Invalid') / 1;",
             "  static final int value8 = value7 & 0xFFFF;",                        
             "}"),
             errEx(ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION_NUMBER, 4, 29, 11),
             errEx(ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION_NUMBER, 4, 29, 11),
             errEx(ResolverErrorCode.EXPECTED_CONSTANT_EXPRESSION_INT, 5, 29, 6));            
   }
 }