Create DeclaredSimpleIdentifier when parse a declaration with Fasta.

pkg/analyzer/test/generated/parser_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.parser_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 3464 matching lines @@
     listener.assertErrorsWithCodes([ParserErrorCode.NON_CONSTRUCTOR_FACTORY]);
   }
 
   void test_nonIdentifierLibraryName_library() {
     CompilationUnit unit = parseCompilationUnit(
         "library 'lib';", [ParserErrorCode.NON_IDENTIFIER_LIBRARY_NAME]);
     expect(unit, isNotNull);
   }
 
   void test_nonIdentifierLibraryName_partOf() {
-    CompilationUnit unit = parseCompilationUnit(
-        "part of 3;", [ParserErrorCode.MISSING_NAME_IN_PART_OF_DIRECTIVE,
-                       ParserErrorCode.UNEXPECTED_TOKEN]);
+    CompilationUnit unit = parseCompilationUnit("part of 3;", [
+      ParserErrorCode.MISSING_NAME_IN_PART_OF_DIRECTIVE,
+      ParserErrorCode.UNEXPECTED_TOKEN
+    ]);
     expect(unit, isNotNull);
   }
 
   void test_nonPartOfDirectiveInPart_after() {
     parseCompilationUnit("part of l; part 'f.dart';",
         [ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART]);
   }
 
   void test_nonPartOfDirectiveInPart_before() {
     parseCompilationUnit("part 'f.dart'; part of m;",
@@ skipping 9675 matching lines @@
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.extendsClause, isNull);
     expect(declaration.implementsClause, isNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
     expect(declaration.typeParameters, isNull);
+    _assertDeclarationName(declaration.name);
+  }
+
+  /**
+   * Assert that the given [name] is in declaration context.
+   */
+  void _assertDeclarationName(SimpleIdentifier name) {
+    expect(name.inDeclarationContext(), isTrue);
   }
 
   void test_parseClassDeclaration_extends() {
     createParser('class A extends B {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
     expect(member, new isInstanceOf<ClassDeclaration>());
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
@@ skipping 128 matching lines @@
     expect(member, new isInstanceOf<ClassTypeAlias>());
     ClassTypeAlias typeAlias = member;
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.withClause, isNotNull);
     expect(typeAlias.implementsClause, isNotNull);
     expect(typeAlias.implementsClause.implementsKeyword, isNotNull);
     expect(typeAlias.implementsClause.interfaces.length, 1);
     expect(typeAlias.semicolon, isNotNull);
+    _assertDeclarationName(typeAlias.name);
   }
 
   void test_parseClassDeclaration_typeAlias_withB() {
     createParser('class A = Object with B;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
     expect(member, new isInstanceOf<ClassTypeAlias>());
     ClassTypeAlias typeAlias = member;
     expect(typeAlias.typedefKeyword, isNotNull);
@@ skipping 17 matching lines @@
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.extendsClause, isNull);
     expect(declaration.implementsClause, isNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
     expect(declaration.typeParameters, isNotNull);
     expect(declaration.typeParameters.typeParameters, hasLength(1));
+    _assertDeclarationName(declaration.typeParameters.typeParameters[0].name);
   }
 
   void test_parseClassDeclaration_withDocumentationComment() {
     createParser('/// Doc\nclass C {}');
     var classDeclaration = parseFullCompilationUnitMember() as ClassDeclaration;
     expectCommentText(classDeclaration.documentationComment, '/// Doc');
   }
 
   void test_parseClassTypeAlias_withDocumentationComment() {
     createParser('/// Doc\nclass C = D with E;');
@@ skipping 165 matching lines @@
   void test_parseCompilationUnitMember_constVariable() {
     createParser('const int x = 0;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
     expect(member, new isInstanceOf<TopLevelVariableDeclaration>());
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
     expect(declaration.variables.keyword.lexeme, 'const');
+    _assertDeclarationName(declaration.variables.variables[0].name);
   }
 
   void test_parseCompilationUnitMember_expressionFunctionBody_tokens() {
     createParser('f() => 0;');
     var f = parseFullCompilationUnitMember() as FunctionDeclaration;
     var body = f.functionExpression.body as ExpressionFunctionBody;
     expect(body.functionDefinition.lexeme, '=>');
     expect(body.semicolon.lexeme, ';');
+    _assertDeclarationName(f.name);
   }
 
   void test_parseCompilationUnitMember_finalVariable() {
     createParser('final x = 0;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
     expect(member, new isInstanceOf<TopLevelVariableDeclaration>());
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
@@ skipping 105 matching lines @@
   void test_parseCompilationUnitMember_getter_external_noType() {
     createParser('external get p;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.externalKeyword, isNotNull);
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
+    _assertDeclarationName(declaration.name);
   }
 
   void test_parseCompilationUnitMember_getter_external_type() {
     createParser('external int get p;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.externalKeyword, isNotNull);
@@ skipping 49 matching lines @@
 
   void test_parseCompilationUnitMember_setter_noType() {
     createParser('set p(v) {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
+    _assertDeclarationName(declaration.name);
   }
 
   void test_parseCompilationUnitMember_setter_type() {
     createParser('void set p(int v) {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
@@ skipping 10 matching lines @@
     ClassTypeAlias typeAlias = member;
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name.name, "C");
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.equals, isNotNull);
     expect(typeAlias.abstractKeyword, isNotNull);
     expect(typeAlias.superclass.name.name, "S");
     expect(typeAlias.withClause, isNotNull);
     expect(typeAlias.implementsClause, isNull);
     expect(typeAlias.semicolon, isNotNull);
+    _assertDeclarationName(typeAlias.name);
   }
 
   void test_parseCompilationUnitMember_typeAlias_generic() {
     createParser('class C<E> = S<E> with M<E> implements I<E>;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
     expect(member, new isInstanceOf<ClassTypeAlias>());
     ClassTypeAlias typeAlias = member;
     expect(typeAlias.typedefKeyword, isNotNull);
@@ skipping 45 matching lines @@
 
   void test_parseCompilationUnitMember_typedef() {
     createParser('typedef F();');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
     expect(member, new isInstanceOf<FunctionTypeAlias>());
     FunctionTypeAlias typeAlias = member;
     expect(typeAlias.name.name, "F");
     expect(typeAlias.parameters.parameters, hasLength(0));
+    _assertDeclarationName(typeAlias.name);
   }
 
   void test_parseCompilationUnitMember_typedef_withDocComment() {
     createParser('/// Doc\ntypedef F();');
     var typeAlias = parseFullCompilationUnitMember() as FunctionTypeAlias;
     expectCommentText(typeAlias.documentationComment, '/// Doc');
   }
 
   void test_parseCompilationUnitMember_typedVariable() {
     createParser('int x = 0;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
     expect(member, new isInstanceOf<TopLevelVariableDeclaration>());
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
     expect(declaration.variables.type, isNotNull);
     expect(declaration.variables.keyword, isNull);
+    _assertDeclarationName(declaration.variables.variables[0].name);
   }
 
   void test_parseCompilationUnitMember_variable() {
     createParser('var x = 0;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
     expect(member, new isInstanceOf<TopLevelVariableDeclaration>());
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
@@ skipping 912 matching lines @@
     createParser('''
 class A<
     /// Doc
     B> {}
 ''');
     var classDeclaration = parseFullCompilationUnitMember() as ClassDeclaration;
     var typeVariable = classDeclaration.typeParameters.typeParameters[0];
     expectCommentText(typeVariable.documentationComment, '/// Doc');
   }
 }