Issue 23181. Fix for ParameterElement.node.

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';
@@ skipping 19 matching lines @@
   runReflectiveTests(InterfaceTypeImplTest);
   runReflectiveTests(TypeParameterTypeImplTest);
   runReflectiveTests(VoidTypeImplTest);
   runReflectiveTests(ClassElementImplTest);
   runReflectiveTests(CompilationUnitElementImplTest);
   runReflectiveTests(ElementLocationImplTest);
   runReflectiveTests(ElementImplTest);
   runReflectiveTests(HtmlElementImplTest);
   runReflectiveTests(LibraryElementImplTest);
   runReflectiveTests(MultiplyDefinedElementImplTest);
+  runReflectiveTests(ParameterElementImplTest);
 }
 
 @reflectiveTest
 class ClassElementImplTest extends EngineTestCase {
   void test_getAllSupertypes_interface() {
     ClassElement classA = ElementFactory.classElement2("A");
     ClassElement classB = ElementFactory.classElement("B", classA.type);
     ClassElementImpl elementC = ElementFactory.classElement2("C");
     InterfaceType typeObject = classA.supertype;
     InterfaceType typeA = classA.type;
@@ skipping 2577 matching lines @@
     ClassElement classB = ElementFactory.classElement2("B", ["F", "G"]);
     InterfaceTypeImpl typeAF = new InterfaceTypeImpl.con1(classA);
     typeAF.typeArguments = <DartType>[classB.typeParameters[0].type];
     InterfaceTypeImpl typeAG = new InterfaceTypeImpl.con1(classA);
     typeAG.typeArguments = <DartType>[classB.typeParameters[1].type];
     expect(typeAG.isAssignableTo(typeAF), isFalse);
   }
 
   void test_isAssignableTo_void() {
     InterfaceTypeImpl intType = _typeProvider.intType;
-    expect(
-        VoidTypeImpl.instance.isAssignableTo(intType), isFalse);
+    expect(VoidTypeImpl.instance.isAssignableTo(intType), isFalse);
   }
 
   void test_isDirectSupertypeOf_extends() {
     ClassElement classA = ElementFactory.classElement2("A");
     ClassElement classB = ElementFactory.classElement("B", classA.type);
     InterfaceType typeA = classA.type;
     InterfaceType typeB = classB.type;
     expect(typeA.isDirectSupertypeOf(typeB), isTrue);
   }
 
@@ skipping 968 matching lines @@
   }
 
   void test_fromElements_nonConflicting() {
     Element element = ElementFactory.localVariableElement2("xx");
     expect(MultiplyDefinedElementImpl.fromElements(null, element, element),
         same(element));
   }
 }
 
 @reflectiveTest
+class ParameterElementImplTest extends EngineTestCase {
+  void test_node_DefaultFormalParameter() {
+    AnalysisContextHelper contextHelper = new AnalysisContextHelper();
+    AnalysisContext context = contextHelper.context;
+    Source source = contextHelper.addSource("/test.dart", r'''
+main([int p = 42]) {
+}''');
+    // prepare CompilationUnitElement
+    LibraryElement libraryElement = context.computeLibraryElement(source);
+    CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
+    // p
+    {
+      ParameterElement element = unitElement.functions[0].parameters[0];
+      DefaultFormalParameter node = element.node;
+      expect(node, isNotNull);
+      expect(node.identifier.name, 'p');
+      expect(node.element, same(element));
+    }
+  }
+
+  void test_node_FieldFormalParameter() {
+    AnalysisContextHelper contextHelper = new AnalysisContextHelper();
+    AnalysisContext context = contextHelper.context;
+    Source source = contextHelper.addSource("/test.dart", r'''
+class A {
+  int p;
+  A(this.p) {
+  }
+}''');
+    // prepare CompilationUnitElement
+    LibraryElement libraryElement = context.computeLibraryElement(source);
+    CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
+    // p
+    {
+      ClassElement classA = unitElement.types[0];
+      ConstructorElement constructorA = classA.constructors[0];
+      FieldFormalParameterElement element = constructorA.parameters[0];
+      FieldFormalParameter node = element.node;
+      expect(node, isNotNull);
+      expect(node.identifier.name, 'p');
+      expect(node.element, same(element));
+    }
+  }
+
+  void test_node_FunctionTypedFormalParameter() {
+    AnalysisContextHelper contextHelper = new AnalysisContextHelper();
+    AnalysisContext context = contextHelper.context;
+    Source source = contextHelper.addSource("/test.dart", r'''
+main(p(int a, int b)) {
+}''');
+    // prepare CompilationUnitElement
+    LibraryElement libraryElement = context.computeLibraryElement(source);
+    CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
+    // p
+    {
+      ParameterElement element = unitElement.functions[0].parameters[0];
+      FunctionTypedFormalParameter node = element.node;
+      expect(node, isNotNull);
+      expect(node.identifier.name, 'p');
+      expect(node.element, same(element));
+    }
+  }
+
+  void test_node_SimpleFormalParameter() {
+    AnalysisContextHelper contextHelper = new AnalysisContextHelper();
+    AnalysisContext context = contextHelper.context;
+    Source source = contextHelper.addSource("/test.dart", r'''
+main(int p) {
+}''');
+    // prepare CompilationUnitElement
+    LibraryElement libraryElement = context.computeLibraryElement(source);
+    CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
+    // p
+    {
+      ParameterElement element = unitElement.functions[0].parameters[0];
+      SimpleFormalParameter node = element.node;
+      expect(node, isNotNull);
+      expect(node.identifier.name, 'p');
+      expect(node.element, same(element));
+    }
+  }
+}
+
+@reflectiveTest
 class TypeParameterTypeImplTest extends EngineTestCase {
   void test_creation() {
     expect(new TypeParameterTypeImpl(
             new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"))),
         isNotNull);
   }
 
   void test_getElement() {
     TypeParameterElementImpl element =
         new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
@@ skipping 151 matching lines @@
 }
 
 class _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction
     extends InterfaceTypeImpl {
   _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction(ClassElement arg0)
       : super.con1(arg0);
 
   @override
   bool get isDartCoreFunction => true;
 }