diff --git a/clang-tools-extra/clang-tidy/objc/CMakeLists.txt b/clang-tools-extra/clang-tidy/objc/CMakeLists.txt --- a/clang-tools-extra/clang-tidy/objc/CMakeLists.txt +++ b/clang-tools-extra/clang-tidy/objc/CMakeLists.txt @@ -4,6 +4,7 @@ AvoidNSErrorInitCheck.cpp DeallocInCategoryCheck.cpp ForbiddenSubclassingCheck.cpp + MethodUnavailableNotOverrideCheck.cpp MissingHashCheck.cpp ObjCTidyModule.cpp PropertyDeclarationCheck.cpp diff --git a/clang-tools-extra/clang-tidy/objc/MethodUnavailableNotOverrideCheck.h b/clang-tools-extra/clang-tidy/objc/MethodUnavailableNotOverrideCheck.h new file mode 100644 --- /dev/null +++ b/clang-tools-extra/clang-tidy/objc/MethodUnavailableNotOverrideCheck.h @@ -0,0 +1,32 @@ +//===--- MethodUnavailableNotOverrideCheck.h - clang-tidy -------*- C++ -*-===// +// +// 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_OBJC_METHODUNAVAILABLENOTOVERRIDECHECK_H +#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_METHODUNAVAILABLENOTOVERRIDECHECK_H + +#include "../ClangTidyCheck.h" + +namespace clang { +namespace tidy { +namespace objc { + +/// Finds methods marked with __attribute__((unavailable)) that do not override +/// any declaration from a superclass. +class MethodUnavailableNotOverrideCheck : public ClangTidyCheck { +public: + MethodUnavailableNotOverrideCheck(StringRef Name, ClangTidyContext *Context) + : ClangTidyCheck(Name, Context) {} + void registerMatchers(ast_matchers::MatchFinder *Finder) override; + void check(const ast_matchers::MatchFinder::MatchResult &Result) override; +}; + +} // namespace objc +} // namespace tidy +} // namespace clang + +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_METHODUNAVAILABLENOTOVERRIDECHECK_H diff --git a/clang-tools-extra/clang-tidy/objc/MethodUnavailableNotOverrideCheck.cpp b/clang-tools-extra/clang-tidy/objc/MethodUnavailableNotOverrideCheck.cpp new file mode 100644 --- /dev/null +++ b/clang-tools-extra/clang-tidy/objc/MethodUnavailableNotOverrideCheck.cpp @@ -0,0 +1,50 @@ +//===--- MethodUnavailableNotOverrideCheck.cpp - clang-tidy ---------------===// +// +// 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 "MethodUnavailableNotOverrideCheck.h" +#include "clang/AST/ASTContext.h" +#include "clang/AST/Attr.h" +#include "clang/AST/DeclObjC.h" +#include "clang/ASTMatchers/ASTMatchFinder.h" +#include "clang/ASTMatchers/ASTMatchers.h" +#include "clang/Basic/Diagnostic.h" +#include "clang/Lex/Lexer.h" + +using namespace clang::ast_matchers; + +namespace clang { +namespace tidy { +namespace objc { + +// Check for Objective-C methods that are marked unavailable but are not +// overriding another method declaration. +AST_MATCHER(ObjCMethodDecl, isUnavailableMethodNotOverriding) { + return Node.isUnavailable() && !Node.isOverriding(); +} + +void MethodUnavailableNotOverrideCheck::registerMatchers(MatchFinder *Finder) { + if (!getLangOpts().ObjC) + return; + + Finder->addMatcher(objcMethodDecl(allOf(isUnavailableMethodNotOverriding(), + hasDeclContext(objcInterfaceDecl()))) + .bind("decl"), + this); +} + +void MethodUnavailableNotOverrideCheck::check( + const MatchFinder::MatchResult &Result) { + const auto *MD = Result.Nodes.getNodeAs("decl"); + diag(MD->getLocation(), "method %0 is marked unavailable but " + "does not override a superclass method") + << MD << FixItHint::CreateRemoval(MD->getSourceRange()); +} + +} // namespace objc +} // namespace tidy +} // namespace clang diff --git a/clang-tools-extra/clang-tidy/objc/ObjCTidyModule.cpp b/clang-tools-extra/clang-tidy/objc/ObjCTidyModule.cpp --- a/clang-tools-extra/clang-tidy/objc/ObjCTidyModule.cpp +++ b/clang-tools-extra/clang-tidy/objc/ObjCTidyModule.cpp @@ -12,6 +12,7 @@ #include "AvoidNSErrorInitCheck.h" #include "DeallocInCategoryCheck.h" #include "ForbiddenSubclassingCheck.h" +#include "MethodUnavailableNotOverrideCheck.h" #include "MissingHashCheck.h" #include "PropertyDeclarationCheck.h" #include "SuperSelfCheck.h" @@ -31,6 +32,8 @@ "objc-dealloc-in-category"); CheckFactories.registerCheck( "objc-forbidden-subclassing"); + CheckFactories.registerCheck( + "objc-method-unavailable-not-override"); CheckFactories.registerCheck( "objc-missing-hash"); CheckFactories.registerCheck( diff --git a/clang-tools-extra/docs/ReleaseNotes.rst b/clang-tools-extra/docs/ReleaseNotes.rst --- a/clang-tools-extra/docs/ReleaseNotes.rst +++ b/clang-tools-extra/docs/ReleaseNotes.rst @@ -98,6 +98,12 @@ Finds recursive functions and diagnoses them. +- New :doc:`objc-method-unavailable-not-override + ` check. + + Finds methods marked unavailable that do not override any method from a + superclass. + New check aliases ^^^^^^^^^^^^^^^^^ @@ -115,7 +121,7 @@ ^^^^^^^^^^^^^^^^^^^^^^^^^^ - Improved :doc:`readability-qualified-auto - ` check now supports a + ` check now supports a `AddConstToQualified` to enable adding ``const`` qualifiers to variables typed with ``auto *`` and ``auto &``. diff --git a/clang-tools-extra/docs/clang-tidy/checks/list.rst b/clang-tools-extra/docs/clang-tidy/checks/list.rst --- a/clang-tools-extra/docs/clang-tidy/checks/list.rst +++ b/clang-tools-extra/docs/clang-tidy/checks/list.rst @@ -236,6 +236,7 @@ `objc-avoid-nserror-init `_, `objc-dealloc-in-category `_, `objc-forbidden-subclassing `_, + `objc-method-unavailable-not-override `_, "Yes" `objc-missing-hash `_, `objc-property-declaration `_, "Yes" `objc-super-self `_, "Yes" @@ -283,7 +284,7 @@ `readability-redundant-member-init `_, "Yes" `readability-redundant-preprocessor `_, `readability-redundant-smartptr-get `_, "Yes" - `readability-redundant-string-cstr `_, + `readability-redundant-string-cstr `_, "Yes" `readability-redundant-string-init `_, "Yes" `readability-simplify-boolean-expr `_, "Yes" `readability-simplify-subscript-expr `_, "Yes" diff --git a/clang-tools-extra/docs/clang-tidy/checks/objc-method-unavailable-not-override.rst b/clang-tools-extra/docs/clang-tidy/checks/objc-method-unavailable-not-override.rst new file mode 100644 --- /dev/null +++ b/clang-tools-extra/docs/clang-tidy/checks/objc-method-unavailable-not-override.rst @@ -0,0 +1,20 @@ +.. title:: clang-tidy - objc-method-unavailable-not-override + +objc-method-unavailable-not-override +==================================== + +Checks that a method marked with __attribute__((unavailable)) is overriding +a method declaration from a superclass. That declaration can usually be +deleted entirely. + +.. code-block:: objc + + @interface ClassA : NSObject + // Neither ClassA nor any superclasses define method -foo. + @end + + @interface ClassB : ClassA + - (void)foo __attribute__((unavailable)); + @end + +Suggests a fix to remove the method declaration entirely. diff --git a/clang-tools-extra/test/clang-tidy/checkers/objc-method-unavailable-not-override.m b/clang-tools-extra/test/clang-tidy/checkers/objc-method-unavailable-not-override.m new file mode 100644 --- /dev/null +++ b/clang-tools-extra/test/clang-tidy/checkers/objc-method-unavailable-not-override.m @@ -0,0 +1,41 @@ +// RUN: %check_clang_tidy %s objc-method-unavailable-not-override %t + +__attribute__((objc_root_class)) +@interface Object +- (instancetype)init; +@end + +@interface MyObject : Object +- (instancetype)init __attribute__((unavailable)); +- (instancetype)initWithInt:(int)anInt; + +- (void)methodA __attribute__((unavailable)); +// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: method 'methodA' is marked unavailable but does not override a superclass method [objc-method-unavailable-not-override] + +// Verify the check catches the unavailable attribute when a message is provided. +- (void)methodB __attribute__((unavailable("use methodD"))); +// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: method 'methodB' is marked unavailable but does not override a superclass method [objc-method-unavailable-not-override] + +#define NS_UNAVAILABLE __attribute__((unavailable)) + +// Verify the check works with macros declaring the unavailable attribute. +- (void)methodC NS_UNAVAILABLE; +// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: method 'methodC' is marked unavailable but does not override a superclass method [objc-method-unavailable-not-override] +@end + + +@implementation MyObject + +- (instancetype)initWithInt:(int)anInt { + return 0; +} + +// Should not flag implementations for methods declared unavailable; sometimes +// implemementations are provided that assert, to catch such codepaths that +// lead to those calls during development. +- (void)methodA {} + +@end + +// Verify that fixes exist to delete entire method declarations: +// CHECK-FIXES: {{^\s*$}}