Support virtual-near-miss check.

[congliu]

Summary

Virtual function override near miss detection. Function complete. Test complete. Do not conduct Fix for now.

[alexfh]

Thank you for working on this! See the initial set of comments inline.

clang-tidy/misc/VirtualNearMissCheck.cpp

21

Parameters should be StringRef instead of const std::string &. StringRef is the most common way to pass a read-only string to a function in LLVM.

Also, there's already StringRef::edit_distance. It should do what you need, I guess.

23

Please use LLVM naming conventions (http://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly).

59

Why is the hasAttr<OverrideAttr>() part needed? Do you have an example of code that results in size_overridden_methods() == 0 and hasAttr<OverrideAttr>() == true?

62

Please maintain 80-columns limit. The easiest way to do this is to use clang-format (with -style=LLVM, if needed).

72

nit: Extra space before ==. Please use clang-format.

79

You can call .getNonReferenceType() unconditionally to make the code shorter.

84

clang-format

85

What if both return types are not references and are not pointers? Why do you return false in this case?

128

clang-format

129

No parentheses are needed around method calls here. Please remove.

130

Please use isa<T> instead of dyn_cast<T> in boolean context.

139

clang-format

144

clang-format

173

It's not common to use braces around one-line if bodies in LLVM/Clang code. Please remove the braces.

197

Comments should use proper Capitalization and punctuation. See http://llvm.org/docs/CodingStandards.html#commenting for details.

200

Please add a trailing period.

201

Dead/commented-out code should not be submitted. Either fix the code or remove the comment.

clang-tidy/misc/VirtualNearMissCheck.h

21

Please address the FIXME.

docs/clang-tidy/checks/misc-virtual-near-miss.rst

4

Please address the FIXME.

test/clang-tidy/misc-virtual-near-miss.cpp

3

Please use proper formatting for test code as well, unless some unusual formatting is needed for the purpose of testing. clang-format should do a good job on files in the test/ directory as well (the only difference with the "normal" code is that the // RUN: and // CHECK.* lines in tests may violate the column limit).

9

This comment is redundant. The CHECK-MESSAGES line below states clearly that a warning is expected.

17

To improve readability of the test, please remove the check name from all CHECK-MESSAGES lines except for the first one. When the CHECK-MESSAGES lines exceed 80 columns, it sometimes makes sense to truncate the message to make it fit the column limit.

51

s/miss match/mismatch/

Also, I'm not an English native speaker, but I believe a comma should be used before because in this sentence.

[congliu]

clang-tidy/misc/VirtualNearMissCheck.cpp

79

The condition is necessary, for the same reason I explained in the comment for line 85.

85

This is to deal with an special case of C++ override. Usually the return type of the override and overriden should be the same. The exception is that the return type ban be a reference (or pointer) to the class themselves. For example,

class Base{
  virtual Base* func();
};
class Derived : Base{
  virtual Derived* func();
};

In this case, the Derived::func() does override Base::func(), even though the return type are not the same.
So if the return types are not the same (line 72 assured that), and are not both references (or pointers), we can rule out the possibility of override, and therefore return false.

[alexfh]

clang-tidy/misc/VirtualNearMissCheck.cpp

85

It looks like you're talking about the concept of covariance described in [class.virtual] p7. And you seem to be getting it wrong: the return type doesn't need to be a pointer/reference to the class defining the method. Here's the relevant quote from the standard:

The return type of an overriding function shall be either identical to the return type of the overridden
function or covariant with the classes of the functions. If a function D::f overrides a function B::f, the
return types of the functions are covariant if they satisfy the following criteria:
— both are pointers to classes, both are lvalue references to classes, or both are rvalue references to
classes115
— the class in the return type of B::f is the same class as the class in the return type of D::f, or is an
unambiguous and accessible direct or indirect base class of the class in the return type of D::f
— both pointers or references have the same cv-qualification and the class type in the return type of D::f
has the same cv-qualification as or less cv-qualification than the class type in the return type of B::f.

Please change your code to implement this concept correctly.

[congliu]

clang-tidy/misc/VirtualNearMissCheck.cpp

59

I tried some cases, but haven't found an example for that case.
I saw the same code in AST_MATCHER(CXXMethodDecl, isOverride).
I'm not sure why there is a "hasAttr".

[alexfh]

Looks like you've forgotten to upload a new patch.

[congliu]

• Corrected naming styles; Used clang-format; Add doc to .h
• Removed useless parentheses, braces around one-line ifs.
• Added doc; Corrected style and typos for test.
• Implemented c++ [class.virtual]p7. But has bug.
• Support ambiguity checking.
• Completed virtual covarient check. Updated test.

[alexfh]

clang-tidy/misc/VirtualNearMissCheck.cpp

72

Please use const auto * to avoid repeating the type name.

218

This should be moved to the registerMatchers method: the matcher shouldn't be registered, if you don't intend to handle matches.

226

Please remove this check. Clang-tidy handles filtering of warnings by source location itself. Sometimes, developers of the standard library, for example, also want to run clang-tidy on it.

233

1. When is this going to be nullptr?
2. Why do you return here instead of continuing to check other base classes?

243

Doesn't seem like these variables make the code much shorter or easier to read.

249

The message doesn't explain what's wrong with the code, which makes it difficult for the user to understand the issue. Maybe something like this:
"method 'aab' has the same signature as a virtual method 'aaa' of the base class 'X' and a similar name; did you intend to override 'aaa'?"?

clang-tidy/misc/VirtualNearMissCheck.h

22

Thanks for adding the description. However, the "near miss" words don't explain the main thing: the check looks for virtual methods with a very similar name and an identical signature defined in a base class. Please mention this in the description.

You can also leave the example in the user-facing documentation only. BTW, please add back the link to it.

40

You can use Doxygen tags in the documentation comments, e.g.:

/// Finds out if the method overrides some other method.
///
/// \returns \c true if the given method overrides some other method.

Please read http://llvm.org/docs/CodingStandards.html#doxygen-use-in-documentation-comments

61

nit: typo: s/CheckOveridingFunctionReturnType/CheckOverridingFunctionReturnType/

62

What does the function return? Also, can we maybe pull out common functionality to avoid code duplication?

74

Please add an empty line after the first line (the first line serves as a brief description and the rest is a body of the documentation).

80

nit: typo to ve.

86

nit: s/OverridenMap/OverriddenMap/ (note the double 'd')

88

I'd call this EditDistanceThreshold to avoid questions on what does the threshold apply to.

docs/clang-tidy/checks/misc-virtual-near-miss.rst

5

Please mention that function signatures need to match in order for this check to fire.

test/clang-tidy/misc-virtual-near-miss.cpp

42

Is private inheritance intended here?

49

"because param type mismatch" is not grammatically correct. Use either "because of parameter type mismatch" or "because parameter types don't match". Same applies to "because return type missmatch" and "because access missmatch" below.

51

"const type mismatch" is not a clear description. Maybe "Shouldn't warn: method is not const."

53

Not actually done. There are still four "missmatch" occurrences in this file.

65

nit: Please insert a space after //.

[alexfh]

A few more comments.

clang-tidy/misc/VirtualNearMissCheck.cpp

23

This should be a free-standing function.

49

IIUC, this can be a free-standing function instead of a method, since it doesn't use any class members.

111

nit: typo: s/IsIteself/IsItself/

113

Why not a range-for loop?

119

Please propagate the negation inside parentheses: !HasPublicAccess && !IsItself.

130

nit: Please add a trailing period.

137

This should be checkParamTypes, note the plural form.

137

This can be a free-standing function, since it doesn't use any class members.

139

I'd slightly prefer unsigned over unsigned int.

164

This should be a free-standing function.

165

The variable is not needed here, just return the expression.

170

s/Overriden/Overridden/

176

I'd just return Iter->second; and remove else. Same below in the isOverridenByDerivedClass method.

[congliu]

• Completed [class.virtual] p7 covarient check. Updated test.
• Corrected implement of checkParamType.
• Clean up.
• Corrected typos. Changed some methods to free-standing. Changed warning message. Updated tests.
• Finished correcting cpp. Updated doc.

clang-tidy/misc/VirtualNearMissCheck.cpp

233

1. Just to assure it's not nullptr. If the base specification contains a class type that was not declared anywhere, it would be nullptr. I found similar code here NewDeleteOverloadsCheck.cpp, line 121
2. Sorry, it's a mistake, should be 'continue' not 'return'.

test/clang-tidy/misc-virtual-near-miss.cpp

42

Yes, it's intended. This is for the case in line 57: although Father is a private base class of Child, since that function itself is in Child class, the conversion is accessible.

[alexfh]

A few minor comments.

clang-tidy/misc/VirtualNearMissCheck.cpp

24

Please mark this and other functions static to make them local to the translation unit.

44

nit: Missing trailing period.

69

nit: No braces around one-line if bodies, please.

91

I wonder whether BTy.getCanonicalType().getUnqualifiedType() will work here.

100

nit: No braces around one-line if bodies, please.

189

nit: No braces around one-line if bodies, please.

204

nit: No braces around one-line if bodies, please.

259

The diagnostic messages are not complete sentences. Please use a semicolon instead of the period and a lower-case letter after it. Also, s/signature with/signature as/ and s/meant/mean/. Overall it should be:
method '%0' has a similar name and the same signature as method '%1'; did you mean to override it?.

test/clang-tidy/misc-virtual-near-miss.cpp

16

Please remove the . Did you mean to override it? part from all CHECK lines except for the first one to make the test file easier to read. Maybe even cut the static test in the middle:

// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'Derived::func2' has {{.*}} 'Base::func'

43

Please mark the inheritance explicitly private then to avoid questions.

[congliu]

This comment was removed by congliu.

clang-tidy/misc/VirtualNearMissCheck.cpp

91

I'm afraid they're different. CXXBasePaths.isAmbiguous receives a CanQualType parameter, while BTy.getCanonicalType().getUnqualifiedType() returns a QualType object.

[congliu]

• Removed braces; corrected comments; updated test.

[alexfh]

Looks good with one nit. I'll update the comment myself and commit the patch for you.

Thank you for the contribution!

clang-tidy/misc/VirtualNearMissCheck.cpp

61

Answering my own question: I guess, it may be useful for methods of template classes and for template methods, where the template declaration doesn't make it clear whether the method is overridden or not. However the author may want the compiler to ensure the instantiation actually overrides something.

clang-tidy/misc/VirtualNearMissCheck.h

40

nit: It should look up ... sounds like a requirement, however, you exactly know what the implementation does, so It looks up ... or updates ... is better. Maybe even Results are memoized in PossibleMap.

Same below.

clang-tidy/misc/CMakeLists.txt

add_clang_library(clangTidyMiscModule
   StringIntegerAssignmentCheck.cpp
   SwappedArgumentsCheck.cpp
   ThrowByValueCatchByReferenceCheck.cpp
   UndelegatedConstructor.cpp
   UnusedAliasDeclsCheck.cpp
   UnusedParametersCheck.cpp
   UnusedRAIICheck.cpp
   UniqueptrResetReleaseCheck.cpp
+  VirtualNearMissCheck.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTidyUtils
   )

clang-tidy/misc/MiscTidyModule.cpp

 #include "StringIntegerAssignmentCheck.h"
 #include "SwappedArgumentsCheck.h"
 #include "ThrowByValueCatchByReferenceCheck.h"
 #include "UndelegatedConstructor.h"
 #include "UniqueptrResetReleaseCheck.h"
 #include "UnusedAliasDeclsCheck.h"
 #include "UnusedParametersCheck.h"
 #include "UnusedRAIICheck.h"
+#include "VirtualNearMissCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 class MiscModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<UndelegatedConstructorCheck>(
         "misc-undelegated-constructor");
     CheckFactories.registerCheck<UniqueptrResetReleaseCheck>(
         "misc-uniqueptr-reset-release");
     CheckFactories.registerCheck<UnusedAliasDeclsCheck>(
         "misc-unused-alias-decls");
     CheckFactories.registerCheck<UnusedParametersCheck>(
         "misc-unused-parameters");
     CheckFactories.registerCheck<UnusedRAIICheck>("misc-unused-raii");
+    CheckFactories.registerCheck<VirtualNearMissCheck>(
+        "misc-virtual-near-miss");
   }
 };
 
 } // namespace misc
 
 // Register the MiscTidyModule using this statically initialized variable.
 static ClangTidyModuleRegistry::Add<misc::MiscModule>
 X("misc-module", "Adds miscellaneous lint checks.");
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the MiscModule.
 volatile int MiscModuleAnchorSource = 0;
 
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/VirtualNearMissCheck.h

