In constant evaluation, handle final vars initialized at declaration site.

pkg/analyzer/test/generated/all_the_rest_test.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.all_the_rest_test;
 
 import 'dart:collection';
@@ skipping 833 matching lines @@
     ConstantEvaluator evaluator =
         new ConstantEvaluator(source, analysisContext.typeProvider);
     return evaluator.evaluate(variables[0].initializer);
   }
 }
 
 @reflectiveTest
 class ConstantFinderTest extends EngineTestCase {
   AstNode _node;
 
+  TypeProvider _typeProvider;
+
+  void setUp() {
+    super.setUp();
+    _typeProvider = new TestTypeProvider();
+  }
+
   /**
    * Test an annotation that consists solely of an identifier (and hence
    * represents a reference to a compile-time constant variable).
    */
   void test_visitAnnotation_constantVariable() {
     _node = AstFactory.annotation(AstFactory.identifier3('x'));
     expect(_findAnnotations(), contains(_node));
   }
 
   /**
@@ skipping 24 matching lines @@
   void test_visitInstanceCreationExpression_nonConst() {
     _setupInstanceCreationExpression("A", false);
     expect(_findConstructorInvocations().isEmpty, isTrue);
   }
 
   void test_visitVariableDeclaration_const() {
     VariableElement element = _setupVariableDeclaration("v", true, true);
     expect(_findVariableDeclarations()[element], same(_node));
   }
 
+  void test_visitVariableDeclaration_final_inClass() {
+    _setupFieldDeclaration('C', 'f', Keyword.FINAL);
+    expect(_findVariableDeclarations(), isEmpty);
+  }
+
+  void test_visitVariableDeclaration_final_inClassWithConstConstructor() {
+    VariableDeclaration field = _setupFieldDeclaration('C', 'f', Keyword.FINAL,
+        hasConstConstructor: true);
+    expect(_findVariableDeclarations()[field.element], same(field));
+  }
+
+  void test_visitVariableDeclaration_final_outsideClass() {
+    _setupVariableDeclaration('v', false, true, isFinal: true);
+    expect(_findVariableDeclarations(), isEmpty);
+  }
+
   void test_visitVariableDeclaration_noInitializer() {
     _setupVariableDeclaration("v", true, false);
     expect(_findVariableDeclarations().isEmpty, isTrue);
   }
 
   void test_visitVariableDeclaration_nonConst() {
     _setupVariableDeclaration("v", false, true);
     expect(_findVariableDeclarations().isEmpty, isTrue);
   }
 
+  void test_visitVariableDeclaration_static_const_inClass() {
+    VariableDeclaration field =
+        _setupFieldDeclaration('C', 'f', Keyword.CONST, isStatic: true);
+    expect(_findVariableDeclarations()[field.element], same(field));
+  }
+
+  void test_visitVariableDeclaration_static_const_inClassWithConstConstructor() {
+    VariableDeclaration field = _setupFieldDeclaration('C', 'f', Keyword.CONST,
+        isStatic: true, hasConstConstructor: true);
+    expect(_findVariableDeclarations()[field.element], same(field));
+  }
+
+  void test_visitVariableDeclaration_static_final_inClassWithConstConstructor() {
+    _setupFieldDeclaration('C', 'f', Keyword.FINAL,
+        isStatic: true, hasConstConstructor: true);
+    expect(_findVariableDeclarations(), isEmpty);
+  }
+
+  void test_visitVariableDeclaration_uninitialized_final_inClassWithConstConstructor() {
+    _setupFieldDeclaration('C', 'f', Keyword.FINAL,
+        isInitialized: false, hasConstConstructor: true);
+    expect(_findVariableDeclarations(), isEmpty);
+  }
+
+  void test_visitVariableDeclaration_uninitialized_static_const_inClass() {
+    _setupFieldDeclaration('C', 'f', Keyword.CONST,
+        isStatic: true, isInitialized: false);
+    expect(_findVariableDeclarations(), isEmpty);
+  }
+
   List<Annotation> _findAnnotations() {
     ConstantFinder finder = new ConstantFinder();
     _node.accept(finder);
     List<Annotation> annotations = finder.annotations;
     expect(annotations, isNotNull);
     return annotations;
   }
 
   Map<ConstructorElement, ConstructorDeclaration> _findConstantDeclarations() {
     ConstantFinder finder = new ConstantFinder();
@@ skipping 29 matching lines @@
             AstFactory.formalParameterList(), null,
             AstFactory.blockFunctionBody2());
     ClassElement classElement = ElementFactory.classElement2(name);
     ConstructorElement element =
         ElementFactory.constructorElement(classElement, name, isConst);
     constructorDeclaration.element = element;
     _node = constructorDeclaration;
     return element;
   }
 
+  VariableDeclaration _setupFieldDeclaration(
+      String className, String fieldName, Keyword keyword,
+      {bool isInitialized: true, bool isStatic: false,
+      bool hasConstConstructor: false}) {
+    VariableDeclaration variableDeclaration = isInitialized
+        ? AstFactory.variableDeclaration2(fieldName, AstFactory.integer(0))
+        : AstFactory.variableDeclaration(fieldName);
+    VariableElement fieldElement = ElementFactory.fieldElement(fieldName,
+        isStatic, keyword == Keyword.FINAL, keyword == Keyword.CONST,
+        _typeProvider.intType);
+    variableDeclaration.name.staticElement = fieldElement;
+    FieldDeclaration fieldDeclaration = AstFactory.fieldDeclaration2(
+        isStatic, keyword, <VariableDeclaration>[variableDeclaration]);
+    ClassDeclaration classDeclaration =
+        AstFactory.classDeclaration(null, className, null, null, null, null);
+    classDeclaration.members.add(fieldDeclaration);
+    _node = classDeclaration;
+    ClassElementImpl classElement = ElementFactory.classElement2(className);
+    classElement.fields = <FieldElement>[fieldElement];
+    classDeclaration.name.staticElement = classElement;
+    if (hasConstConstructor) {
+      ConstructorDeclaration constructorDeclaration = AstFactory
+          .constructorDeclaration2(Keyword.CONST, null,
+              AstFactory.identifier3(className), null,
+              AstFactory.formalParameterList(), null,
+              AstFactory.blockFunctionBody2());
+      classDeclaration.members.add(constructorDeclaration);
+      ConstructorElement constructorElement =
+          ElementFactory.constructorElement(classElement, '', true);
+      constructorDeclaration.element = constructorElement;
+      classElement.constructors = <ConstructorElement>[constructorElement];
+    }
+    return variableDeclaration;
+  }
+
   void _setupInstanceCreationExpression(String name, bool isConst) {
     _node = AstFactory.instanceCreationExpression2(
         isConst ? Keyword.CONST : null,
         AstFactory.typeName3(AstFactory.identifier3(name)));
   }
 
   VariableElement _setupVariableDeclaration(
-      String name, bool isConst, bool isInitialized) {
+      String name, bool isConst, bool isInitialized, {isFinal: false}) {
     VariableDeclaration variableDeclaration = isInitialized
         ? AstFactory.variableDeclaration2(name, AstFactory.integer(0))
         : AstFactory.variableDeclaration(name);
     SimpleIdentifier identifier = variableDeclaration.name;
     VariableElement element = ElementFactory.localVariableElement(identifier);
     identifier.staticElement = element;
-    AstFactory.variableDeclarationList2(
-        isConst ? Keyword.CONST : null, [variableDeclaration]);
+    Keyword keyword = isConst ? Keyword.CONST : isFinal ? Keyword.FINAL : null;
+    AstFactory.variableDeclarationList2(keyword, [variableDeclaration]);
     _node = variableDeclaration;
     return element;
   }
 }
 
 @reflectiveTest
 class ConstantValueComputerTest extends ResolverTestCase {
   void test_annotation_constConstructor() {
     CompilationUnit compilationUnit = resolveSource(r'''
 class A {
@@ skipping 355 matching lines @@
 class A {
   const A() : x = 5;
   final int x;
 }
 class B extends A {
   const B();
 }
 const B b = const B();''');
   }
 
+  void test_dependencyOnInitializedNonStaticConst() {
+    // Even though non-static consts are not allowed by the language, we need
+    // to handle them for error recovery purposes.
+    // a depends on A() depends on A.x
+    _assertProperDependencies('''
+class A {
+  const A();
+  const int x = 1;
+}
+const A a = const A();
+''', [CompileTimeErrorCode.CONST_INSTANCE_FIELD]);
+  }
+
+  void test_dependencyOnInitializedFinal() {
+    // a depends on A() depends on A.x
+    _assertProperDependencies('''
+class A {
+  const A();
+  final int x = 1;
+}
+const A a = const A();
+''');
+  }
+
   void test_dependencyOnNonFactoryRedirect() {
     // a depends on A.foo() depends on A.bar()
     _assertProperDependencies(r'''
 const A a = const A.foo();
 class A {
   const A.foo() : this.bar();
   const A.bar();
 }''');
   }
 
@@ skipping 65 matching lines @@
 const A a = const A();''');
   }
 
   void test_dependencyOnVariable() {
     // x depends on y
     _assertProperDependencies(r'''
 const x = y + 1;
 const y = 2;''');
   }
 
+  void test_final_initialized_at_declaration() {
+    CompilationUnit compilationUnit = resolveSource('''
+class A {
+  final int i = 123;
+  const A();
+}
+
+const A a = const A();
+''');
+    EvaluationResultImpl result =
+        _evaluateInstanceCreationExpression(compilationUnit, 'a');
+    Map<String, DartObjectImpl> fields = _assertType(result, "A");
+    expect(fields, hasLength(1));
+    _assertIntField(fields, "i", 123);
+  }
+
+  void test_non_static_const_initialized_at_declaration() {
+    // Even though non-static consts are not allowed by the language, we need
+    // to handle them for error recovery purposes.
+    CompilationUnit compilationUnit = resolveSource('''
+class A {
+  const int i = 123;
+  const A();
+}
+
+const A a = const A();
+''');
+    EvaluationResultImpl result =
+        _evaluateInstanceCreationExpression(compilationUnit, 'a');
+    Map<String, DartObjectImpl> fields = _assertType(result, "A");
+    expect(fields, hasLength(1));
+    _assertIntField(fields, "i", 123);
+  }
+
   void test_fromEnvironment_bool_default_false() {
     expect(_assertValidBool(_check_fromEnvironment_bool(null, "false")), false);
   }
 
   void test_fromEnvironment_bool_default_overridden() {
     expect(
         _assertValidBool(_check_fromEnvironment_bool("false", "true")), false);
   }
 
   void test_fromEnvironment_bool_default_parseError() {
@@ skipping 6859 matching lines @@
       TypeProvider typeProvider, DeclaredVariables declaredVariables)
       : super(typeProvider, declaredVariables);
 
   @override
   void beforeComputeValue(AstNode constNode) {
     super.beforeComputeValue(constNode);
     _nodeBeingEvaluated = constNode;
   }
 
   @override
+  void beforeGetFieldEvaluationResult(FieldElementImpl field) {
+    super.beforeGetFieldEvaluationResult(field);
+    // If we are getting the constant value for a node in the graph, make sure
+    // we properly recorded the dependency.
+    VariableDeclaration node = findVariableDeclaration(field);
+    if (node != null && referenceGraph.nodes.contains(node)) {
+      expect(referenceGraph.containsPath(_nodeBeingEvaluated, node), isTrue);
+    }
+  }
+
+  @override
   void beforeGetConstantInitializers(ConstructorElement constructor) {
     super.beforeGetConstantInitializers(constructor);
     // If we are getting the constant initializers for a node in the graph,
     // make sure we properly recorded the dependency.
     ConstructorDeclaration node = findConstructorDeclaration(constructor);
     if (node != null && referenceGraph.nodes.contains(node)) {
       expect(referenceGraph.containsPath(_nodeBeingEvaluated, node), isTrue);
     }
   }
 
@@ skipping 299 matching lines @@
     if (_expectedExternalScriptName == null) {
       expect(scriptSource, isNull, reason: "script $scriptIndex");
     } else {
       expect(scriptSource, isNotNull, reason: "script $scriptIndex");
       String actualExternalScriptName = scriptSource.shortName;
       expect(actualExternalScriptName, _expectedExternalScriptName,
           reason: "script $scriptIndex");
     }
   }
 }