[clang-tools-extra] [clang-tidy] Add readability-redundant-override check (PR #242955)
via cfe-commits
cfe-commits at lists.llvm.org
Sun Nov 15 19:53:46 PST 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang-tidy
Author: Richard Thomson (LegalizeAdulthood)
<details>
<summary>Changes</summary>
Find overrides that only forward to an inherited implementation. Support inline definitions and paired removal of header declarations and out-of-line definitions.
Restrict removal to public methods inherited publicly. Preserve cases that affect access, contracts, overload resolution, copies, or known member-pointer uses, and never offer partial fixes.
Add documentation and regression coverage, including compilation of fixed code under native and Linux targets.
Fixes #<!-- -->27431.
---
Patch is 30.65 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/242955.diff
11 Files Affected:
- (modified) clang-tools-extra/clang-tidy/readability/CMakeLists.txt (+1)
- (modified) clang-tools-extra/clang-tidy/readability/ReadabilityTidyModule.cpp (+3)
- (added) clang-tools-extra/clang-tidy/readability/RedundantOverrideCheck.cpp (+223)
- (added) clang-tools-extra/clang-tidy/readability/RedundantOverrideCheck.h (+40)
- (modified) clang-tools-extra/docs/ReleaseNotes.md (+7)
- (modified) clang-tools-extra/docs/clang-tidy/checks/list.md (+1)
- (added) clang-tools-extra/docs/clang-tidy/checks/readability/redundant-override.md (+59)
- (added) clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/redundant-override/header.h (+24)
- (added) clang-tools-extra/test/clang-tidy/checkers/readability/redundant-override-cxx98.cpp (+13)
- (added) clang-tools-extra/test/clang-tidy/checkers/readability/redundant-override-header.cpp (+20)
- (added) clang-tools-extra/test/clang-tidy/checkers/readability/redundant-override.cpp (+370)
``````````diff
diff --git a/clang-tools-extra/clang-tidy/readability/CMakeLists.txt b/clang-tools-extra/clang-tidy/readability/CMakeLists.txt
index 11cadf9f398792..f3a94a7cc30258 100644
--- a/clang-tools-extra/clang-tidy/readability/CMakeLists.txt
+++ b/clang-tools-extra/clang-tidy/readability/CMakeLists.txt
@@ -47,6 +47,7 @@ add_clang_library(clangTidyReadabilityModule STATIC
RedundantLambdaParameterListCheck.cpp
RedundantMemberInitCheck.cpp
RedundantNestedIfCheck.cpp
+ RedundantOverrideCheck.cpp
RedundantParenthesesCheck.cpp
RedundantPreprocessorCheck.cpp
RedundantQualifiedAliasCheck.cpp
diff --git a/clang-tools-extra/clang-tidy/readability/ReadabilityTidyModule.cpp b/clang-tools-extra/clang-tidy/readability/ReadabilityTidyModule.cpp
index 0592ae5f1bf606..8dbedbd7d643e1 100644
--- a/clang-tools-extra/clang-tidy/readability/ReadabilityTidyModule.cpp
+++ b/clang-tools-extra/clang-tidy/readability/ReadabilityTidyModule.cpp
@@ -49,6 +49,7 @@
#include "RedundantLambdaParameterListCheck.h"
#include "RedundantMemberInitCheck.h"
#include "RedundantNestedIfCheck.h"
+#include "RedundantOverrideCheck.h"
#include "RedundantParenthesesCheck.h"
#include "RedundantPreprocessorCheck.h"
#include "RedundantQualifiedAliasCheck.h"
@@ -153,6 +154,8 @@ class ReadabilityModule : public ClangTidyModule {
"readability-redundant-member-init");
CheckFactories.registerCheck<RedundantNestedIfCheck>(
"readability-redundant-nested-if");
+ CheckFactories.registerCheck<RedundantOverrideCheck>(
+ "readability-redundant-override");
CheckFactories.registerCheck<RedundantParenthesesCheck>(
"readability-redundant-parentheses");
CheckFactories.registerCheck<RedundantPreprocessorCheck>(
diff --git a/clang-tools-extra/clang-tidy/readability/RedundantOverrideCheck.cpp b/clang-tools-extra/clang-tidy/readability/RedundantOverrideCheck.cpp
new file mode 100644
index 00000000000000..93ad5a8c618344
--- /dev/null
+++ b/clang-tools-extra/clang-tidy/readability/RedundantOverrideCheck.cpp
@@ -0,0 +1,223 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "RedundantOverrideCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Attr.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/AST/ExprCXX.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+#include "llvm/ADT/STLExtras.h"
+#include <algorithm>
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::readability {
+
+static bool isForwardingType(QualType Type) {
+ return Type->isVoidType() || Type->isReferenceType() ||
+ (Type->isScalarType() && !Type.isVolatileQualified());
+}
+
+static bool hasAdditionalInterface(const CXXMethodDecl *Method) {
+ for (const FunctionDecl *Redecl : Method->redecls()) {
+ if (Redecl->getBeginLoc().isMacroID() || Redecl->getEndLoc().isMacroID())
+ return true;
+ if (llvm::any_of(Redecl->attrs(),
+ [](const Attr *A) { return !isa<OverrideAttr>(A); }))
+ return true;
+ if (llvm::any_of(Redecl->parameters(), [](const ParmVarDecl *P) {
+ return P->hasDefaultArg() || P->hasAttrs() ||
+ !isForwardingType(P->getType());
+ }))
+ return true;
+ }
+ return false;
+}
+
+static bool hasOtherOverloads(const CXXRecordDecl *Record,
+ const CXXMethodDecl *Method) {
+ return llvm::any_of(
+ Record->lookup(Method->getDeclName()), [Method](const NamedDecl *D) {
+ return D->getCanonicalDecl() != Method->getCanonicalDecl();
+ });
+}
+
+static const CXXMethodDecl *getRedundantBase(const CXXMethodDecl *Method,
+ ASTContext &Context) {
+ const CXXRecordDecl *Record = Method->getParent();
+ if (Method->size_overridden_methods() != 1 || Method->isPureVirtual() ||
+ !Method->getDeclName().isIdentifier() || Record->isDependentContext() ||
+ isa<ClassTemplateSpecializationDecl>(Record) ||
+ Method->getTemplatedKind() != FunctionDecl::TK_NonTemplate ||
+ Record->getNumBases() != 1 || Record->hasAttrs() ||
+ hasAdditionalInterface(Method))
+ return nullptr;
+
+ const CXXMethodDecl *Base = *Method->begin_overridden_methods();
+ const CXXBaseSpecifier &Inheritance = *Record->bases_begin();
+ const CXXRecordDecl *BaseRecord = Inheritance.getType()->getAsCXXRecordDecl();
+ if (!BaseRecord || Inheritance.isVirtual() || Base->isPureVirtual() ||
+ Base->getAccess() != AS_public ||
+ isa<ClassTemplateSpecializationDecl>(BaseRecord) ||
+ BaseRecord->hasAttrs() ||
+ BaseRecord->getCanonicalDecl() != Base->getParent()->getCanonicalDecl() ||
+ hasAdditionalInterface(Base) || hasOtherOverloads(Record, Method) ||
+ hasOtherOverloads(BaseRecord, Base))
+ return nullptr;
+
+ // Removing the override must preserve access through the derived class,
+ // including access restricted by protected or private inheritance.
+ const AccessSpecifier InheritedAccess =
+ std::max(Base->getAccess(), Inheritance.getAccessSpecifier());
+ if (InheritedAccess != AS_public || Method->getAccess() != InheritedAccess ||
+ !Context.hasSameType(Method->getType(), Base->getType()) ||
+ !isForwardingType(Method->getReturnType()) ||
+ Method->isConstexpr() != Base->isConstexpr() ||
+ Method->isConsteval() != Base->isConsteval())
+ return nullptr;
+
+ const auto *MethodType = Method->getType()->castAs<FunctionProtoType>();
+ const auto *BaseType = Base->getType()->castAs<FunctionProtoType>();
+ if (MethodType->isVariadic() || MethodType->hasDynamicExceptionSpec() ||
+ MethodType->getExceptionSpecType() != BaseType->getExceptionSpecType() ||
+ isUnresolvedExceptionSpec(MethodType->getExceptionSpecType()) ||
+ MethodType->canThrow() == CT_Dependent ||
+ MethodType->canThrow() != BaseType->canThrow())
+ return nullptr;
+
+ const auto *Body = dyn_cast<CompoundStmt>(Method->getBody());
+ if (!Body || Body->size() != 1)
+ return nullptr;
+ const Stmt *Statement = Body->body_front();
+ const Expr *Expression = nullptr;
+ if (const auto *Return = dyn_cast<ReturnStmt>(Statement))
+ Expression = Return->getRetValue();
+ else if (Method->getReturnType()->isVoidType())
+ Expression = dyn_cast<Expr>(Statement);
+ if (!Expression)
+ return nullptr;
+
+ const auto *Call =
+ dyn_cast<CXXMemberCallExpr>(Expression->IgnoreParenImpCasts());
+ if (!Call || !Call->getMethodDecl() || Call->getExprLoc().isMacroID() ||
+ Call->getMethodDecl()->getCanonicalDecl() != Base->getCanonicalDecl() ||
+ Call->getNumArgs() != Method->getNumParams())
+ return nullptr;
+ const auto *Member =
+ dyn_cast<MemberExpr>(Call->getCallee()->IgnoreParenImpCasts());
+ if (!Member || !Member->hasQualifier() ||
+ !isa<CXXThisExpr>(
+ Call->getImplicitObjectArgument()->IgnoreParenImpCasts()))
+ return nullptr;
+ for (unsigned I = 0; I != Call->getNumArgs(); ++I) {
+ const auto *Argument =
+ dyn_cast<DeclRefExpr>(Call->getArg(I)->IgnoreParenImpCasts());
+ if (!Argument || Argument->getLocation().isMacroID() ||
+ Argument->getDecl() != Method->getParamDecl(I))
+ return nullptr;
+ }
+ return Base;
+}
+
+static bool getRemovalRanges(const CXXMethodDecl *Method,
+ const SourceManager &SM,
+ const LangOptions &LangOpts,
+ SmallVectorImpl<CharSourceRange> &Ranges) {
+ for (const FunctionDecl *Redecl : Method->redecls()) {
+ const SourceRange Range = Redecl->getSourceRange();
+ if (Range.isInvalid() || Range.getBegin().isMacroID() ||
+ Range.getEnd().isMacroID() || SM.isInSystemHeader(Range.getBegin()))
+ return false;
+ // A shared declaration such as "void f(), g();" cannot be removed whole.
+ for (const Decl *Other : Redecl->getLexicalDeclContext()->decls())
+ if (Other->getCanonicalDecl() != Redecl->getCanonicalDecl() &&
+ Other->getBeginLoc() == Range.getBegin())
+ return false;
+
+ CharSourceRange FileRange = Lexer::makeFileCharRange(
+ CharSourceRange::getTokenRange(Range), SM, LangOpts);
+ if (FileRange.isInvalid())
+ return false;
+ if (!Redecl->doesThisDeclarationHaveABody()) {
+ const SourceLocation AfterSemicolon = Lexer::findLocationAfterToken(
+ Range.getEnd(), tok::semi, SM, LangOpts,
+ /*SkipTrailingWhitespaceAndNewLine=*/false);
+ if (AfterSemicolon.isInvalid())
+ return false;
+ FileRange.setEnd(AfterSemicolon);
+ }
+ SourceLocation Loc = FileRange.getBegin();
+ while (Loc < FileRange.getEnd()) {
+ Token Tok;
+ if (Lexer::getRawToken(Loc, Tok, SM, LangOpts,
+ /*IgnoreWhiteSpace=*/true))
+ return false;
+ if (Tok.getLocation() >= FileRange.getEnd())
+ break;
+ if (Tok.isOneOf(tok::hash, tok::eof))
+ return false;
+ Loc = Tok.getEndLoc();
+ }
+ Ranges.push_back(FileRange);
+ }
+ return true;
+}
+
+bool RedundantOverrideCheck::isLanguageVersionSupported(
+ const LangOptions &LangOpts) const {
+ return LangOpts.CPlusPlus;
+}
+
+std::optional<TraversalKind>
+RedundantOverrideCheck::getCheckTraversalKind() const {
+ return TK_IgnoreUnlessSpelledInSource;
+}
+
+void RedundantOverrideCheck::registerMatchers(MatchFinder *Finder) {
+ Finder->addMatcher(cxxMethodDecl(isDefinition(), isVirtual(),
+ unless(cxxDestructorDecl()),
+ hasBody(compoundStmt(statementCountIs(1))))
+ .bind("method"),
+ this);
+ Finder->addMatcher(declRefExpr(to(cxxMethodDecl().bind("referenced-method"))),
+ this);
+}
+
+void RedundantOverrideCheck::check(const MatchFinder::MatchResult &Result) {
+ if (const auto *Reference =
+ Result.Nodes.getNodeAs<CXXMethodDecl>("referenced-method")) {
+ // A pointer-to-member or its type can depend on the derived declaration.
+ ReferencedMethods.insert(Reference->getCanonicalDecl());
+ return;
+ }
+ const auto *Method = Result.Nodes.getNodeAs<CXXMethodDecl>("method");
+ if (getRedundantBase(Method, *Result.Context))
+ Candidates.push_back(Method);
+}
+
+void RedundantOverrideCheck::onEndOfTranslationUnit() {
+ for (const CXXMethodDecl *Method : Candidates) {
+ if (ReferencedMethods.contains(Method->getCanonicalDecl()) ||
+ Method->getLocation().isMacroID())
+ continue;
+ SmallVector<CharSourceRange, 2> Ranges;
+ if (!getRemovalRanges(Method, Method->getASTContext().getSourceManager(),
+ getLangOpts(), Ranges))
+ continue;
+ const auto Diag = diag(Method->getLocation(), "redundant override of %0")
+ << *Method->begin_overridden_methods();
+ for (CharSourceRange Range : Ranges)
+ Diag << FixItHint::CreateRemoval(Range);
+ }
+ Candidates.clear();
+ ReferencedMethods.clear();
+}
+
+} // namespace clang::tidy::readability
diff --git a/clang-tools-extra/clang-tidy/readability/RedundantOverrideCheck.h b/clang-tools-extra/clang-tidy/readability/RedundantOverrideCheck.h
new file mode 100644
index 00000000000000..f325097e96021a
--- /dev/null
+++ b/clang-tools-extra/clang-tidy/readability/RedundantOverrideCheck.h
@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANTOVERRIDECHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANTOVERRIDECHECK_H
+
+#include "../ClangTidyCheck.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace clang::tidy::readability {
+
+/// Finds overrides that only forward to the inherited implementation without
+/// changing its interface.
+///
+/// For the user-facing documentation see:
+/// https://clang.llvm.org/extra/clang-tidy/checks/readability/redundant-override.html
+class RedundantOverrideCheck : public ClangTidyCheck {
+public:
+ using ClangTidyCheck::ClangTidyCheck;
+ bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
+ void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+ void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+ void onEndOfTranslationUnit() override;
+
+private:
+ std::optional<TraversalKind> getCheckTraversalKind() const override;
+
+ SmallVector<const CXXMethodDecl *, 8> Candidates;
+ llvm::SmallPtrSet<const CXXMethodDecl *, 8> ReferencedMethods;
+};
+
+} // namespace clang::tidy::readability
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANTOVERRIDECHECK_H
diff --git a/clang-tools-extra/docs/ReleaseNotes.md b/clang-tools-extra/docs/ReleaseNotes.md
index b6774370511feb..b5ddec9e413341 100644
--- a/clang-tools-extra/docs/ReleaseNotes.md
+++ b/clang-tools-extra/docs/ReleaseNotes.md
@@ -174,6 +174,13 @@ infrastructure are described first, followed by tool-specific sections.
Finds uses of `#pragma comment` and, for `lib` or `linker` comments, suggests
using the build system for improved portability.
+- New {doc}`readability-redundant-override
+ <clang-tidy/checks/readability/redundant-override>` check.
+
+ Removes overrides that only forward to an inherited implementation
+ without changing its interface, including declarations and out-of-line
+ definitions in different files.
+
- New {doc}`readability-redundant-zero-initializer
<clang-tidy/checks/readability/redundant-zero-initializer>` check.
diff --git a/clang-tools-extra/docs/clang-tidy/checks/list.md b/clang-tools-extra/docs/clang-tidy/checks/list.md
index ec20c380131852..c17a3cde342b9e 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/list.md
+++ b/clang-tools-extra/docs/clang-tidy/checks/list.md
@@ -427,6 +427,7 @@ readability/*
| {doc}`readability-redundant-lambda-parameter-list <readability/redundant-lambda-parameter-list>` | Yes |
| {doc}`readability-redundant-member-init <readability/redundant-member-init>` | Yes |
| {doc}`readability-redundant-nested-if <readability/redundant-nested-if>` | Yes |
+| {doc}`readability/redundant-override` | Yes |
| {doc}`readability-redundant-parentheses <readability/redundant-parentheses>` | Yes |
| {doc}`readability-redundant-preprocessor <readability/redundant-preprocessor>` | |
| {doc}`readability-redundant-qualified-alias <readability/redundant-qualified-alias>` | Yes |
diff --git a/clang-tools-extra/docs/clang-tidy/checks/readability/redundant-override.md b/clang-tools-extra/docs/clang-tidy/checks/readability/redundant-override.md
new file mode 100644
index 00000000000000..c1722c1e3154b0
--- /dev/null
+++ b/clang-tools-extra/docs/clang-tidy/checks/readability/redundant-override.md
@@ -0,0 +1,59 @@
+```{title} clang-tidy - readability-redundant-override
+```
+
+# readability-redundant-override
+
+Finds virtual overrides that only forward their arguments to the inherited
+implementation on the same object, without changing its interface.
+
+For example:
+
+```c++
+struct Base {
+ virtual void f() {}
+};
+
+struct Derived : Base {
+ void f() override { Base::f(); }
+};
+```
+
+becomes:
+
+```c++
+struct Base {
+ virtual void f() {}
+};
+
+struct Derived : Base {};
+```
+
+Both inline definitions and out-of-line definitions are supported. When an
+override is declared in a header and defined in a source file, the fix
+removes both declarations. The check skips an override if any declaration
+or definition cannot be safely removed, including shared declarations and
+ranges containing preprocessor directives. It never offers a partial fix.
+
+Access is compared after accounting for the inheritance access specifier.
+Only public methods inherited publicly are considered for removal.
+Non-public methods and non-public inheritance are preserved. Even matching
+non-public access can change access from code in the base class when an
+override is removed.
+
+The check is deliberately conservative. It requires one non-virtual direct
+base class declaring the overridden method, a single forwarding call, and
+unchanged function types and exception specifications. It does not diagnose
+overrides involving:
+
+- Pure virtual base methods, `final`, or additional attributes.
+- Default arguments or overload sets that would affect name lookup.
+- Class objects passed or returned by value, or changed argument order or
+ expressions.
+- Templates, multiple inheritance, or virtual inheritance.
+- Macro-generated declarations or forwarding calls.
+- References to the overriding method that can observe its member-pointer
+ identity or type in the analyzed translation unit.
+
+As with removing any member function, uses outside the analyzed translation
+unit and binary compatibility require review. All affected translation
+units should be rebuilt after applying the fix.
diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/redundant-override/header.h b/clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/redundant-override/header.h
new file mode 100644
index 00000000000000..7a61a56f7fa2d2
--- /dev/null
+++ b/clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/redundant-override/header.h
@@ -0,0 +1,24 @@
+#ifndef REDUNDANT_OVERRIDE_HEADER_H
+#define REDUNDANT_OVERRIDE_HEADER_H
+
+struct HeaderBase {
+ virtual void f() {}
+ virtual int value(int n) const { return n; }
+};
+
+struct HeaderDerived : HeaderBase {
+ void f() override;
+ int value(int n) const override;
+};
+// CHECK-FIXES: struct HeaderDerived : HeaderBase {
+// CHECK-FIXES-NOT: f()
+// CHECK-FIXES-NOT: value(
+// CHECK-FIXES: };
+
+struct HeaderVisibility : protected HeaderBase {
+ void f() override;
+};
+// CHECK-FIXES: struct HeaderVisibility : protected HeaderBase {
+// CHECK-FIXES-NEXT: void f() override;
+
+#endif
diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-override-cxx98.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-override-cxx98.cpp
new file mode 100644
index 00000000000000..01c99b610b5ebd
--- /dev/null
+++ b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-override-cxx98.cpp
@@ -0,0 +1,13 @@
+// RUN: %check_clang_tidy -std=c++98 %s readability-redundant-override %t
+// RUN: %clang_cc1 -std=c++98 -fsyntax-only %t.cpp
+
+struct Base {
+ virtual void f() {}
+};
+struct Derived : Base {
+ virtual void f() { Base::f(); }
+};
+// CHECK-MESSAGES: :[[@LINE-2]]:16: warning: redundant override
+// CHECK-FIXES: struct Derived : Base {
+// CHECK-FIXES-NOT: f()
+// CHECK-FIXES: };
diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-override-header.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-override-header.cpp
new file mode 100644
index 00000000000000..be83baf7fdfa53
--- /dev/null
+++ b/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-override-header.cpp
@@ -0,0 +1,20 @@
+// RUN: %check_clang_tidy -check-header %S/Inputs/redundant-override/header.h \
+// RUN: %s readability-redundant-override %t
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -I%t.cpp.headers %t.cpp
+
+#include "header.h"
+
+void HeaderDerived::f() { HeaderBase::f(); }
+// CHECK-MESSAGES: :[[@LINE-1]]:21: warning: redundant override
+// CHECK-FIXES-NOT: void HeaderDerived::f()
+int HeaderDerived::value(int n) const { return HeaderBase::value(n); }
+// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: redundant override
+// CHECK-FIXES-NOT: int HeaderDerived::value(
+
+void HeaderVisibility::f() { HeaderBase::f(); }
+// CHECK-FIXES: void HeaderVisibility::f() { HeaderBase::f(); }
+
+void use(HeaderDerived &object) {
+ object.f();
+ object.value(1);
+}
diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/redundant-overri...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/242955
More information about the cfe-commits
mailing list