+//===--- VirtualNearMissCheck.h - clang-tidy---------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_VIRTUAL_NEAR_MISS_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_VIRTUAL_NEAR_MISS_H
+
+#include "../ClangTidy.h"
+#include <map>
+#include <string>
+
+namespace clang {
+namespace tidy {
+namespace misc {
+
+/// FIXME: Write a short description.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/misc-virtual-near-miss.html
+class VirtualNearMissCheck : public ClangTidyCheck {
+public:
+  VirtualNearMissCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+  static int editDistance(const std::string &SourceStr, const std::string &TargetStr);
+private:
+  /// Return true if the given method overrides some method.
+  bool isOverrideMethod(const CXXMethodDecl *DerivedMD);
+
+  /// Return true if the given method is possible to be overriden by some other
+  /// method.
+  //It should look up the possible_map or update it.
+  bool isPossibleToBeOverriden(const CXXMethodDecl *BaseMD);
+
+  /// Return true if the given base method is overriden by some methods in the
+  /// given derived class.
+  /// It should look up the overriden_map or update it.
+  bool isOverriden(const CXXMethodDecl *BaseMD, const CXXRecordDecl *DerivedRD);
+
+  /// Return true if the two methods are the same (in type and qualifier) except for the name.
+  bool equalWithoutName(const CXXMethodDecl *BaseMD, const CXXMethodDecl *DerivedMD);
+
+  /// Return true if the method A overrides method B.
+  bool compareOverride(const CXXMethodDecl *BaseMD, const CXXMethodDecl *DerivedMD);
+
+  /// Generate unique ID for given MethodDecl.
+  /// The ID is used as key for 'possible_map'.
+  /// e.g. Base::func void (void)
+  std::string generateMethodID(const CXXMethodDecl *MD);
+
+  /// key: the unique ID of a method;
+  /// value: whether the method is possible to ve overriden.
+  std::map<std::string, bool> possible_map_;
+
+  /// key: <unique ID of base method, name of derived class>
+  /// value: whether the base method is overriden by some method in the derived
+  /// class.
+  std::map<std::pair<std::string, std::string>, bool> overriden_map_;
+
+  const int kNearMissThreshold = 1;
+};
+
+} // namespace misc
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_VIRTUAL_NEAR_MISS_H
+

clang-tidy/misc/VirtualNearMissCheck.cpp

+//===--- VirtualNearMissCheck.cpp - clang-tidy-----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "VirtualNearMissCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace misc {
+
+int VirtualNearMissCheck::editDistance(const std::string &SourceStr,
+                                        const std::string &TargeStr){
+  int len_source = SourceStr.size();
+  int len_target = TargeStr.size();
+  if (len_source == 0) {
+    return len_target;
+  }
+  if (len_target == 0) {
+    return len_source;
+  }
+
+  std::vector<std::vector<int>> f(len_source + 1,
+                                  std::vector<int>(len_target + 1));
+  int i, j;
+  for (i = 1; i <= len_source; i ++){
+    f[i][0] = i;
+  }
+  for (j = 1; j <= len_target; j ++){
+    f[0][j] = j;
+  }
+
+  for (i = 1; i <= len_source; i ++){
+    for (j = 1; j <= len_target; j ++){
+      int del = f[i - 1][j] + 1; // delete char SourceStr[i]
+      int ins = f[i][j - 1] + 1; // insert char TargeStr[j]
+      int rep = f[i - 1][j - 1]; // replace SourceStr[i] and TargeStr[j]
+      if (SourceStr[i - 1] != TargeStr[j - 1]){
+        rep++;
+      }
+      int min_dist = del < ins ? del : ins;
+      min_dist = rep < min_dist ? rep : min_dist;
+      f[i][j] = min_dist;
+    }
+  }
+  return f[len_source][len_target];
+}
+
+bool VirtualNearMissCheck::isOverrideMethod(const CXXMethodDecl *MD){
+  return MD->size_overridden_methods() > 0 || MD->hasAttr<OverrideAttr>();
+}
+
+bool VirtualNearMissCheck::equalWithoutName(const CXXMethodDecl *BaseMD, const CXXMethodDecl *DerivedMD){
+  if (BaseMD->getTypeQualifiers() != DerivedMD->getTypeQualifiers())
+    return false;
+
+  if (BaseMD->isStatic() != DerivedMD->isStatic())
+    return false;
+
+  if (BaseMD->getAccess() != DerivedMD->getAccess())
+    return false;
+
+  if (BaseMD->getType()  == DerivedMD->getType())
+    return true;
+
+  // One exception for return type &Base and &Derived (or *Base and *Derived)
+  QualType BaseReturnType = BaseMD->getReturnType();
+  QualType DerivedReturnType = DerivedMD->getReturnType();
+  if (BaseReturnType->isReferenceType() && DerivedReturnType->isReferenceType()){
+    BaseReturnType = BaseReturnType.getNonReferenceType();
+    DerivedReturnType = DerivedReturnType.getNonReferenceType();
+  } else if (BaseReturnType->isPointerType() && DerivedReturnType->isPointerType()){
+    BaseReturnType = BaseReturnType->getPointeeType();
+    DerivedReturnType = DerivedReturnType->getPointeeType();
+  }else {
+    return false;
+  }
+  if (BaseReturnType->getAsCXXRecordDecl() != BaseMD->getParent() ||
+      DerivedReturnType->getAsCXXRecordDecl() != DerivedMD->getParent()){
+    return false;
+  }
+
+  int a_num_param = BaseMD->getNumParams();
+  int b_num_param = DerivedMD->getNumParams();
+  if (a_num_param != b_num_param) {
+    return false;
+  }
+  for (int i = 0; i < a_num_param; i++){
+    if (BaseMD->getParamDecl(i)->getType() != DerivedMD->getParamDecl(i)->getType()){
+      return false;
+    }
+  }
+  return true;
+}
+
+bool VirtualNearMissCheck::compareOverride(const CXXMethodDecl *BaseMD, const CXXMethodDecl *DerivedMD){
+  if (!equalWithoutName(BaseMD, DerivedMD)){
+    return false;
+  }
+  if (BaseMD->getNameAsString() != DerivedMD->getNameAsString()){
+    return false;
+  }
+  return true;
+}
+
+std::string VirtualNearMissCheck::generateMethodID(const CXXMethodDecl *MD){
+  std::string Id = MD->getQualifiedNameAsString()
+      + " "
+      + MD->getType().getAsString();
+  return Id;
+}
+
+bool VirtualNearMissCheck::isPossibleToBeOverriden(const CXXMethodDecl *BaseMD){
+  std::string id = generateMethodID(BaseMD);
+  auto it = possible_map_.find(id);
+  bool is_possible;
+  if (it != possible_map_.end()){
+    is_possible = it->second;
+  } else{
+    is_possible = !(BaseMD->isImplicit())
+        && !(dyn_cast<CXXConstructorDecl>(BaseMD))
+        && BaseMD->isVirtual();
+    possible_map_[id] = is_possible;
+  }
+  return is_possible;
+}
+
+bool VirtualNearMissCheck::isOverriden(const CXXMethodDecl *BaseMD,
+                                 const CXXRecordDecl *DerivedRD){
+  auto key = std::make_pair(generateMethodID(BaseMD), DerivedRD->getQualifiedNameAsString());
+  auto it = overriden_map_.find(key);
+  bool is_overriden;
+  if (it != overriden_map_.end()){
+    is_overriden = it->second;
+  } else{
+    is_overriden = false;
+    for (const CXXMethodDecl *DerivedMD : DerivedRD->methods()){
+      if(!isOverrideMethod(DerivedMD)){
+        continue;
+      }
+
+      if (compareOverride(BaseMD, DerivedMD)){
+        is_overriden = true;
+        break;
+      }
+    }
+    overriden_map_[key] = is_overriden;
+  }
+  return is_overriden;
+}
+
+void VirtualNearMissCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(
+          cxxMethodDecl(
+              unless(anyOf(isOverride(), isImplicit(),cxxConstructorDecl())))
+          .bind("method"),
+          this);
+}
+
+void VirtualNearMissCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *DerivedMD = Result.Nodes.getNodeAs<CXXMethodDecl>("method");
+  assert(DerivedMD != nullptr);
+
+  if (Result.SourceManager->isInSystemHeader(DerivedMD->getLocation())){
+    return;
+  }
+
+  const auto *DerivedRD = DerivedMD->getParent();
+  for (const auto &BasesSpec : DerivedRD->bases()){
+    const auto *BaseRD = BasesSpec.getType()->getAsCXXRecordDecl();
+    if(BaseRD == nullptr){
+      return;
+    }
+
+    for (const auto *BaseMD : BaseRD->methods()){
+      if (!isPossibleToBeOverriden(BaseMD)){
+        continue;
+      }
+
+      if (isOverriden(BaseMD, DerivedRD)){
+        continue;
+      }
+
+      if (equalWithoutName(BaseMD, DerivedMD)){
+        const std::string &BaseMDName = BaseMD->getNameAsString();
+        const std::string &DerivedMDName = DerivedMD->getNameAsString();
+        if (editDistance(BaseMDName, DerivedMDName) <= kNearMissThreshold){
+          // virtual-near-miss found
+          diag(DerivedMD->getLocStart(), "do you want to override '%0'?")
+              << BaseMD->getName();
+          // Auto fix could be risky
+          // const auto Fixup = FixItHint::CreateReplacement(DerivedMD->getNameInfo().getSourceRange(), BaseMDName);
+        }
+      }
+    }
+  }
+}
+
+} // namespace misc
+} // namespace tidy
+} // namespace clang

