Implement 'node' for ClassElement and FieldElement for enums.

pkg/analyzer/test/generated/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.
 
 // 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.element_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisContextImpl;
 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 '../reflective_tests.dart';
 import 'resolver_test.dart' show TestTypeProvider, AnalysisContextHelper;
 import 'test_support.dart';
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(ElementKindTest);
+  runReflectiveTests(FieldElementImplTest);
   runReflectiveTests(FunctionTypeImplTest);
   runReflectiveTests(InterfaceTypeImplTest);
   runReflectiveTests(TypeParameterTypeImplTest);
   runReflectiveTests(UnionTypeImplTest);
   runReflectiveTests(VoidTypeImplTest);
   runReflectiveTests(ClassElementImplTest);
   runReflectiveTests(CompilationUnitElementImplTest);
   runReflectiveTests(ElementLocationImplTest);
   runReflectiveTests(ElementImplTest);
   runReflectiveTests(HtmlElementImplTest);
@@ skipping 68 matching lines @@
   }
 
   void test_getMethod_undeclared() {
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
     MethodElement method = ElementFactory.methodElement(methodName, null);
     classA.methods = <MethodElement>[method];
     expect(classA.getMethod("${methodName}x"), isNull);
   }
 
-  void test_getNode() {
-    AnalysisContextHelper contextHelper = new AnalysisContextHelper();
-    AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource("/test.dart", r'''
-class A {}
-class B {}''');
-    // prepare CompilationUnitElement
-    LibraryElement libraryElement = context.computeLibraryElement(source);
-    CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
-    // A
-    {
-      ClassElement elementA = unitElement.getType("A");
-      ClassDeclaration nodeA = elementA.node;
-      expect(nodeA, isNotNull);
-      expect(nodeA.name.name, "A");
-      expect(nodeA.element, same(elementA));
-    }
-    // B
-    {
-      ClassElement elementB = unitElement.getType("B");
-      ClassDeclaration nodeB = elementB.node;
-      expect(nodeB, isNotNull);
-      expect(nodeB.name.name, "B");
-      expect(nodeB.element, same(elementB));
-    }
-  }
-
   void test_hasNonFinalField_false_const() {
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.fields = <FieldElement>[
       ElementFactory.fieldElement("f", false, false, true, classA.type)
     ];
     expect(classA.hasNonFinalField, isFalse);
   }
 
   void test_hasNonFinalField_false_final() {
     ClassElementImpl classA = ElementFactory.classElement2("A");
@@ skipping 723 matching lines @@
     // }
     LibraryElementImpl library =
         ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classA = ElementFactory.classElement2("A");
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     classA.supertype = classB.type;
     (library.definingCompilationUnit as CompilationUnitElementImpl).types =
         <ClassElement>[classA, classB];
     expect(classA.lookUpSetter("s", library), isNull);
   }
+
+  void test_node() {
+    AnalysisContextHelper contextHelper = new AnalysisContextHelper();
+    AnalysisContext context = contextHelper.context;
+    Source source = contextHelper.addSource("/test.dart", r'''
+class A {}
+class B {}
+enum C {C1, C2, C3}''');
+    // prepare CompilationUnitElement
+    LibraryElement libraryElement = context.computeLibraryElement(source);
+    CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
+    // A
+    {
+      ClassElement elementA = unitElement.getType("A");
+      ClassDeclaration nodeA = elementA.node;
+      expect(nodeA, isNotNull);
+      expect(nodeA.name.name, "A");
+      expect(nodeA.element, same(elementA));
+    }
+    // B
+    {
+      ClassElement elementB = unitElement.getType("B");
+      ClassDeclaration nodeB = elementB.node;
+      expect(nodeB, isNotNull);
+      expect(nodeB.name.name, "B");
+      expect(nodeB.element, same(elementB));
+    }
+    // C
+    {
+      ClassElement elementC = unitElement.getEnum("C");
+      EnumDeclaration nodeC = elementC.node;
+      expect(nodeC, isNotNull);
+      expect(nodeC.name.name, "C");
+      expect(nodeC.element, same(elementC));
+    }
+  }
 }
 
+
 @reflectiveTest
 class CompilationUnitElementImplTest extends EngineTestCase {
   void test_getEnum_declared() {
     TestTypeProvider typeProvider = new TestTypeProvider();
     CompilationUnitElementImpl unit =
         ElementFactory.compilationUnit("/lib.dart");
     String enumName = "E";
     ClassElement enumElement =
         ElementFactory.enumElement(typeProvider, enumName);
     unit.enums = <ClassElement>[enumElement];
@@ skipping 197 matching lines @@
 
   void test_hashCode_equal() {
     String encoding = "a;b;c";
     ElementLocationImpl first = new ElementLocationImpl.con2(encoding);
     ElementLocationImpl second = new ElementLocationImpl.con2(encoding);
     expect(first.hashCode == second.hashCode, isTrue);
   }
 }
 
 @reflectiveTest
+class FieldElementImplTest extends EngineTestCase {
+  void test_node() {
+    AnalysisContextHelper contextHelper = new AnalysisContextHelper();
+    AnalysisContext context = contextHelper.context;
+    Source source = contextHelper.addSource("/test.dart", r'''
+class A {
+  int a;
+}
+enum B {B1, B2, B3}''');
+    // prepare CompilationUnitElement
+    LibraryElement libraryElement = context.computeLibraryElement(source);
+    CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
+    // A
+    {
+      FieldElement elementA = unitElement.getType("A").getField('a');
+      VariableDeclaration nodeA = elementA.node;
+      expect(nodeA, isNotNull);
+      expect(nodeA.name.name, "a");
+      expect(nodeA.element, same(elementA));
+    }
+    // B
+    {
+      FieldElement elementB = unitElement.getEnum("B").getField('B2');
+      EnumConstantDeclaration nodeB = elementB.node;
+      expect(nodeB, isNotNull);
+      expect(nodeB.name.name, "B2");
+      expect(nodeB.element, same(elementB));
+    }
+  }
+}
+
+@reflectiveTest
 class FunctionTypeImplTest extends EngineTestCase {
   void test_creation() {
     expect(new FunctionTypeImpl.con1(
             new FunctionElementImpl.forNode(AstFactory.identifier3("f"))),
         isNotNull);
   }
 
   void test_getElement() {
     FunctionElementImpl typeElement =
         new FunctionElementImpl.forNode(AstFactory.identifier3("f"));
@@ skipping 2814 matching lines @@
 }
 
 class _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction
     extends InterfaceTypeImpl {
   _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction(ClassElement arg0)
       : super.con1(arg0);
 
   @override
   bool get isDartCoreFunction => true;
 }