blob: e066bb4c60c07aa1bece29ac2824925726783767 [file]
// Copyright (c) 2026, 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/dart/element/element.dart';
import 'package:analyzer/src/error/element_usage_frontier_detector.dart' // ignore: implementation_imports
show ElementUsageFrontierDetector;
import 'package:analyzer/src/utilities/extensions/ast.dart'; // ignore: implementation_imports
/// Reports uses of tagged elements with an [ElementUsageFrontierDetector].
///
/// Each declaration is pushed onto the detector while its contents are
/// visited, so that the detector reports a use only if the use is not inside
/// a declaration that is itself tagged. This is the "frontier" between the
/// tagged and the untagged code.
class ElementUsageFrontierVisitor<TagInfo extends Object>
extends RecursiveAstVisitor<void> {
final ElementUsageFrontierDetector<TagInfo> _detector;
new(this._detector);
@override
void visitAssignmentExpression(AssignmentExpression node) {
_detector.assignmentExpression(node);
super.visitAssignmentExpression(node);
}
@override
void visitBinaryExpression(BinaryExpression node) {
_detector.binaryExpression(node);
super.visitBinaryExpression(node);
}
@override
void visitClassDeclaration(ClassDeclaration node) {
_withDeclaration(node, () {
super.visitClassDeclaration(node);
});
}
@override
void visitClassTypeAlias(ClassTypeAlias node) {
_withDeclaration(node, () {
super.visitClassTypeAlias(node);
});
}
@override
void visitCompilationUnit(CompilationUnit node) {
var library = node.declaredFragment?.element;
if (library == null) {
return;
}
_detector.pushElement(library);
super.visitCompilationUnit(node);
}
@override
void visitConstructorDeclaration(ConstructorDeclaration node) {
_withDeclaration(node, () {
_detector.constructorDeclaration(node);
super.visitConstructorDeclaration(node);
});
}
@override
void visitConstructorName(ConstructorName node) {
_detector.constructorName(node);
super.visitConstructorName(node);
}
@override
void visitEnumDeclaration(EnumDeclaration node) {
_withDeclaration(node, () {
super.visitEnumDeclaration(node);
});
}
@override
void visitExportDirective(ExportDirective node) {
_detector.exportDirective(node);
super.visitExportDirective(node);
}
@override
void visitExtensionDeclaration(ExtensionDeclaration node) {
_withDeclaration(node, () {
super.visitExtensionDeclaration(node);
});
}
@override
void visitExtensionOverride(ExtensionOverride node) {
_detector.extensionOverride(node);
super.visitExtensionOverride(node);
}
@override
void visitExtensionTypeDeclaration(ExtensionTypeDeclaration node) {
_withDeclaration(node, () {
super.visitExtensionTypeDeclaration(node);
});
}
@override
void visitFieldDeclaration(FieldDeclaration node) {
_detector.pushElement(node.firstVariableElement);
try {
super.visitFieldDeclaration(node);
} finally {
_detector.popElement();
}
}
@override
void visitFieldFormalParameter(FieldFormalParameter node) {
_withFormalParameter(node, () {
super.visitFieldFormalParameter(node);
});
}
@override
void visitFunctionDeclaration(FunctionDeclaration node) {
_withDeclaration(node, () {
super.visitFunctionDeclaration(node);
});
}
@override
void visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
_detector.functionExpressionInvocation(node);
super.visitFunctionExpressionInvocation(node);
}
@override
void visitFunctionTypeAlias(FunctionTypeAlias node) {
_withDeclaration(node, () {
super.visitFunctionTypeAlias(node);
});
}
@override
void visitGenericTypeAlias(GenericTypeAlias node) {
_withDeclaration(node, () {
super.visitGenericTypeAlias(node);
});
}
@override
void visitImportDirective(ImportDirective node) {
_detector.importDirective(node);
super.visitImportDirective(node);
}
@override
void visitIndexExpression(IndexExpression node) {
_detector.indexExpression(node);
super.visitIndexExpression(node);
}
@override
void visitInstanceCreationExpression(InstanceCreationExpression node) {
_detector.instanceCreationExpression(node);
super.visitInstanceCreationExpression(node);
}
@override
void visitMethodDeclaration(MethodDeclaration node) {
_withDeclaration(node, () {
super.visitMethodDeclaration(node);
});
}
@override
void visitMethodInvocation(MethodInvocation node) {
_detector.methodInvocation(node);
super.visitMethodInvocation(node);
}
@override
void visitMixinDeclaration(MixinDeclaration node) {
_withDeclaration(node, () {
super.visitMixinDeclaration(node);
});
}
@override
void visitNamedType(NamedType node) {
_detector.namedType(node);
super.visitNamedType(node);
}
@override
void visitPatternField(PatternField node) {
_detector.patternField(node);
super.visitPatternField(node);
}
@override
void visitPostfixExpression(PostfixExpression node) {
_detector.postfixExpression(node);
super.visitPostfixExpression(node);
}
@override
void visitPrefixExpression(PrefixExpression node) {
_detector.prefixExpression(node);
super.visitPrefixExpression(node);
}
@override
void visitRedirectingConstructorInvocation(
RedirectingConstructorInvocation node,
) {
_detector.redirectingConstructorInvocation(node);
super.visitRedirectingConstructorInvocation(node);
}
@override
void visitRegularFormalParameter(RegularFormalParameter node) {
_withFormalParameter(node, () {
super.visitRegularFormalParameter(node);
});
}
@override
void visitSimpleIdentifier(SimpleIdentifier node) {
_detector.simpleIdentifier(node);
super.visitSimpleIdentifier(node);
}
@override
void visitSuperConstructorInvocation(SuperConstructorInvocation node) {
_detector.superConstructorInvocation(node);
super.visitSuperConstructorInvocation(node);
}
@override
void visitSuperFormalParameter(SuperFormalParameter node) {
_withFormalParameter(node, () {
super.visitSuperFormalParameter(node);
});
}
@override
void visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
_detector.pushElement(node.firstVariableElement);
try {
super.visitTopLevelVariableDeclaration(node);
} finally {
_detector.popElement();
}
}
void _withDeclaration<T extends Declaration>(
T node,
void Function() recurse,
) {
_withFragment(node.declaredFragment, recurse);
}
void _withFormalParameter<T extends FormalParameter>(
T node,
void Function() recurse,
) {
_withFragment(node.declaredFragment, recurse);
}
void _withFragment(Fragment? fragment, void Function() recurse) {
_detector.pushElement(fragment?.element);
try {
recurse();
} finally {
_detector.popElement();
}
}
}