From e04eec7977725f73cf21ef2e3312822b97846a2f Mon Sep 17 00:00:00 2001 From: Sam Rawlins Date: Tue, 25 Feb 2025 11:19:20 -0800 Subject: [PATCH 1/6] Introduce an analyzer plugin for the test package. --- pkgs/test_analyzer_plugin/README.md | 13 +++++ pkgs/test_analyzer_plugin/lib/main.dart | 20 +++++++ pkgs/test_analyzer_plugin/lib/src/fixes.dart | 58 +++++++++++++++++++ pkgs/test_analyzer_plugin/lib/src/rules.dart | 53 +++++++++++++++++ .../lib/src/utilities.dart | 37 ++++++++++++ pkgs/test_analyzer_plugin/pubspec.yaml | 12 ++++ 6 files changed, 193 insertions(+) create mode 100644 pkgs/test_analyzer_plugin/README.md create mode 100644 pkgs/test_analyzer_plugin/lib/main.dart create mode 100644 pkgs/test_analyzer_plugin/lib/src/fixes.dart create mode 100644 pkgs/test_analyzer_plugin/lib/src/rules.dart create mode 100644 pkgs/test_analyzer_plugin/lib/src/utilities.dart create mode 100644 pkgs/test_analyzer_plugin/pubspec.yaml diff --git a/pkgs/test_analyzer_plugin/README.md b/pkgs/test_analyzer_plugin/README.md new file mode 100644 index 000000000..1f157181a --- /dev/null +++ b/pkgs/test_analyzer_plugin/README.md @@ -0,0 +1,13 @@ +# test_analyzer_plugin + +This package is an analyzer plugin that provides additional static analysis for +usage of the test package. + +This analyzer plugin provides the following additional analysis: + +* Report a warning when a `test` or a `group` is declared inside a `test` + declaration. This can _sometimes_ be detected at runtime. This warning is + reported statically. + +* Offer a quick fix in the IDE for the above warning, which moves the violating + `test` or `group` declaration below the containing `test` declaration. \ No newline at end of file diff --git a/pkgs/test_analyzer_plugin/lib/main.dart b/pkgs/test_analyzer_plugin/lib/main.dart new file mode 100644 index 000000000..a7445cf0b --- /dev/null +++ b/pkgs/test_analyzer_plugin/lib/main.dart @@ -0,0 +1,20 @@ +// Copyright (c) 2025, 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_plugin/plugin.dart'; +import 'package:analysis_server_plugin/registry.dart'; + +import 'src/fixes.dart'; +import 'src/rules.dart'; + +final plugin = TestPackagePlugin(); + +class TestPackagePlugin extends Plugin { + @override + void register(PluginRegistry registry) { + registry.registerWarningRule(TestInTestRule()); + registry.registerFixForRule( + TestInTestRule.code, MoveBelowEnclosingTestCall.new); + } +} diff --git a/pkgs/test_analyzer_plugin/lib/src/fixes.dart b/pkgs/test_analyzer_plugin/lib/src/fixes.dart new file mode 100644 index 000000000..98af4aa3e --- /dev/null +++ b/pkgs/test_analyzer_plugin/lib/src/fixes.dart @@ -0,0 +1,58 @@ +// Copyright (c) 2025, 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_plugin/edit/dart/correction_producer.dart'; +import 'package:analysis_server_plugin/edit/dart/dart_fix_kind_priority.dart'; +import 'package:analyzer/dart/ast/ast.dart'; +import 'package:analyzer_plugin/utilities/change_builder/change_builder_core.dart'; +import 'package:analyzer_plugin/utilities/fixes/fixes.dart'; +import 'package:analyzer_plugin/utilities/range_factory.dart'; + +import 'utilities.dart'; + +class MoveBelowEnclosingTestCall extends ResolvedCorrectionProducer { + static const _wrapInQuotesKind = FixKind( + 'dart.fix.moveBelowEnclosingTestCall', + DartFixKindPriority.standard, + "Move below the enclosing 'test' call"); + + MoveBelowEnclosingTestCall({required super.context}); + + @override + CorrectionApplicability get applicability => + // This fix may break code by moving references to variables away from the + // scope in which they are declared. + CorrectionApplicability.singleLocation; + + @override + FixKind get fixKind => _wrapInQuotesKind; + + @override + Future compute(ChangeBuilder builder) async { + var methodCall = node; + if (methodCall is! MethodInvocation) return; + AstNode? enclosingTestCall = findEnclosingTestCall(methodCall); + if (enclosingTestCall == null) return; + + if (enclosingTestCall.parent is ExpressionStatement) { + // Move the 'test' call to below the outer 'test' call _statement_. + enclosingTestCall = enclosingTestCall.parent!; + } + + if (methodCall.parent is ExpressionStatement) { + // Move the whole statement (don't leave the semicolon dangling). + methodCall = methodCall.parent!; + } + + await builder.addDartFileEdit(file, (builder) { + var indent = utils.getLinePrefix(enclosingTestCall!.offset); + var source = utils.getRangeText(range.node(methodCall)); + + // Move the source for `methodCall` wholsale to be just after `enclosingTestCall`. + builder.addDeletion(range.deletionRange(methodCall)); + builder.addSimpleInsertion( + enclosingTestCall.end, '$eol$eol$indent$source'); + }); + } +} diff --git a/pkgs/test_analyzer_plugin/lib/src/rules.dart b/pkgs/test_analyzer_plugin/lib/src/rules.dart new file mode 100644 index 000000000..bf4634ec0 --- /dev/null +++ b/pkgs/test_analyzer_plugin/lib/src/rules.dart @@ -0,0 +1,53 @@ +// Copyright (c) 2025, 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:analyzer/dart/ast/ast.dart'; +import 'package:analyzer/dart/ast/visitor.dart'; +import 'package:analyzer/src/dart/error/lint_codes.dart'; +import 'package:analyzer/src/lint/linter.dart'; + +import 'utilities.dart'; + +class TestInTestRule extends AnalysisRule { + static const LintCode code = LintCode( + 'test_in_test', + "Do not declare a 'test' or a 'group' inside a 'test'", + correctionMessage: "Try moving 'test' or 'group' outside of 'test'", + ); + + TestInTestRule() + : super( + name: 'test_in_test', + description: + 'Tests and groups declared inside of a test are not properly ' + 'registered in the test framework.', + ); + + @override + LintCode get lintCode => code; + + @override + void registerNodeProcessors( + NodeLintRegistry registry, LinterContext context) { + var visitor = _Visitor(this); + registry.addMethodInvocation(this, visitor); + } +} + +class _Visitor extends SimpleAstVisitor { + final AnalysisRule rule; + + _Visitor(this.rule); + + @override + void visitMethodInvocation(MethodInvocation node) { + if (!node.methodName.isTest && !node.methodName.isGroup) { + return; + } + var enclosingTestCall = findEnclosingTestCall(node); + if (enclosingTestCall != null) { + rule.reportLint(node); + } + } +} diff --git a/pkgs/test_analyzer_plugin/lib/src/utilities.dart b/pkgs/test_analyzer_plugin/lib/src/utilities.dart new file mode 100644 index 000000000..0de22044c --- /dev/null +++ b/pkgs/test_analyzer_plugin/lib/src/utilities.dart @@ -0,0 +1,37 @@ +// Copyright (c) 2025, 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:analyzer/dart/ast/ast.dart'; + +/// Finds an enclosing call to the 'test' function, if there is one. +MethodInvocation? findEnclosingTestCall(MethodInvocation node) { + var ancestor = node.parent?.thisOrAncestorOfType(); + while (ancestor != null) { + if (ancestor.methodName.isTest) { + return ancestor; + } + ancestor = ancestor.parent?.thisOrAncestorOfType(); + } + return null; +} + +extension SimpleIdentifierExtension on SimpleIdentifier { + /// Whether this identifier represents the 'test' function from the + /// 'test_core' package. + bool get isTest { + final element = this.element; + if (element == null) return false; + if (element.name3 != 'test') return false; + return element.library2?.uri.path.startsWith('test_core/') ?? false; + } + + /// Whether this identifier represents the 'group' function from the + /// 'test_core' package. + bool get isGroup { + final element = this.element; + if (element == null) return false; + if (element.name3 != 'group') return false; + return element.library2?.uri.path.startsWith('test_core/') ?? false; + } +} diff --git a/pkgs/test_analyzer_plugin/pubspec.yaml b/pkgs/test_analyzer_plugin/pubspec.yaml new file mode 100644 index 000000000..9a434a305 --- /dev/null +++ b/pkgs/test_analyzer_plugin/pubspec.yaml @@ -0,0 +1,12 @@ +name: test_analyzer_plugin +description: An analyzer plugin to report improper usage of the test package. +version: 1.0.0 +publish_to: none + +environment: + sdk: '>=3.6.0 <4.0.0' + +dependencies: + analysis_server_plugin: any + analyzer: ^7.2.0 + From 6cc66f1fcb3e3f4c43fb836818cc84d6ce1d63d5 Mon Sep 17 00:00:00 2001 From: Sam Rawlins Date: Tue, 4 Mar 2025 10:56:59 -0800 Subject: [PATCH 2/6] feedback --- pkgs/test_analyzer_plugin/lib/src/fixes.dart | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/test_analyzer_plugin/lib/src/fixes.dart b/pkgs/test_analyzer_plugin/lib/src/fixes.dart index 98af4aa3e..87d35f55b 100644 --- a/pkgs/test_analyzer_plugin/lib/src/fixes.dart +++ b/pkgs/test_analyzer_plugin/lib/src/fixes.dart @@ -12,7 +12,7 @@ import 'package:analyzer_plugin/utilities/range_factory.dart'; import 'utilities.dart'; class MoveBelowEnclosingTestCall extends ResolvedCorrectionProducer { - static const _wrapInQuotesKind = FixKind( + static const _moveBelowEnclosingTestCallKind = FixKind( 'dart.fix.moveBelowEnclosingTestCall', DartFixKindPriority.standard, "Move below the enclosing 'test' call"); @@ -26,7 +26,7 @@ class MoveBelowEnclosingTestCall extends ResolvedCorrectionProducer { CorrectionApplicability.singleLocation; @override - FixKind get fixKind => _wrapInQuotesKind; + FixKind get fixKind => _moveBelowEnclosingTestCallKind; @override Future compute(ChangeBuilder builder) async { From eaedfb3e02aba61dbcf2accd2882cf74bb051cde Mon Sep 17 00:00:00 2001 From: Sam Rawlins Date: Tue, 8 Jul 2025 12:13:24 -0700 Subject: [PATCH 3/6] Add another rule: non_nullable_is_not_null_rule --- pkgs/test_analyzer_plugin/lib/main.dart | 17 +++- .../rules/non_nullable_is_not_null_rule.dart | 81 ++++++++++++++++++ .../test_in_test_rule.dart} | 14 ++-- .../lib/src/utilities.dart | 31 ++++++- pkgs/test_analyzer_plugin/pubspec.yaml | 17 ++++ .../rules/non_nullable_is_not_null_test.dart | 84 +++++++++++++++++++ 6 files changed, 235 insertions(+), 9 deletions(-) create mode 100644 pkgs/test_analyzer_plugin/lib/src/rules/non_nullable_is_not_null_rule.dart rename pkgs/test_analyzer_plugin/lib/src/{rules.dart => rules/test_in_test_rule.dart} (76%) create mode 100644 pkgs/test_analyzer_plugin/test/rules/non_nullable_is_not_null_test.dart diff --git a/pkgs/test_analyzer_plugin/lib/main.dart b/pkgs/test_analyzer_plugin/lib/main.dart index a7445cf0b..952ea3575 100644 --- a/pkgs/test_analyzer_plugin/lib/main.dart +++ b/pkgs/test_analyzer_plugin/lib/main.dart @@ -6,7 +6,8 @@ import 'package:analysis_server_plugin/plugin.dart'; import 'package:analysis_server_plugin/registry.dart'; import 'src/fixes.dart'; -import 'src/rules.dart'; +import 'src/rules/non_nullable_is_not_null_rule.dart'; +import 'src/rules/test_in_test_rule.dart'; final plugin = TestPackagePlugin(); @@ -16,5 +17,19 @@ class TestPackagePlugin extends Plugin { registry.registerWarningRule(TestInTestRule()); registry.registerFixForRule( TestInTestRule.code, MoveBelowEnclosingTestCall.new); + + registry.registerWarningRule(NonNullableIsNotNullRule()); + // Should we register a fix for this rule? The only automatic fix I can + // think of would be to delete the entire statement: + // `expect(a, isNotNull);` or `expect(a, isNull);`. + + // TODO(srawlins): More rules to catch: + // * `expect(7, contains(6))` - should only use `hasLength` with `Iterable` + // or `String`. + // * `expect(7, hasLength(3))` - should only use `hasLength` with `Iterable` + // or `String`. + // * `expect([].isEmpty, isFalse)` - should use `isEmpty` matcher. + // * `expect([].isNotEmpty, isTrue)` - should use `isNotEmpty` matcher. + // * `expect([].contains(7), isFalse)` - should use `contains` matcher. } } diff --git a/pkgs/test_analyzer_plugin/lib/src/rules/non_nullable_is_not_null_rule.dart b/pkgs/test_analyzer_plugin/lib/src/rules/non_nullable_is_not_null_rule.dart new file mode 100644 index 000000000..ddd6d6a49 --- /dev/null +++ b/pkgs/test_analyzer_plugin/lib/src/rules/non_nullable_is_not_null_rule.dart @@ -0,0 +1,81 @@ +// Copyright (c) 2025, 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:analyzer/analysis_rule/analysis_rule.dart'; +import 'package:analyzer/analysis_rule/rule_context.dart'; +import 'package:analyzer/analysis_rule/rule_visitor_registry.dart'; +import 'package:analyzer/dart/ast/ast.dart'; +import 'package:analyzer/dart/ast/visitor.dart'; +import 'package:analyzer/dart/element/type_system.dart'; +import 'package:analyzer/error/error.dart'; + +import '../utilities.dart'; + +// TODO(srawlins): Several others; use same name or just different codes? +// * `expect(null, isNotNull)` - always false +// * `expect(null, isNull)` - always true +// * `expect(7, isNull)` - always false +class NonNullableIsNotNullRule extends MultiAnalysisRule { + static const LintCode nonNullableIsNotNullCode = LintCode( + 'non_nullable_is_not_null', + 'Do not check whether a non-nullable value isNotNull', + correctionMessage: 'Try changing the expectation, or removing it', + ); + + static const LintCode nonNullableIsNullCode = LintCode( + 'non_nullable_is_null', + 'Do not check whether a non-nullable value isNull', + correctionMessage: 'Try changing the expectation, or removing it', + ); + + NonNullableIsNotNullRule() + : super( + name: 'non_nullable_is_not_null', + description: "Non-nullable values will always pass an 'isNotNull' " + "expectation and never pass an 'isNull' expectation.", + ); + + @override + List get diagnosticCodes => [nonNullableIsNotNullCode]; + + @override + void registerNodeProcessors( + RuleVisitorRegistry registry, RuleContext context) { + var visitor = _Visitor(this, context.typeSystem); + registry.addMethodInvocation(this, visitor); + } +} + +class _Visitor extends SimpleAstVisitor { + final MultiAnalysisRule rule; + + final TypeSystem typeSystem; + + _Visitor(this.rule, this.typeSystem); + + @override + void visitMethodInvocation(MethodInvocation node) { + if (!node.methodName.isExpect) { + return; + } + + if (node.argumentList.arguments + case [var actual, SimpleIdentifier matcher]) { + var actualType = actual.staticType; + if (actualType == null) return; + if (typeSystem.isNonNullable(actualType)) { + if (matcher.isNotNull) { + // The actual value will always match this matcher. + rule.reportAtNode(matcher, + diagnosticCode: + NonNullableIsNotNullRule.nonNullableIsNotNullCode); + } else if (matcher.isNull) { + // The actual value will never match this matcher. + rule.reportAtNode(matcher, + diagnosticCode: NonNullableIsNotNullRule.nonNullableIsNullCode); + } + } + } + } +} diff --git a/pkgs/test_analyzer_plugin/lib/src/rules.dart b/pkgs/test_analyzer_plugin/lib/src/rules/test_in_test_rule.dart similarity index 76% rename from pkgs/test_analyzer_plugin/lib/src/rules.dart rename to pkgs/test_analyzer_plugin/lib/src/rules/test_in_test_rule.dart index bf4634ec0..9c3ae89cf 100644 --- a/pkgs/test_analyzer_plugin/lib/src/rules.dart +++ b/pkgs/test_analyzer_plugin/lib/src/rules/test_in_test_rule.dart @@ -2,12 +2,14 @@ // 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:analyzer/analysis_rule/analysis_rule.dart'; +import 'package:analyzer/analysis_rule/rule_context.dart'; +import 'package:analyzer/analysis_rule/rule_visitor_registry.dart'; import 'package:analyzer/dart/ast/ast.dart'; import 'package:analyzer/dart/ast/visitor.dart'; -import 'package:analyzer/src/dart/error/lint_codes.dart'; -import 'package:analyzer/src/lint/linter.dart'; +import 'package:analyzer/error/error.dart'; -import 'utilities.dart'; +import '../utilities.dart'; class TestInTestRule extends AnalysisRule { static const LintCode code = LintCode( @@ -25,11 +27,11 @@ class TestInTestRule extends AnalysisRule { ); @override - LintCode get lintCode => code; + LintCode get diagnosticCode => code; @override void registerNodeProcessors( - NodeLintRegistry registry, LinterContext context) { + RuleVisitorRegistry registry, RuleContext context) { var visitor = _Visitor(this); registry.addMethodInvocation(this, visitor); } @@ -47,7 +49,7 @@ class _Visitor extends SimpleAstVisitor { } var enclosingTestCall = findEnclosingTestCall(node); if (enclosingTestCall != null) { - rule.reportLint(node); + rule.reportAtNode(node); } } } diff --git a/pkgs/test_analyzer_plugin/lib/src/utilities.dart b/pkgs/test_analyzer_plugin/lib/src/utilities.dart index 0de22044c..5226a4949 100644 --- a/pkgs/test_analyzer_plugin/lib/src/utilities.dart +++ b/pkgs/test_analyzer_plugin/lib/src/utilities.dart @@ -23,7 +23,7 @@ extension SimpleIdentifierExtension on SimpleIdentifier { final element = this.element; if (element == null) return false; if (element.name3 != 'test') return false; - return element.library2?.uri.path.startsWith('test_core/') ?? false; + return element.library?.uri.path.startsWith('test_core/') ?? false; } /// Whether this identifier represents the 'group' function from the @@ -32,6 +32,33 @@ extension SimpleIdentifierExtension on SimpleIdentifier { final element = this.element; if (element == null) return false; if (element.name3 != 'group') return false; - return element.library2?.uri.path.startsWith('test_core/') ?? false; + return element.library?.uri.path.startsWith('test_core/') ?? false; + } + + /// Whether this identifier represents the 'expect' function from the + /// 'matcher' package. + bool get isExpect { + final element = this.element; + if (element == null) return false; + if (element.name3 != 'expect') return false; + return element.library?.uri.path.startsWith('matcher/') ?? false; + } + + /// Whether this identifier represents the 'isNotNull' constant from the + /// 'matcher' package. + bool get isNotNull { + final element = this.element; + if (element == null) return false; + if (element.name3 != 'isNotNull') return false; + return element.library?.uri.path.startsWith('matcher/') ?? false; + } + + /// Whether this identifier represents the 'isNull' constant from the + /// 'matcher' package. + bool get isNull { + final element = this.element; + if (element == null) return false; + if (element.name3 != 'isNull') return false; + return element.library?.uri.path.startsWith('matcher/') ?? false; } } diff --git a/pkgs/test_analyzer_plugin/pubspec.yaml b/pkgs/test_analyzer_plugin/pubspec.yaml index 9a434a305..69e1131bf 100644 --- a/pkgs/test_analyzer_plugin/pubspec.yaml +++ b/pkgs/test_analyzer_plugin/pubspec.yaml @@ -9,4 +9,21 @@ environment: dependencies: analysis_server_plugin: any analyzer: ^7.2.0 + analyzer_plugin: + analyzer_testing: +dev_dependencies: + test: any + test_reflective_loader: any + +dependency_overrides: + _fe_analyzer_shared: + path: /Users/srawlins/code/dart-sdk/sdk/pkg/_fe_analyzer_shared + analysis_server_plugin: + path: /Users/srawlins/code/dart-sdk/sdk/pkg/analysis_server_plugin + analyzer: + path: /Users/srawlins/code/dart-sdk/sdk/pkg/analyzer + analyzer_plugin: + path: /Users/srawlins/code/dart-sdk/sdk/pkg/analyzer_plugin + analyzer_testing: + path: /Users/srawlins/code/dart-sdk/sdk/pkg/analyzer_testing diff --git a/pkgs/test_analyzer_plugin/test/rules/non_nullable_is_not_null_test.dart b/pkgs/test_analyzer_plugin/test/rules/non_nullable_is_not_null_test.dart new file mode 100644 index 000000000..98828b171 --- /dev/null +++ b/pkgs/test_analyzer_plugin/test/rules/non_nullable_is_not_null_test.dart @@ -0,0 +1,84 @@ +// Copyright (c) 2023, 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. + +// ignore_for_file: non_constant_identifier_names + +import 'package:analyzer/src/lint/registry.dart'; +import 'package:analyzer/utilities/package_config_file_builder.dart'; +import 'package:analyzer_testing/analysis_rule/analysis_rule.dart'; +import 'package:test_analyzer_plugin/src/rules/non_nullable_is_not_null_rule.dart'; +import 'package:test_reflective_loader/test_reflective_loader.dart'; + +void main() { + defineReflectiveSuite(() { + defineReflectiveTests(NonNullableIsNotNullTest); + }); +} + +@reflectiveTest +class NonNullableIsNotNullTest extends AnalysisRuleTest { + @override + void setUp() { + Registry.ruleRegistry.registerLintRule(NonNullableIsNotNullRule()); + + super.setUp(); + + var matcherPath = '/packages/matcher'; + newFile('$matcherPath/lib/matcher.dart', ''' +void expect(dynamic actual, dynamic matcher) {} + +const isNotNull = 0; +const isNull = 0; +'''); + writeTestPackageConfig( + PackageConfigFileBuilder() + ..add(name: 'matcher', rootPath: convertPath(matcherPath)), + ); + } + + @override + String get analysisRule => 'non_nullable_is_not_null'; + + void test_nullableValue_isNotNullMatcher() async { + await assertNoDiagnostics(r''' +import 'package:matcher/matcher.dart'; +void f(String? p) { + expect(p, isNotNull); +} +'''); + } + + void test_nonNullableValue_isNotNullMatcher() async { + await assertDiagnostics( + r''' +import 'package:matcher/matcher.dart'; +void f() { + expect(123, isNotNull); +} +''', + [lint(64, 9)], + ); + } + + void test_nullableValue_isNullMatcher() async { + await assertNoDiagnostics(r''' +import 'package:matcher/matcher.dart'; +void f(String? p) { + expect(p, isNull); +} +'''); + } + + void test_nonNullableValue_isNullMatcher() async { + await assertDiagnostics( + r''' +import 'package:matcher/matcher.dart'; +void f() { + expect(123, isNull); +} +''', + [lint(64, 6, name: 'non_nullable_is_null')], + ); + } +} From f128a0d908c03b22140cff5547bd94f0d16b0012 Mon Sep 17 00:00:00 2001 From: Sam Rawlins Date: Fri, 15 Aug 2025 11:04:48 -0700 Subject: [PATCH 4/6] Bump to analysis_server_plugin 0.2.2 --- pkgs/test_analyzer_plugin/lib/src/fixes.dart | 2 +- .../lib/src/utilities.dart | 10 +++---- pkgs/test_analyzer_plugin/pubspec.yaml | 30 +++++++++---------- 3 files changed, 21 insertions(+), 21 deletions(-) diff --git a/pkgs/test_analyzer_plugin/lib/src/fixes.dart b/pkgs/test_analyzer_plugin/lib/src/fixes.dart index 87d35f55b..a470c6404 100644 --- a/pkgs/test_analyzer_plugin/lib/src/fixes.dart +++ b/pkgs/test_analyzer_plugin/lib/src/fixes.dart @@ -52,7 +52,7 @@ class MoveBelowEnclosingTestCall extends ResolvedCorrectionProducer { // Move the source for `methodCall` wholsale to be just after `enclosingTestCall`. builder.addDeletion(range.deletionRange(methodCall)); builder.addSimpleInsertion( - enclosingTestCall.end, '$eol$eol$indent$source'); + enclosingTestCall.end, '$defaultEol$defaultEol$indent$source'); }); } } diff --git a/pkgs/test_analyzer_plugin/lib/src/utilities.dart b/pkgs/test_analyzer_plugin/lib/src/utilities.dart index 5226a4949..3ff142b3d 100644 --- a/pkgs/test_analyzer_plugin/lib/src/utilities.dart +++ b/pkgs/test_analyzer_plugin/lib/src/utilities.dart @@ -22,7 +22,7 @@ extension SimpleIdentifierExtension on SimpleIdentifier { bool get isTest { final element = this.element; if (element == null) return false; - if (element.name3 != 'test') return false; + if (element.name != 'test') return false; return element.library?.uri.path.startsWith('test_core/') ?? false; } @@ -31,7 +31,7 @@ extension SimpleIdentifierExtension on SimpleIdentifier { bool get isGroup { final element = this.element; if (element == null) return false; - if (element.name3 != 'group') return false; + if (element.name != 'group') return false; return element.library?.uri.path.startsWith('test_core/') ?? false; } @@ -40,7 +40,7 @@ extension SimpleIdentifierExtension on SimpleIdentifier { bool get isExpect { final element = this.element; if (element == null) return false; - if (element.name3 != 'expect') return false; + if (element.name != 'expect') return false; return element.library?.uri.path.startsWith('matcher/') ?? false; } @@ -49,7 +49,7 @@ extension SimpleIdentifierExtension on SimpleIdentifier { bool get isNotNull { final element = this.element; if (element == null) return false; - if (element.name3 != 'isNotNull') return false; + if (element.name != 'isNotNull') return false; return element.library?.uri.path.startsWith('matcher/') ?? false; } @@ -58,7 +58,7 @@ extension SimpleIdentifierExtension on SimpleIdentifier { bool get isNull { final element = this.element; if (element == null) return false; - if (element.name3 != 'isNull') return false; + if (element.name != 'isNull') return false; return element.library?.uri.path.startsWith('matcher/') ?? false; } } diff --git a/pkgs/test_analyzer_plugin/pubspec.yaml b/pkgs/test_analyzer_plugin/pubspec.yaml index 69e1131bf..9c7051546 100644 --- a/pkgs/test_analyzer_plugin/pubspec.yaml +++ b/pkgs/test_analyzer_plugin/pubspec.yaml @@ -7,23 +7,23 @@ environment: sdk: '>=3.6.0 <4.0.0' dependencies: - analysis_server_plugin: any - analyzer: ^7.2.0 - analyzer_plugin: - analyzer_testing: + analysis_server_plugin: ^0.2.2 + analyzer: ^8.0.0 + analyzer_plugin: ^0.13.6 + analyzer_testing: ^0.1.2 dev_dependencies: test: any test_reflective_loader: any -dependency_overrides: - _fe_analyzer_shared: - path: /Users/srawlins/code/dart-sdk/sdk/pkg/_fe_analyzer_shared - analysis_server_plugin: - path: /Users/srawlins/code/dart-sdk/sdk/pkg/analysis_server_plugin - analyzer: - path: /Users/srawlins/code/dart-sdk/sdk/pkg/analyzer - analyzer_plugin: - path: /Users/srawlins/code/dart-sdk/sdk/pkg/analyzer_plugin - analyzer_testing: - path: /Users/srawlins/code/dart-sdk/sdk/pkg/analyzer_testing + #dependency_overrides: + # _fe_analyzer_shared: + # path: /Users/srawlins/code/dart-sdk/sdk/pkg/_fe_analyzer_shared + # analysis_server_plugin: + # path: /Users/srawlins/code/dart-sdk/sdk/pkg/analysis_server_plugin + # analyzer: + # path: /Users/srawlins/code/dart-sdk/sdk/pkg/analyzer + # analyzer_plugin: + # path: /Users/srawlins/code/dart-sdk/sdk/pkg/analyzer_plugin + # analyzer_testing: + # path: /Users/srawlins/code/dart-sdk/sdk/pkg/analyzer_testing From 54ab763ecb43dcf2b913cc885929e4b23fc074c9 Mon Sep 17 00:00:00 2001 From: Sam Rawlins Date: Fri, 24 Oct 2025 12:26:54 -0700 Subject: [PATCH 5/6] Bump to work with analysis_server_plugin 0.3.0 --- pkgs/test_analyzer_plugin/lib/main.dart | 2 ++ pkgs/test_analyzer_plugin/pubspec.yaml | 12 ++++++------ 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/pkgs/test_analyzer_plugin/lib/main.dart b/pkgs/test_analyzer_plugin/lib/main.dart index 952ea3575..1a9caa14b 100644 --- a/pkgs/test_analyzer_plugin/lib/main.dart +++ b/pkgs/test_analyzer_plugin/lib/main.dart @@ -12,6 +12,8 @@ import 'src/rules/test_in_test_rule.dart'; final plugin = TestPackagePlugin(); class TestPackagePlugin extends Plugin { + String get name => 'Test package plugin'; + @override void register(PluginRegistry registry) { registry.registerWarningRule(TestInTestRule()); diff --git a/pkgs/test_analyzer_plugin/pubspec.yaml b/pkgs/test_analyzer_plugin/pubspec.yaml index 9c7051546..337bac63b 100644 --- a/pkgs/test_analyzer_plugin/pubspec.yaml +++ b/pkgs/test_analyzer_plugin/pubspec.yaml @@ -7,20 +7,20 @@ environment: sdk: '>=3.6.0 <4.0.0' dependencies: - analysis_server_plugin: ^0.2.2 - analyzer: ^8.0.0 - analyzer_plugin: ^0.13.6 - analyzer_testing: ^0.1.2 + analysis_server_plugin: ^0.3.0 + analyzer: ^8.4.0 + analyzer_plugin: ^0.13.5 dev_dependencies: + analyzer_testing: ^0.1.0 test: any test_reflective_loader: any - #dependency_overrides: +dependency_overrides: # _fe_analyzer_shared: # path: /Users/srawlins/code/dart-sdk/sdk/pkg/_fe_analyzer_shared # analysis_server_plugin: - # path: /Users/srawlins/code/dart-sdk/sdk/pkg/analysis_server_plugin + # path: /Users/srawlins/code/analysis_server_plugin # analyzer: # path: /Users/srawlins/code/dart-sdk/sdk/pkg/analyzer # analyzer_plugin: From 2635b72e1ff9088f86284ae91232d36558212d8f Mon Sep 17 00:00:00 2001 From: Sam Rawlins Date: Tue, 11 Nov 2025 22:06:58 -0800 Subject: [PATCH 6/6] bump to 3.10; add a rule --- pkgs/test_analyzer_plugin/README.md | 8 + pkgs/test_analyzer_plugin/lib/main.dart | 8 +- pkgs/test_analyzer_plugin/lib/src/fixes.dart | 11 +- .../rules/non_nullable_is_not_null_rule.dart | 43 ++--- .../lib/src/rules/test_in_test_rule.dart | 16 +- .../lib/src/rules/use_is_empty_matcher.dart | 111 +++++++++++++ .../lib/src/utilities.dart | 18 +++ pkgs/test_analyzer_plugin/pubspec.yaml | 19 +-- .../rules/non_nullable_is_not_null_test.dart | 2 +- .../test/rules/use_is_empty_matcher_test.dart | 152 ++++++++++++++++++ 10 files changed, 339 insertions(+), 49 deletions(-) create mode 100644 pkgs/test_analyzer_plugin/lib/src/rules/use_is_empty_matcher.dart create mode 100644 pkgs/test_analyzer_plugin/test/rules/use_is_empty_matcher_test.dart diff --git a/pkgs/test_analyzer_plugin/README.md b/pkgs/test_analyzer_plugin/README.md index 1f157181a..e0540b9a2 100644 --- a/pkgs/test_analyzer_plugin/README.md +++ b/pkgs/test_analyzer_plugin/README.md @@ -9,5 +9,13 @@ This analyzer plugin provides the following additional analysis: declaration. This can _sometimes_ be detected at runtime. This warning is reported statically. +* Report a warning when a non-nullable value is matched against `isNotNull` or + `isNull`. + +* Report a warning when an `expect` expectation of `true`, `false`, `isTrue`, + or `isFalse` is paired with a `.isEmpty` or `.isNotEmpty` property access on + an actual value. Instead, the `isEmpty` or `isNotEmpty` Matcher should be + used. + * Offer a quick fix in the IDE for the above warning, which moves the violating `test` or `group` declaration below the containing `test` declaration. \ No newline at end of file diff --git a/pkgs/test_analyzer_plugin/lib/main.dart b/pkgs/test_analyzer_plugin/lib/main.dart index 1a9caa14b..343e2c5f8 100644 --- a/pkgs/test_analyzer_plugin/lib/main.dart +++ b/pkgs/test_analyzer_plugin/lib/main.dart @@ -8,6 +8,7 @@ import 'package:analysis_server_plugin/registry.dart'; import 'src/fixes.dart'; import 'src/rules/non_nullable_is_not_null_rule.dart'; import 'src/rules/test_in_test_rule.dart'; +import 'src/rules/use_is_empty_matcher.dart'; final plugin = TestPackagePlugin(); @@ -18,9 +19,12 @@ class TestPackagePlugin extends Plugin { void register(PluginRegistry registry) { registry.registerWarningRule(TestInTestRule()); registry.registerFixForRule( - TestInTestRule.code, MoveBelowEnclosingTestCall.new); + TestInTestRule.code, + MoveBelowEnclosingTestCall.new, + ); registry.registerWarningRule(NonNullableIsNotNullRule()); + registry.registerWarningRule(UseIsEmptyMatcherRule()); // Should we register a fix for this rule? The only automatic fix I can // think of would be to delete the entire statement: // `expect(a, isNotNull);` or `expect(a, isNull);`. @@ -30,8 +34,6 @@ class TestPackagePlugin extends Plugin { // or `String`. // * `expect(7, hasLength(3))` - should only use `hasLength` with `Iterable` // or `String`. - // * `expect([].isEmpty, isFalse)` - should use `isEmpty` matcher. - // * `expect([].isNotEmpty, isTrue)` - should use `isNotEmpty` matcher. // * `expect([].contains(7), isFalse)` - should use `contains` matcher. } } diff --git a/pkgs/test_analyzer_plugin/lib/src/fixes.dart b/pkgs/test_analyzer_plugin/lib/src/fixes.dart index a470c6404..f2d36f8a1 100644 --- a/pkgs/test_analyzer_plugin/lib/src/fixes.dart +++ b/pkgs/test_analyzer_plugin/lib/src/fixes.dart @@ -13,9 +13,10 @@ import 'utilities.dart'; class MoveBelowEnclosingTestCall extends ResolvedCorrectionProducer { static const _moveBelowEnclosingTestCallKind = FixKind( - 'dart.fix.moveBelowEnclosingTestCall', - DartFixKindPriority.standard, - "Move below the enclosing 'test' call"); + 'dart.fix.moveBelowEnclosingTestCall', + DartFixKindPriority.standard, + "Move below the enclosing 'test' call", + ); MoveBelowEnclosingTestCall({required super.context}); @@ -52,7 +53,9 @@ class MoveBelowEnclosingTestCall extends ResolvedCorrectionProducer { // Move the source for `methodCall` wholsale to be just after `enclosingTestCall`. builder.addDeletion(range.deletionRange(methodCall)); builder.addSimpleInsertion( - enclosingTestCall.end, '$defaultEol$defaultEol$indent$source'); + enclosingTestCall.end, + '$defaultEol$defaultEol$indent$source', + ); }); } } diff --git a/pkgs/test_analyzer_plugin/lib/src/rules/non_nullable_is_not_null_rule.dart b/pkgs/test_analyzer_plugin/lib/src/rules/non_nullable_is_not_null_rule.dart index ddd6d6a49..4c826ae1e 100644 --- a/pkgs/test_analyzer_plugin/lib/src/rules/non_nullable_is_not_null_rule.dart +++ b/pkgs/test_analyzer_plugin/lib/src/rules/non_nullable_is_not_null_rule.dart @@ -12,10 +12,6 @@ import 'package:analyzer/error/error.dart'; import '../utilities.dart'; -// TODO(srawlins): Several others; use same name or just different codes? -// * `expect(null, isNotNull)` - always false -// * `expect(null, isNull)` - always true -// * `expect(7, isNull)` - always false class NonNullableIsNotNullRule extends MultiAnalysisRule { static const LintCode nonNullableIsNotNullCode = LintCode( 'non_nullable_is_not_null', @@ -30,18 +26,24 @@ class NonNullableIsNotNullRule extends MultiAnalysisRule { ); NonNullableIsNotNullRule() - : super( - name: 'non_nullable_is_not_null', - description: "Non-nullable values will always pass an 'isNotNull' " - "expectation and never pass an 'isNull' expectation.", - ); + : super( + name: 'non_nullable_is_not_null', + description: + "Non-nullable values will always pass an 'isNotNull' " + "expectation and never pass an 'isNull' expectation.", + ); @override - List get diagnosticCodes => [nonNullableIsNotNullCode]; + List get diagnosticCodes => [ + nonNullableIsNotNullCode, + nonNullableIsNullCode, + ]; @override void registerNodeProcessors( - RuleVisitorRegistry registry, RuleContext context) { + RuleVisitorRegistry registry, + RuleContext context, + ) { var visitor = _Visitor(this, context.typeSystem); registry.addMethodInvocation(this, visitor); } @@ -60,20 +62,25 @@ class _Visitor extends SimpleAstVisitor { return; } - if (node.argumentList.arguments - case [var actual, SimpleIdentifier matcher]) { + if (node.argumentList.arguments case [ + var actual, + SimpleIdentifier matcher, + ]) { var actualType = actual.staticType; if (actualType == null) return; if (typeSystem.isNonNullable(actualType)) { if (matcher.isNotNull) { // The actual value will always match this matcher. - rule.reportAtNode(matcher, - diagnosticCode: - NonNullableIsNotNullRule.nonNullableIsNotNullCode); + rule.reportAtNode( + matcher, + diagnosticCode: NonNullableIsNotNullRule.nonNullableIsNotNullCode, + ); } else if (matcher.isNull) { // The actual value will never match this matcher. - rule.reportAtNode(matcher, - diagnosticCode: NonNullableIsNotNullRule.nonNullableIsNullCode); + rule.reportAtNode( + matcher, + diagnosticCode: NonNullableIsNotNullRule.nonNullableIsNullCode, + ); } } } diff --git a/pkgs/test_analyzer_plugin/lib/src/rules/test_in_test_rule.dart b/pkgs/test_analyzer_plugin/lib/src/rules/test_in_test_rule.dart index 9c3ae89cf..05f639daa 100644 --- a/pkgs/test_analyzer_plugin/lib/src/rules/test_in_test_rule.dart +++ b/pkgs/test_analyzer_plugin/lib/src/rules/test_in_test_rule.dart @@ -19,19 +19,21 @@ class TestInTestRule extends AnalysisRule { ); TestInTestRule() - : super( - name: 'test_in_test', - description: - 'Tests and groups declared inside of a test are not properly ' - 'registered in the test framework.', - ); + : super( + name: 'test_in_test', + description: + 'Tests and groups declared inside of a test are not properly ' + 'registered in the test framework.', + ); @override LintCode get diagnosticCode => code; @override void registerNodeProcessors( - RuleVisitorRegistry registry, RuleContext context) { + RuleVisitorRegistry registry, + RuleContext context, + ) { var visitor = _Visitor(this); registry.addMethodInvocation(this, visitor); } diff --git a/pkgs/test_analyzer_plugin/lib/src/rules/use_is_empty_matcher.dart b/pkgs/test_analyzer_plugin/lib/src/rules/use_is_empty_matcher.dart new file mode 100644 index 000000000..99035e53c --- /dev/null +++ b/pkgs/test_analyzer_plugin/lib/src/rules/use_is_empty_matcher.dart @@ -0,0 +1,111 @@ +// Copyright (c) 2025, 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:analyzer/analysis_rule/analysis_rule.dart'; +import 'package:analyzer/analysis_rule/rule_context.dart'; +import 'package:analyzer/analysis_rule/rule_visitor_registry.dart'; +import 'package:analyzer/dart/ast/ast.dart'; +import 'package:analyzer/dart/ast/visitor.dart'; +import 'package:analyzer/dart/element/type_system.dart'; +import 'package:analyzer/error/error.dart'; + +import '../utilities.dart'; + +class UseIsEmptyMatcherRule extends MultiAnalysisRule { + static const LintCode useIsEmptyMatcherCode = LintCode( + 'use_is_empty_matcher', + "Use the 'isEmpty' matcher.", + ); + + static const LintCode useIsNotEmptyMatcherCode = LintCode( + 'use_is_not_empty_matcher', + "Use the 'isNotEmpty' matcher.", + ); + + UseIsEmptyMatcherRule() + : super( + name: 'use_is_empty_matcher', + description: "Use the built-in 'isEmpty' and 'isNotEmpty' matchers.", + ); + + @override + List get diagnosticCodes => [ + useIsEmptyMatcherCode, + useIsNotEmptyMatcherCode, + ]; + + @override + void registerNodeProcessors( + RuleVisitorRegistry registry, + RuleContext context, + ) { + var visitor = _Visitor(this, context.typeSystem); + registry.addMethodInvocation(this, visitor); + } +} + +class _Visitor extends SimpleAstVisitor { + final MultiAnalysisRule rule; + + final TypeSystem typeSystem; + + _Visitor(this.rule, this.typeSystem); + + @override + void visitMethodInvocation(MethodInvocation node) { + if (!node.methodName.isExpect) return; + + var arguments = node.argumentList.arguments; + if (arguments.isEmpty || arguments.length > 2) return; + var [actual, matcher] = arguments; + + bool actualIsIsEmpty; + if (actual is PrefixedIdentifier) { + if (actual.identifier.name == 'isEmpty') { + actualIsIsEmpty = true; + } else if (actual.identifier.name == 'isNotEmpty') { + actualIsIsEmpty = false; + } else { + return; + } + } else if (actual is PropertyAccess) { + if (actual.propertyName.name == 'isEmpty') { + actualIsIsEmpty = true; + } else if (actual.propertyName.name == 'isNotEmpty') { + actualIsIsEmpty = false; + } else { + return; + } + } else { + return; + } + + bool matcherValue; + if (matcher is BooleanLiteral) { + matcherValue = matcher.value; + } else if (matcher is SimpleIdentifier && matcher.isIsFalse) { + matcherValue = false; + } else if (matcher is SimpleIdentifier && matcher.isIsTrue) { + matcherValue = true; + } else { + return; + } + + if (actualIsIsEmpty == matcherValue) { + // Either `expect(a.isEmpty, isTrue|true)` or + // `expect(a.isNotEmpty, isFalse|false)`. + rule.reportAtNode( + matcher, + diagnosticCode: UseIsEmptyMatcherRule.useIsEmptyMatcherCode, + ); + } else { + // Either `expect(a.isEmpty, isFalse|false)` or + // `expect(a.isNotEmpty, isTrue|true)`. + rule.reportAtNode( + matcher, + diagnosticCode: UseIsEmptyMatcherRule.useIsNotEmptyMatcherCode, + ); + } + } +} diff --git a/pkgs/test_analyzer_plugin/lib/src/utilities.dart b/pkgs/test_analyzer_plugin/lib/src/utilities.dart index 3ff142b3d..bb110d294 100644 --- a/pkgs/test_analyzer_plugin/lib/src/utilities.dart +++ b/pkgs/test_analyzer_plugin/lib/src/utilities.dart @@ -44,6 +44,24 @@ extension SimpleIdentifierExtension on SimpleIdentifier { return element.library?.uri.path.startsWith('matcher/') ?? false; } + /// Whether this identifier represents the 'isFalse' matcher from the + /// 'matcher' package. + bool get isIsFalse { + final element = this.element; + if (element == null) return false; + if (element.name != 'isFalse') return false; + return element.library?.uri.path.startsWith('matcher/') ?? false; + } + + /// Whether this identifier represents the 'isTrue' matcher from the + /// 'matcher' package. + bool get isIsTrue { + final element = this.element; + if (element == null) return false; + if (element.name != 'isTrue') return false; + return element.library?.uri.path.startsWith('matcher/') ?? false; + } + /// Whether this identifier represents the 'isNotNull' constant from the /// 'matcher' package. bool get isNotNull { diff --git a/pkgs/test_analyzer_plugin/pubspec.yaml b/pkgs/test_analyzer_plugin/pubspec.yaml index 337bac63b..a9a276c4d 100644 --- a/pkgs/test_analyzer_plugin/pubspec.yaml +++ b/pkgs/test_analyzer_plugin/pubspec.yaml @@ -1,10 +1,9 @@ name: test_analyzer_plugin description: An analyzer plugin to report improper usage of the test package. -version: 1.0.0 -publish_to: none +version: 0.1.0 environment: - sdk: '>=3.6.0 <4.0.0' + sdk: ^3.10.0 dependencies: analysis_server_plugin: ^0.3.0 @@ -12,18 +11,6 @@ dependencies: analyzer_plugin: ^0.13.5 dev_dependencies: - analyzer_testing: ^0.1.0 + analyzer_testing: ^0.1.2 test: any test_reflective_loader: any - -dependency_overrides: - # _fe_analyzer_shared: - # path: /Users/srawlins/code/dart-sdk/sdk/pkg/_fe_analyzer_shared - # analysis_server_plugin: - # path: /Users/srawlins/code/analysis_server_plugin - # analyzer: - # path: /Users/srawlins/code/dart-sdk/sdk/pkg/analyzer - # analyzer_plugin: - # path: /Users/srawlins/code/dart-sdk/sdk/pkg/analyzer_plugin - # analyzer_testing: - # path: /Users/srawlins/code/dart-sdk/sdk/pkg/analyzer_testing diff --git a/pkgs/test_analyzer_plugin/test/rules/non_nullable_is_not_null_test.dart b/pkgs/test_analyzer_plugin/test/rules/non_nullable_is_not_null_test.dart index 98828b171..abac2b0cf 100644 --- a/pkgs/test_analyzer_plugin/test/rules/non_nullable_is_not_null_test.dart +++ b/pkgs/test_analyzer_plugin/test/rules/non_nullable_is_not_null_test.dart @@ -1,4 +1,4 @@ -// Copyright (c) 2023, the Dart project authors. Please see the AUTHORS file +// Copyright (c) 2025, 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. diff --git a/pkgs/test_analyzer_plugin/test/rules/use_is_empty_matcher_test.dart b/pkgs/test_analyzer_plugin/test/rules/use_is_empty_matcher_test.dart new file mode 100644 index 000000000..68d898919 --- /dev/null +++ b/pkgs/test_analyzer_plugin/test/rules/use_is_empty_matcher_test.dart @@ -0,0 +1,152 @@ +// Copyright (c) 2025, 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. + +// ignore_for_file: non_constant_identifier_names + +import 'package:analyzer/src/lint/registry.dart'; +import 'package:analyzer/utilities/package_config_file_builder.dart'; +import 'package:analyzer_testing/analysis_rule/analysis_rule.dart'; +import 'package:test_analyzer_plugin/src/rules/use_is_empty_matcher.dart'; +import 'package:test_reflective_loader/test_reflective_loader.dart'; + +void main() { + defineReflectiveSuite(() { + defineReflectiveTests(UseIsEmptyMatcherTest); + }); +} + +@reflectiveTest +class UseIsEmptyMatcherTest extends AnalysisRuleTest { + @override + String get analysisRule => 'use_is_empty_matcher'; + + @override + void setUp() { + Registry.ruleRegistry.registerLintRule(UseIsEmptyMatcherRule()); + + super.setUp(); + + var matcherPath = '/packages/matcher'; + newFile('$matcherPath/lib/matcher.dart', ''' +void expect(dynamic actual, dynamic matcher) {} + +const isNotNull = 0; +const isNull = 0; + +const isEmpty = 0; +const isFalse = 0; +const isNotEmpty = 0; +const isTrue = 0; +'''); + writeTestPackageConfig( + PackageConfigFileBuilder() + ..add(name: 'matcher', rootPath: convertPath(matcherPath)), + ); + } + + void test_isEmpty_false() async { + await assertDiagnostics( + r''' +import 'package:matcher/matcher.dart'; +void f() { + expect(''.isEmpty, false); +} +''', + [lint(71, 5, name: 'use_is_not_empty_matcher')], + ); + } + + void test_isEmpty_isFalse() async { + await assertDiagnostics( + r''' +import 'package:matcher/matcher.dart'; +void f() { + expect(''.isEmpty, isFalse); +} +''', + [lint(71, 7, name: 'use_is_not_empty_matcher')], + ); + } + + void test_isEmpty_isTrue() async { + await assertDiagnostics( + r''' +import 'package:matcher/matcher.dart'; +void f() { + expect(''.isEmpty, isTrue); +} +''', + [lint(71, 6, messageContains: 'isEmpty')], + ); + } + + void test_isEmpty_true() async { + await assertDiagnostics( + r''' +import 'package:matcher/matcher.dart'; +void f() { + expect(''.isEmpty, true); +} +''', + [lint(71, 4, messageContains: 'isEmpty')], + ); + } + + void test_isEmptyMatcher() async { + await assertNoDiagnostics(r''' +import 'package:matcher/matcher.dart'; +void f() { + expect('', isEmpty); +} +'''); + } + + void test_isNotEmpty_false() async { + await assertDiagnostics( + r''' +import 'package:matcher/matcher.dart'; +void f() { + expect(''.isNotEmpty, false); +} +''', + [lint(74, 5, messageContains: 'isEmpty')], + ); + } + + void test_isNotEmpty_isFalse() async { + await assertDiagnostics( + r''' +import 'package:matcher/matcher.dart'; +void f() { + expect(''.isNotEmpty, isFalse); +} +''', + [lint(74, 7, messageContains: 'isEmpty')], + ); + } + + void test_isNotEmpty_isTrue() async { + await assertDiagnostics( + r''' +import 'package:matcher/matcher.dart'; +void f() { + expect(''.isNotEmpty, isTrue); +} +''', + [lint(74, 6, name: 'use_is_not_empty_matcher')], + ); + } + + void test_isNotEmpty_true() async { + await assertDiagnostics( + r''' +import 'package:matcher/matcher.dart'; +void f() { + expect(''.isNotEmpty, true); +} +''', + [lint(74, 4, name: 'use_is_not_empty_matcher')], + ); + } +}