| // Copyright (c) 2018, 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. | |
| import 'package:analysis_server/protocol/protocol_generated.dart'; | |
| import 'package:analyzer/src/test_utilities/test_code_format.dart'; | |
| import 'package:analyzer_plugin/protocol/protocol_common.dart'; | |
| import 'package:test/test.dart'; | |
| import 'package:test_reflective_loader/test_reflective_loader.dart'; | |
| import '../utils/test_code_extensions.dart'; | |
| import 'abstract_search_domain.dart'; | |
| void main() { | |
| defineReflectiveSuite(() { | |
| defineReflectiveTests(DeclarationsTest); | |
| }); | |
| } | |
| @reflectiveTest | |
| class DeclarationsTest extends AbstractSearchDomainTest { | |
| late SearchGetElementDeclarationsResult declarationsResult; | |
| ElementDeclaration assertHas( | |
| String name, | |
| ElementKind kind, { | |
| String? className, | |
| String? mixinName, | |
| TestCodeRange? range, | |
| }) { | |
| var declaration = declarationsResult.declarations.singleWhere( | |
| (ElementDeclaration d) => | |
| declarationsResult.files[d.fileIndex] == testFile.path && | |
| d.name == name && | |
| d.kind == kind && | |
| d.className == className && | |
| d.mixinName == mixinName, | |
| ); | |
| if (range != null) { | |
| expect(declaration.codeOffset, range.sourceRange.offset); | |
| expect(declaration.codeLength, range.sourceRange.length); | |
| } | |
| return declaration; | |
| } | |
| void assertNo(String name) { | |
| expect( | |
| declarationsResult.declarations, | |
| isNot( | |
| contains( | |
| predicate( | |
| (ElementDeclaration d) => | |
| declarationsResult.files[d.fileIndex] == testFile.path && | |
| d.name == name, | |
| ), | |
| ), | |
| ), | |
| ); | |
| } | |
| Future<void> test_class() async { | |
| addTestFile(r''' | |
| class C { | |
| int f; | |
| C(); | |
| C.named(); | |
| int get g => 0; | |
| /*[0*/void set s(_) {}/*0]*/ | |
| /*[1*/void m() {}/*1]*/ | |
| } | |
| '''); | |
| await _getDeclarations(); | |
| assertHas('C', ElementKind.CLASS); | |
| assertHas('f', ElementKind.FIELD, className: 'C'); | |
| assertHas('named', ElementKind.CONSTRUCTOR, className: 'C'); | |
| assertHas('g', ElementKind.GETTER, className: 'C'); | |
| assertHas('s', ElementKind.SETTER, className: 'C', range: parsedRanges[0]); | |
| assertHas('m', ElementKind.METHOD, className: 'C', range: parsedRanges[1]); | |
| } | |
| Future<void> test_enum() async { | |
| addTestFile(r''' | |
| enum E { | |
| a, b, c | |
| } | |
| '''); | |
| await _getDeclarations(); | |
| assertHas('E', ElementKind.ENUM); | |
| assertHas('a', ElementKind.ENUM_CONSTANT); | |
| assertHas('b', ElementKind.ENUM_CONSTANT); | |
| assertHas('c', ElementKind.ENUM_CONSTANT); | |
| } | |
| Future<void> test_extension() async { | |
| addTestFile(r''' | |
| extension E on int { | |
| /*[0*/int get foo01 => 0;/*0]*/ | |
| /*[1*/void set foo02(_) {}/*1]*/ | |
| /*[2*/void foo03() {}/*2]*/ | |
| } | |
| '''); | |
| await _getDeclarations(); | |
| assertHas('E', ElementKind.EXTENSION); | |
| assertHas('foo01', ElementKind.GETTER, range: parsedRanges[0]); | |
| assertHas('foo02', ElementKind.SETTER, range: parsedRanges[1]); | |
| assertHas('foo03', ElementKind.METHOD, range: parsedRanges[2]); | |
| } | |
| Future<void> test_fuzzyMatch() async { | |
| addTestFile(r''' | |
| class MyClassFirst {} | |
| class MyClassSecond {} | |
| class OtherClass {} | |
| '''); | |
| await _getDeclarations(pattern: r'MyClass'); | |
| assertHas('MyClassFirst', ElementKind.CLASS); | |
| assertHas('MyClassSecond', ElementKind.CLASS); | |
| assertNo('OtherClass'); | |
| } | |
| Future<void> test_maxResults() async { | |
| newFile('$testPackageLibPath/a.dart', r''' | |
| class MyClass1 {} | |
| class MyClass2 {} | |
| ''').path; | |
| newFile('$testPackageLibPath/b.dart', r''' | |
| class MyClass3 {} | |
| class MyClass4 {} | |
| ''').path; | |
| // Limit to exactly one file. | |
| await _getDeclarations(pattern: r'MyClass', maxResults: 2); | |
| expect(declarationsResult.declarations, hasLength(2)); | |
| // Limit in the middle of the second file. | |
| await _getDeclarations(pattern: r'MyClass', maxResults: 3); | |
| expect(declarationsResult.declarations, hasLength(3)); | |
| // No limit. | |
| await _getDeclarations(pattern: r'MyClass'); | |
| expect(declarationsResult.declarations, hasLength(4)); | |
| } | |
| Future<void> test_mixin() async { | |
| addTestFile(r''' | |
| mixin M { | |
| int f; | |
| int get g => 0; | |
| void set s(_) {} | |
| void m() {} | |
| } | |
| '''); | |
| await _getDeclarations(); | |
| assertHas('M', ElementKind.MIXIN); | |
| assertHas('f', ElementKind.FIELD, mixinName: 'M'); | |
| assertHas('g', ElementKind.GETTER, mixinName: 'M'); | |
| assertHas('s', ElementKind.SETTER, mixinName: 'M'); | |
| assertHas('m', ElementKind.METHOD, mixinName: 'M'); | |
| } | |
| Future<void> test_multipleFiles() async { | |
| var a = newFile('$testPackageLibPath/a.dart', 'class A {}').path; | |
| var b = newFile('$testPackageLibPath/b.dart', 'class B {}').path; | |
| await _getDeclarations(); | |
| expect(declarationsResult.files, contains(a)); | |
| expect(declarationsResult.files, contains(b)); | |
| { | |
| var declaration = declarationsResult.declarations.singleWhere( | |
| (d) => d.name == 'A', | |
| ); | |
| expect(declaration.name, 'A'); | |
| expect(declaration.kind, ElementKind.CLASS); | |
| expect(declarationsResult.files[declaration.fileIndex], a); | |
| expect(declaration.offset, 6); | |
| expect(declaration.line, 1); | |
| expect(declaration.column, 7); | |
| } | |
| { | |
| var declaration = declarationsResult.declarations.singleWhere( | |
| (d) => d.name == 'B', | |
| ); | |
| expect(declaration.name, 'B'); | |
| expect(declaration.kind, ElementKind.CLASS); | |
| expect(declarationsResult.files[declaration.fileIndex], b); | |
| } | |
| } | |
| Future<void> test_onlyForFile() async { | |
| var a = newFile('$testPackageLibPath/a.dart', 'class A {}').path; | |
| newFile('$testPackageLibPath/b.dart', 'class B {}').path; | |
| await _getDeclarations(file: a); | |
| expect(declarationsResult.files, [a]); | |
| expect(declarationsResult.declarations, hasLength(1)); | |
| var declaration = declarationsResult.declarations[0]; | |
| expect(declaration.name, 'A'); | |
| expect(declaration.kind, ElementKind.CLASS); | |
| expect(declarationsResult.files[declaration.fileIndex], a); | |
| } | |
| Future<void> test_parameters() async { | |
| addTestFile(r''' | |
| void f(bool a, String b) {} | |
| '''); | |
| await _getDeclarations(); | |
| var declaration = assertHas('f', ElementKind.FUNCTION); | |
| expect(declaration.parameters, '(bool a, String b)'); | |
| } | |
| /// Elements in part files should return paths of the definitions, not the | |
| /// parent library. | |
| Future<void> test_parts() async { | |
| var b = newFile('$testPackageLibPath/b.dart', "part 'test.dart';").path; | |
| addTestFile(''' | |
| part of 'b.dart'; | |
| class [!A!] {} | |
| '''); | |
| await _getDeclarations(pattern: 'A'); | |
| expect(declarationsResult.files, isNot(contains(b))); | |
| expect(declarationsResult.files, contains(testFile.path)); | |
| var declaration = declarationsResult.declarations.singleWhere( | |
| (d) => d.name == 'A', | |
| ); | |
| expect(declaration.name, 'A'); | |
| expect(declaration.kind, ElementKind.CLASS); | |
| expect(declarationsResult.files[declaration.fileIndex], testFile.path); | |
| expect(declaration.offset, parsedSourceRange.offset); | |
| expect(declaration.line, parsedRange.range.start.line + 1); | |
| expect(declaration.column, parsedRange.range.start.character + 1); | |
| } | |
| Future<void> test_top() async { | |
| addTestFile(r''' | |
| int get g => 0; | |
| void set s(_) {} | |
| void f(int p) {} | |
| int v; | |
| typedef void tf1(); | |
| typedef tf2<T> = int Function<S>(T tp, S sp); | |
| typedef td3 = double; | |
| '''); | |
| await _getDeclarations(); | |
| assertHas('g', ElementKind.GETTER); | |
| assertHas('s', ElementKind.SETTER); | |
| assertHas('f', ElementKind.FUNCTION); | |
| assertHas('v', ElementKind.TOP_LEVEL_VARIABLE); | |
| assertHas('tf1', ElementKind.TYPE_ALIAS); | |
| assertHas('tf2', ElementKind.TYPE_ALIAS); | |
| assertHas('td3', ElementKind.TYPE_ALIAS); | |
| } | |
| Future<void> _getDeclarations({ | |
| String? file, | |
| String? pattern, | |
| int? maxResults, | |
| }) async { | |
| var request = SearchGetElementDeclarationsParams( | |
| file: file, | |
| pattern: pattern, | |
| maxResults: maxResults, | |
| ).toRequest('0', clientUriConverter: server.uriConverter); | |
| var response = await handleSuccessfulRequest(request); | |
| declarationsResult = SearchGetElementDeclarationsResult.fromResponse( | |
| response, | |
| clientUriConverter: server.uriConverter, | |
| ); | |
| } | |
| } |