Issue 4543. Use complete Resolver before constants analyzer

compiler/java/com/google/dart/compiler/resolver/Resolver.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 com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import com.google.dart.compiler.DartCompilationPhase;
@@ skipping 166 matching lines @@
    *  - A local variable shadowing a class member.
    *  - Using 'this' or 'super' in a static or factory method, or in an initializer.
    *  - Using 'super' in a class without a super class.
    *  - Incorrectly using a resolved element.
    */
   @VisibleForTesting
   public class ResolveElementsVisitor extends ResolveVisitor {
     private EnclosingElement currentHolder;
     private EnclosingElement enclosingElement;
     private MethodElement currentMethod;
+    private boolean inInstanceVariableInitializer;
     private boolean inInitializer;
     private MethodElement innermostFunction;
     private ResolutionContext context;
     private Set<LabelElement> referencedLabels = Sets.newHashSet();
     private Set<LabelElement> labelsInScopes = Sets.newHashSet();
     private Set<FieldElement> finalsNeedingInitializing = Sets.newHashSet();
 
     @VisibleForTesting
     public ResolveElementsVisitor(ResolutionContext context,
                                   EnclosingElement currentHolder,
@@ skipping 458 matching lines @@
 
     @Override
     public Element visitField(DartField node) {
       DartExpression expression = node.getValue();
       Modifiers modifiers = node.getModifiers();
       boolean isFinal = modifiers.isFinal();
       boolean isTopLevel = ElementKind.of(currentHolder).equals(ElementKind.LIBRARY);
       boolean isStatic = modifiers.isStatic();
 
       if (expression != null) {
-        resolve(expression);
+        inInstanceVariableInitializer = !isTopLevel;
+        try {
+          resolve(expression);
+        } finally {
+          inInstanceVariableInitializer = false;
+        }
         // Now, this constant has a type. Save it for future reference.
         Element element = node.getElement();
         Type expressionType = expression.getType();
         if (isFinal && expressionType != null && TypeKind.of(element.getType()) == TypeKind.DYNAMIC) {
           Type fieldType = Types.makeInferred(expressionType);
           Elements.setType(element, fieldType);
         }
       } else if (isFinal) {
         if (modifiers.isConstant()) {
           onError(node, ResolverErrorCode.CONST_REQUIRES_VALUE);
@@ skipping 412 matching lines @@
       return recordElement(x, element);
     }
 
     /**
      * Possibly recursive check on the resolved identifier.
      */
     private Element checkResolvedIdentifier(DartIdentifier x, boolean isQualifier, Scope scope,
                                             String name, Element element) {
       switch (element.getKind()) {
         case FIELD:
-          if (inStaticContext(currentMethod) && !inStaticContext(element)) {
-            onError(x, ResolverErrorCode.ILLEGAL_FIELD_ACCESS_FROM_STATIC,
-                name);
+          if (!inStaticContext(element)) {
+            if (inInstanceVariableInitializer) {
+              onError(x, ResolverErrorCode.CANNOT_USE_INSTANCE_FIELD_IN_INSTANCE_FIELD_INITIALIZER);
+            } else if (inStaticContext(currentMethod)) {
+              onError(x, ResolverErrorCode.ILLEGAL_FIELD_ACCESS_FROM_STATIC, name);
+            }
           }
           if (isIllegalPrivateAccess(x, enclosingElement, element, x.getName())) {
             return null;
           }
           break;
         case METHOD:
           if (inStaticContext(currentMethod) && !inStaticContext(element)) {
             onError(x, ResolverErrorCode.ILLEGAL_METHOD_ACCESS_FROM_STATIC,
                 name);
           }
@@ skipping 1033 matching lines @@
       }
       return false;
     }
 
     @Override
     boolean isStaticContext() {
       return inStaticContext(currentMethod);
     }
 
     private boolean inStaticContext(Element element) {
-      return element == null || Elements.isTopLevel(element)
-          || element.getModifiers().isStatic() || element.getModifiers().isFactory();
+      return element == null || Elements.isTopLevel(element) || element.getModifiers().isStatic()
+          || element.getModifiers().isConstant() || element.getModifiers().isFactory();
     }
 
     @Override
     boolean isFactoryContext() {
         return inFactoryContext(currentMethod);
     }
 
     boolean isStaticContextOrInitializer() {
       return inStaticContext(currentMethod) || inInitializer;
     }
@@ skipping 52 matching lines @@
           ClassElement currentClass = (ClassElement) constructor.getEnclosingElement();
           if (nextClass == currentClass) {
             return (ConstructorNodeElement) nextConstructorElement;
           }
         }
       }
     }
     return null;
   }
 }