Add API to force the computation of constant values

pkg/analyzer/test/src/dart/element/element_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.
 
 library analyzer.test.src.dart.element.element_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/handle.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisOptionsImpl;
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/testing/ast_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:analyzer/src/generated/testing/test_type_provider.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../../generated/analysis_context_factory.dart'
     show AnalysisContextHelper;
+import '../../../generated/resolver_test_case.dart';
 import '../../../generated/test_support.dart';
 import '../../../reflective_tests.dart';
 import '../../../utils.dart';
 
 main() {
   initializeTestEnvironment();
+  runReflectiveTests(ElementAnnotationImplTest);
   runReflectiveTests(FieldElementImplTest);
   runReflectiveTests(FunctionTypeImplTest);
   runReflectiveTests(InterfaceTypeImplTest);
   runReflectiveTests(LocalVariableElementImplTest);
   runReflectiveTests(TypeParameterTypeImplTest);
   runReflectiveTests(VoidTypeImplTest);
   runReflectiveTests(ClassElementImplTest);
   runReflectiveTests(CompilationUnitElementImplTest);
   runReflectiveTests(ElementLocationImplTest);
   runReflectiveTests(ElementImplTest);
   runReflectiveTests(LibraryElementImplTest);
   runReflectiveTests(MethodElementImplTest);
   runReflectiveTests(MultiplyDefinedElementImplTest);
   runReflectiveTests(ParameterElementImplTest);
+  runReflectiveTests(TopLevelVariableElementImplTest);
 }
 
 @reflectiveTest
 class ClassElementImplTest extends EngineTestCase {
   void test_computeNode_ClassDeclaration() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
     Source source = contextHelper.addSource(
         "/test.dart",
         r'''
@@ skipping 1030 matching lines @@
     CompilationUnitElementImpl unit =
         ElementFactory.compilationUnit("/lib.dart");
     String className = "C";
     ClassElement classElement = ElementFactory.classElement2(className);
     unit.types = <ClassElement>[classElement];
     expect(unit.getType("${className}x"), isNull);
   }
 }
 
 @reflectiveTest
+class ElementAnnotationImplTest extends ResolverTestCase {
+  void test_computeConstantValue() {
+    addNamedSource(
+        '/a.dart',
+        r'''
+class A {
+  final String f;
+  const A(this.f);
+}
+void f(@A('x') int p) {}
+''');
+    Source source = addSource(r'''
+import 'a.dart';
+main() {
+  f(3);
+}
+''');
+    LibraryElement library = resolve2(source);
+    CompilationUnit unit = resolveCompilationUnit(source, library);
+    FunctionDeclaration main = unit.declarations[0];
+    BlockFunctionBody body = main.functionExpression.body;
+    ExpressionStatement statement = body.block.statements[0];
+    MethodInvocation invocation = statement.expression;
+    ParameterElement parameter =
+        invocation.argumentList.arguments[0].bestParameterElement;
+    ElementAnnotation annotation = parameter.metadata[0];
+    expect(annotation.constantValue, isNull);
+    DartObject value = annotation.computeConstantValue();
+    expect(value, isNotNull);
+    expect(value.getField('f').toStringValue(), 'x');
+    expect(annotation.constantValue, value);
+  }
+}
+
+@reflectiveTest
 class ElementImplTest extends EngineTestCase {
   void test_equals() {
     LibraryElementImpl library =
         ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classElement = ElementFactory.classElement2("C");
     (library.definingCompilationUnit as CompilationUnitElementImpl).types =
         <ClassElement>[classElement];
     FieldElement field = ElementFactory.fieldElement(
         "next", false, false, false, classElement.type);
     classElement.fields = <FieldElement>[field];
@@ skipping 3047 matching lines @@
   TestElementResynthesizer(AnalysisContext context, this.locationMap)
       : super(context);
 
   @override
   Element getElement(ElementLocation location) {
     return locationMap[location];
   }
 }
 
 @reflectiveTest
+class TopLevelVariableElementImplTest extends ResolverTestCase {
+  void test_computeConstantValue() {
+    addNamedSource(
+        '/a.dart',
+        r'''
+const int C = 42;
+''');
+    Source source = addSource(r'''
+import 'a.dart';
+main() {
+  print(C);
+}
+''');
+    LibraryElement library = resolve2(source);
+    CompilationUnit unit = resolveCompilationUnit(source, library);
+    FunctionDeclaration main = unit.declarations[0];
+    BlockFunctionBody body = main.functionExpression.body;
+    ExpressionStatement statement = body.block.statements[0];
+    MethodInvocation invocation = statement.expression;
+    SimpleIdentifier argument = invocation.argumentList.arguments[0];
+    PropertyAccessorElementImpl getter = argument.bestElement;
+    TopLevelVariableElement constant = getter.variable;
+    expect(constant.constantValue, isNull);
+    DartObject value = constant.computeConstantValue();
+    expect(value, isNotNull);
+    expect(value.toIntValue(), 42);
+    expect(constant.constantValue, value);
+  }
+}
+
+@reflectiveTest
 class TypeParameterTypeImplTest extends EngineTestCase {
   void test_creation() {
     expect(
         new TypeParameterTypeImpl(
             new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"))),
         isNotNull);
   }
 
   void test_getElement() {
     TypeParameterElementImpl element =
@@ skipping 187 matching lines @@
 }
 
 class _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction
     extends InterfaceTypeImpl {
   _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction(ClassElement arg0)
       : super(arg0);
 
   @override
   bool get isDartCoreFunction => true;
 }