Support accessing the parameter element when there is no name

pkg/analyzer/test/generated/resolver_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.generated.resolver_test;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/builder.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
@@ skipping 3167 matching lines @@
     expect(constructor.functions, hasLength(0));
     expect(constructor.labels, hasLength(0));
     expect(constructor.localVariables, hasLength(0));
     expect(constructor.parameters, isEmpty);
   }
 
   test_visitFieldFormalParameter_functionType() async {
     InterfaceType intType = _typeProvider.intType;
     TypeName intTypeName = AstTestFactory.typeName4("int");
     String innerParameterName = "a";
-    SimpleFormalParameter parameter =
+    SimpleFormalParameterImpl parameter =
         AstTestFactory.simpleFormalParameter3(innerParameterName);
-    parameter.identifier.staticElement =
+    parameter.element = parameter.identifier.staticElement =
         ElementFactory.requiredParameter(innerParameterName);
     String outerParameterName = "p";
     FormalParameter node = AstTestFactory.fieldFormalParameter(
         null,
         intTypeName,
         outerParameterName,
         AstTestFactory.formalParameterList([parameter]));
     node.identifier.staticElement =
         ElementFactory.requiredParameter(outerParameterName);
     DartType parameterType = _resolveFormalParameter(node, [intType.element]);
@@ skipping 190 matching lines @@
     declaration.name.staticElement = elementM;
     _resolveNode(declaration, [elementA]);
     expect(declaration.returnType.type, elementE.type);
     SimpleFormalParameter parameter = declaration.parameters.parameters[0];
     expect(parameter.type.type, elementE.type);
     _listener.assertNoErrors();
   }
 
   test_visitSimpleFormalParameter_noType() async {
     // p
-    FormalParameter node = AstTestFactory.simpleFormalParameter3("p");
-    node.identifier.staticElement =
+    SimpleFormalParameterImpl node = AstTestFactory.simpleFormalParameter3("p");
+    node.element = node.identifier.staticElement =
         new ParameterElementImpl.forNode(AstTestFactory.identifier3("p"));
     expect(_resolveFormalParameter(node), same(_typeProvider.dynamicType));
     _listener.assertNoErrors();
   }
 
   test_visitSimpleFormalParameter_type() async {
     // int p
     InterfaceType intType = _typeProvider.intType;
     ClassElement intElement = intType.element;
-    FormalParameter node = AstTestFactory.simpleFormalParameter4(
+    SimpleFormalParameterImpl node = AstTestFactory.simpleFormalParameter4(
         AstTestFactory.typeName(intElement), "p");
     SimpleIdentifier identifier = node.identifier;
     ParameterElementImpl element = new ParameterElementImpl.forNode(identifier);
-    identifier.staticElement = element;
+    node.element = identifier.staticElement = element;
     expect(_resolveFormalParameter(node, [intElement]), same(intType));
     _listener.assertNoErrors();
   }
 
   test_visitTypeName_noParameters_noArguments() async {
     ClassElement classA = ElementFactory.classElement2("A");
     TypeName typeName = AstTestFactory.typeName(classA);
     typeName.type = null;
     _resolveNode(typeName, [classA]);
     expect(typeName.type, same(classA.type));
@@ skipping 174 matching lines @@
  */
 class _StaleElement extends ElementImpl {
   _StaleElement() : super("_StaleElement", -1);
 
   @override
   get kind => throw "_StaleElement's kind shouldn't be accessed";
 
   @override
   /*=T*/ accept/*<T>*/(_) => throw "_StaleElement shouldn't be visited";
 }