docs/clang-tidy/checks/list.rst

.. toctree::
    misc-string-integer-assignment
    misc-swapped-arguments
    misc-throw-by-value-catch-by-reference
    misc-undelegated-constructor
    misc-uniqueptr-reset-release
    misc-unused-alias-decls
    misc-unused-parameters
    misc-unused-raii
+   misc-virtual-near-miss
    modernize-loop-convert
    modernize-make-unique
    modernize-pass-by-value
    modernize-replace-auto-ptr
    modernize-shrink-to-fit
    modernize-use-auto
    modernize-use-default
    modernize-use-nullptr

docs/clang-tidy/checks/misc-virtual-near-miss.rst

+misc-virtual-near-miss
+======================
+
+FIXME: Describe what patterns does the check detect and why. Give examples.

test/clang-tidy/misc-virtual-near-miss.cpp

+// RUN: %check_clang_tidy %s misc-virtual-near-miss %t
+
+struct Base{
+  virtual void func();
+  virtual void gunk();
+};
+
+struct Derived:Base{
+  // Should warn
+  // Should not warn "do you want to override 'gunk'?", becuase gunk is already
+  // overriden by this class
+  virtual void funk();
+// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do you want to override 'func'? [misc-virtual-near-miss]
+
+  // Should warn
+  void func2();
+// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do you want to override 'func'? [misc-virtual-near-miss]
+
+  void func22(); // Should not warn
+
+  void gunk(); // Should not warn because gunk is override
+
+  // Should warn
+  void fun();
+// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do you want to override 'func'? [misc-virtual-near-miss]
+};
+
+class Father{
+ public:
+  Father();
+  virtual void func();
+  virtual Father* create(int i);
+};
+
+class Mother{
+ public:
+  Mother();
+  static void method();
+  virtual int method(int argc, const char** argv);
+  virtual int method(int argc) const;
+};
+
+class Child : Father, Mother{
+ public:
+  Child();
+
+  // Should warn
+  virtual void func2();
+// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do you want to override 'func'? [misc-virtual-near-miss]
+
+  int methoe(int x, char** strs); // Should not warn because param type miss match
+
+  int methoe(int x); // Should not warn because const type miss match
+
+  void methof(int x, const char** strs); // Should not warn because return type miss match
+
+  // Should warn
+  int methoh(int x, const char** strs);
+// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do you want to override 'method'? [misc-virtual-near-miss]
+
+  // Should warn
+  virtual Child* creat(int i);
+// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do you want to override 'create'? [misc-virtual-near-miss]
+
+ private:
+  void funk(); //Should not warn because access miss match
+};