[clang-tidy] Implement type-based check for `gsl::owner`

[JonasToth]

Summary

This check implements the typebased semantic of gsl::owner.
Meaning, that

• only gsl::owner is allowed to get deleted
• new expression must be assigned to gsl::owner
• function calls that expect gsl::owner as argument, must get either an owner or a newly created and recognized resource (in the moment only newed memory)
• assignment to gsl::owner must be either a resource or another owner
• functions returning an gsl::owner are considered as factories, and their result must be assigned to an gsl::owner
• classes that have an gsl::owner-member must declare a non-default destructor

There are some problems that occur when typededuction is in place.
For example auto Var = function_that_returns_owner(); the type of Var will not be
an gsl::owner. This case is catched, and explicitly noted.

But cases like fully templated functions

template <typename T> 
void f(T t) { delete t; }
// ...
f(gsl::owner<int*>(new int(42)));

Will created false positive (the deletion is problematic), since the type deduction
removes the wrapping typeAlias.

Please give your comments :)

[JonasToth]

• [Misc] remove not implemented c function stuff

[JonasToth]

Running this check on clang with llvm/tools/clang$ run-clang-tidy.py -j8 -checks=-*,cppcoreguidelines-owning-memory * 2>&1 1>~/OwnerClangOutput.txt

OwnerClangOutput.txt50 KBDownload

The result is cropped, since it get repetetive.

[JonasToth]

• I broke the diff, try to restore

[JonasToth]

• [Fix] codeblocks in documentation needed empty line

[Eugene.Zelenko]

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

15

Please remove this line.

docs/ReleaseNotes.rst

60 ↗

(On Diff #109868)

Please use previous version Release Notes as example for adding new check.

docs/clang-tidy/checks/cppcoreguidelines-owning-memory.rst

6 ↗

(On Diff #109868)

Please use `` for language constructs. Same in other places.

[JonasToth]

• [Fix] review issues by eugene solved

[JonasToth]

mark as done by eugene

[JonasToth]

• [Misc] fix new line in Release Note

[aaron.ballman]

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

29

Can elide the braces.

32

Variable names should start with an uppercase letter (here and elsewhere).

39

Can remove the comma and add a hyphen to non-owners.

55

non-owners

75

Can remove the first comma.

83

Can remove the first comma.

93

Can remove the first comma.

101

Can remove the first comma.

108

Can remove the first comma.

117

Can remove the first comma.

128

Please split this function up into smaller functions that check only the individual components.

clang-tidy/cppcoreguidelines/OwningMemoryCheck.h

19 ↗

(On Diff #109875)

usecases -> use cases

[JonasToth]

[Misc] address issues from aaron, especially refactor the big check function

[JonasToth]

[Fix] typo

[JonasToth]

[Misc] remove unneccessary stuff

[aaron.ballman]

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

149

Can DeletedVariable ever be null if DeleteStmt is non-null? I don't think it can, so perhaps the best approach is to gate on DeleteStmt and remove the assert.

153

"use RAII" is not particularly helpful. I think this means you should use a smart pointer, no? If so, I'd recommend: "deleting a pointer through a type that is not marked 'gsl::owner'; consider using a smart pointer instead" or something along those lines.

154–155

Can call DeletedVariable->getSourceRange() instead (same applies elsewhere).

157

No else after a return (same applies elsewhere).

168

I'm having a bit of a hard time understanding the guidance in this warning. How about: "argument is expected to be of type 'gsl::owner<>'; got %0" and pass in the type of the argument?

I think something needs to be done to better-define "recognized resource" before it's used as a term of art in the diagnostics; this applies elsewhere as well.

188

Same comments here as above about "owner" and "recognized resource". I think you want to talk about gsl::owner<> where you use "owner" and drop "recognized resource" (because such a resource returns a gsl::owner<>-flagged type, if I understand properly).

[JonasToth]

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

149

I think that both will be matched simultaneously, but i was unsure, therefor i programmed it defensive.
I can change it if you want.

153

in this case RAII means smartpointers, but in general gsl::owner could be file handles, sockets and whatever else.

i will adjust the warning to mention smartpointers.

168

I used the term 'recognized resource' since FILE* would be a resource as well, but the there is no way the C standard function could return an gsl::owner<>.

I plan to enhance this check, to allow of lists of C/C++ functions that are known to create a resource, but can not be changed.
The effect would be like in the case of new - whenever such a function is called, the result must be assigned to an gsl::owner.
Furthermore the CppCoreGuidelines usually talk about 'resources', so the wording is somewhat similar.

same applies to next comment

[JonasToth]

• order release notes
• address aarons comments
• adjust diagnostic for function arguments

[JonasToth]

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

188

ideally every created resource would be flagged as gsl::owner<>, but for example fopen, malloc and friends can't, but would benefit the most from such a check (+ flow analysis if the owner gets consumed on every path)

[JonasToth]

remove manual source range creation, where i forgot it before

[aaron.ballman]

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

167

You can pass the QualType directly instead of calling getAsString() on it.

184

No need to check against nullptr explicitly (here and elsewhere).

188

The use case certainly makes sense, but that doesn't make the diagnostic any more clear to the user. Perhaps: "expected assignment source to be of type 'gsl::owner<>'; got %0"? It's not perfect because it doesn't mention "recognized resource", but that can be improved in the follow-up patch that defines those resources.

The wording should be similar for the below cases as well.

191

No else after a return. Same applies elsewhere.

[aaron.ballman]

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

208

It's hard to understand how this differs from handleAssignmentAndInit(); might need a more descriptive name.

230

Are you intending to address this in this patch?

Also, it should probably be "FIXME: " (with the colon).

[JonasToth]

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

230

no not in this patch directly, but i plan a follow up after getting this one done.

[JonasToth]

address review comments from aaron

[aaron.ballman]

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

191

Please remove the use of CheckApplied. The early returns were fine, it's the complex if/else logic that should be modified. e.g.,

if (OwnerAssignment) {
  <stuff>
  return true;
}

if (OwnerInitialization) {
  <stuff>
  return true;
}
...
return false;

[JonasToth]

This comment was removed by JonasToth.

[JonasToth]

• test case fixed expected warning
• address review comments from aaron

[JonasToth]

• adjust the diagnostics to include the types

[JonasToth]

i think the diagnostics are better now, i added the expected and received type everywhere i could.

[JonasToth]

remove unnecessary outcommented lines

[aaron.ballman]

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

202

Can remove the comma.

239

s/non owner/non-owner

256

s/non owner/non-owner

292

s/an declared/a declared

Also, you should either add punctuation or remove the capital M in Match.

294

Instead of diagnosing this on the class, why not diagnose the individual offending members (and then you don't need a note, either)? (Note, that may change the suggested diagnostic wording below).

295

This diagnostic isn't grammatically correct; how about: class with a member variable of type 'gsl::owner<>' but no destructor to release the owned resource?

[JonasToth]

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

294

yes, this is probably better.
i plan to add deeper analysis, that gsl::owner<> will always be released or moved.
That would check, if destructors do this correctly, so offending the member is the better way.

[JonasToth]

• fix spelling and grammar errors
• adjust unit test to new diagnostics

[JonasToth]

addressed some issues, not all yet

[JonasToth]

• adjusted the diagnostic for member variables

[JonasToth]

docs/clang-tidy/checks/cppcoreguidelines-owning-memory.rst

11 ↗

(On Diff #113265)

s/an/a/

17 ↗

(On Diff #113265)

s/it/It/

27 ↗

(On Diff #113265)

s/caught/checked/

97 ↗

(On Diff #113265)

s/an/a/

131 ↗

(On Diff #113265)

therefore ... therefore

docs/clang-tidy/checks/hicpp-signed-bitwise.rst

1 ↗

(On Diff #113265)

remove from diff

docs/clang-tidy/checks/list.rst

70

remove from diff

test/clang-tidy/hicpp-signed-bitwise.cpp

1 ↗

(On Diff #113265)

remove from diff

[JonasToth]

• fix typos and bad language

[JonasToth]

language in the docuementation improved

[JonasToth]

ping

[aaron.ballman]

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

140

Can assert CheckExecuted and drop the explicit equality test.

141

did execute, -> executed;

206

initializing -> intialization

303–305

Please remove the commented-out lines.

test/clang-tidy/cppcoreguidelines-owning-memory.cpp

39

This diagnostic confuses me -- there's no gsl::owner<> involved anywhere; am I missing something?

[JonasToth]

test/clang-tidy/cppcoreguidelines-owning-memory.cpp

39

owner<> is not involved, but the guidelines say, that new must be assigned to an owner.

This is in line with the resource semantics. Everything that creates an resource, that must be released (no RAII available) shall be annotated.

The diagnostic is bad, though.

Returning a newly created resource from function 'functionname', without declaring it as 'gsl::owner<>'; type is '...'

[aaron.ballman]

test/clang-tidy/cppcoreguidelines-owning-memory.cpp

39

Okay, that makes more sense to me. I don't think the name of the function helps all that much in the diagnostic, however. What about:

"returning a newly created resource of type %0 from a function whose return type is not 'gsl::owner<>'"

[JonasToth]

• Merge branch 'master'
• mention current problems with typedefs of owner<> and adjust test cases

[JonasToth]

• Adressed some review comments.
• Added testcases, where the owner<> annotation might be hidden by a typedef or using, like int using heap_int = gsl::owner<int*>;

The check is currently not able to resolve a typedef to owner<> correctly, and my knowledge in clang is to limited to find exact reason and/or a workaround.
I tried to match the type with hasCanonicalType, but i guess that will remove the owner<> alias and therefore be not an option.
The basic testcase for typedef should stay in the code with the FIXME, since there is probably a way around.

I am thinking of a matcher like IsTypedefToOwner, that looks through one typedef after another recursively until it finds an owner<>, but later and probably with a different solution.

The typedef issue is in the following lines, just as shortcut since the patch is quite big:
testcase: 200-225

The issue is mentioned in the docs as well.

test/clang-tidy/cppcoreguidelines-owning-memory.cpp

39

There is a minor issue with the diagnostic in general, since it is emitted for values of type gsl::owner<> and values that are known to be an owner like new int(42).

There is no easy way to distinguish between a recognized resource or an annotated resource, without complicating the matchers (what i dont want, since there is already a lot happening).

Mixing both cases in the diagnostic would help, but go in the direction of recognized resource, that was decided against earlier.

Would the following modification be acceptable as well?
returning a newly created resource of type %0 or value of type 'gsl::owner<>' from a function whose return type is not 'gsl::owner<>'
or
returning a newly created resource of type %0 or value of type 'gsl::owner<>' without annotating the return type of the function as 'gsl::owner<>'.

This general problem holds true for other cases, since i want to match for IsConsideredOwner, which wraps cases like new, functions returning owner<> and variables of type owner<>.
I want to expand this further to functions that should return owner<> but can't, like malloc.
Splitting up the matchers instead of using IsConsideredOwner would be a burden including a lot of code duplication.

[aaron.ballman]

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

141

Non -> None

294

Missing a full stop at the end of the sentence.

test/clang-tidy/cppcoreguidelines-owning-memory.cpp

39

Would the following modification be acceptable as well?
returning a newly created resource of type %0 or value of type 'gsl::owner<>' from a function whose return type is not 'gsl::owner<>'

I would rephrase slightly to:

returning a newly created resource of type %0 or 'gsl::owner<>' from a function whose return type is not 'gsl::owner<>'

[JonasToth]

• address review comments, especially improve diagnostic for return types, that should be owner but arent

[aaron.ballman]

LGTM, with a few last typos.

test/clang-tidy/cppcoreguidelines-owning-memory.cpp

354

typededuction -> type deduction

(here and elsewhere)

372

harmfull -> harmful

374

nonowner -> non-owner

(here and elsewhere)

[JonasToth]

• fix typos

[JonasToth]

• fix, that deleted destructors are caught as problem as well
• clarify one comment, duplicated avoid was misleading

[aaron.ballman]

Good catch on the deleted constructor -- LGTM still!

[JonasToth]

commited in rL313043

[JonasToth]

This Patch broke the buildbot for vs-2015.
I will revert, when i figured out how to do this in svn :/

It does not emit a warning for line 311:
here the log

C:\b\slave\clang-x86-windows-msvc2015\clang-x86-windows-msvc2015\stage1\tools\clang\tools\extra\test\clang-tidy\Output\cppcoreguidelines-owning-memory.cpp.tmp.cpp:290:3: note: type deduction did not result in an owner
C:\b\slave\clang-x86-windows-msvc2015\clang-x86-windows-msvc2015\stage1\tools\clang\tools\extra\test\clang-tidy\Output\cppcoreguidelines-owning-memory.cpp.tmp.cpp:297:3: warning: expected assignment source to be of type 'gsl::owner<>'; got 'ArbitraryClass *' [cppcoreguidelines-owning-memory]
Owner3 = &A; // Bad, since assignment of non-owner to owner
^
C:\b\slave\clang-x86-windows-msvc2015\clang-x86-windows-msvc2015\stage1\tools\clang\tools\extra\test\clang-tidy\Output\cppcoreguidelines-owning-memory.cpp.tmp.cpp:343:3: warning: expected initialization with value of type 'gsl::owner<>'; got 'int *' [cppcoreguidelines-owning-memory]

gsl::owner<int *> OwningPtr = Array1.data(); // Bad, since it does not return the owner

I have no idea how to debug this, since i dont have a visual studio installation, neither do i have windows. What could it be?

[JonasToth]

• make matcher for ctor initialization more readable

[JonasToth]

Recommited with fix in rL313067

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

 //===--- OwningMemoryCheck.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 "OwningMemoryCheck.h"
 #include "../utils/Matchers.h"
 #include "../utils/OptionsUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 #include <iostream>
 #include <string>
 #include <vector>
 
 using namespace clang::ast_matchers;
 using namespace clang::ast_matchers::internal;
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
-#if 0
-// FIXME Copied from NoMallocCheck!!
-namespace {
-Matcher<FunctionDecl> hasAnyListedName(const std::string &FunctionNames) {
-  const std::vector<std::string> NameList =
-      utils::options::parseStringList(FunctionNames);
-  return hasAnyName(std::vector<StringRef>(NameList.begin(), NameList.end()));
-}
-} // namespace
-#endif
-
 /// Match common cases, where the owner semantic is relevant, like function
 /// calls, delete expressions and others.
 void OwningMemoryCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus11) {
     return;
   }
   const auto ownerDecl = typeAliasTemplateDecl(hasName("::gsl::owner"));
   const auto isOwnerType = hasType(ownerDecl);
   const auto createsOwner =
       anyOf(cxxNewExpr(), callExpr(callee(functionDecl(
                               returns(qualType(hasDeclaration(ownerDecl)))))));
-  // FIXME Integrate custom C functions, which return values must be assigned to
-  // owners.
-#if 0
-  const auto legacyOwnerFunctions =
-      hasDescendant(callExpr(callee(functionDecl(hasAnyListedName(
-          "::malloc,::calloc,::align_malloc,::realloc,::align_realloc")))));
-#endif
-  const auto consideredOwner =
-      anyOf(isOwnerType, createsOwner /*, legacyOwnerFunctions*/);
+  const auto consideredOwner = anyOf(isOwnerType, createsOwner);
 
   // Find delete expressions, that delete non owners.
   Finder->addMatcher(
       cxxDeleteExpr(
           hasDescendant(
               declRefExpr(unless(consideredOwner)).bind("deleted_variable")))
           .bind("delete_expr"),
       this);
 
   // Matching assignment to owners, with the rhs not being an owner nor creating
   // one.
   Finder->addMatcher(binaryOperator(allOf(matchers::isAssignmentOperator(),
                                           hasLHS(isOwnerType),
                                           hasRHS(unless(consideredOwner))))
                          .bind("owner_assignment"),
                      this);
 
   // Matching initialization of owners with non owners, nor creating owners.
   Finder->addMatcher(
       namedDecl(
           varDecl(allOf(hasInitializer(unless(consideredOwner)), isOwnerType))
               .bind("owner_initialization")),
       this);
 
   // Match class member initialization that expects owners, but does not get
   // them.
   Finder->addMatcher(
       cxxRecordDecl(has(cxxConstructorDecl(forEachConstructorInitializer(
           cxxCtorInitializer(
               allOf(
                   isMemberInitializer(), forField(isOwnerType),
                   withInitializer(
                       // Avoid templatesdeclaration with avoiding parenListExpr.
                       allOf(unless(consideredOwner), unless(parenListExpr())))))
               .bind("owner_member_initializer"))))),
       this);
 
   // Matching on assignment operations, where the RHS is a newly created owner,
   // but the LHS is not an owner.
   Finder->addMatcher(
       binaryOperator(allOf(matchers::isAssignmentOperator(),
                            hasLHS(unless(isOwnerType)), hasRHS(createsOwner)))
           .bind("bad_owner_creation_assignment"),
       this);
 
   // Matching on initialization operations, where the initial value is a newly
   // created owner, but the LHS is not an owner.
   Finder->addMatcher(
       namedDecl(varDecl(eachOf(allOf(hasInitializer(createsOwner),
                                      unless(isOwnerType)),
                                allOf(hasInitializer(consideredOwner),
                                      hasType(autoType().bind("deduced_type")))))
                     .bind("bad_owner_creation_variable")),
       this);
 
   // Match on all function calls, that expect owners as arguments, but didn't
   // get them.
   Finder->addMatcher(
       callExpr(forEachArgumentWithParam(
           expr(unless(consideredOwner)).bind("expected_owner_argument"),
           parmVarDecl(isOwnerType))),
       this);
 
   // Matching for function calls, where one argument is a created owner, but the
   // parameter type is not an owner.
   Finder->addMatcher(callExpr(forEachArgumentWithParam(
                          expr(createsOwner).bind("bad_owner_creation_argument"),
                          parmVarDecl(unless(isOwnerType)))),
                      this);
 
   // Matching on functions, that return an owner/resource, but don't declare
   // their return type as owner.
   Finder->addMatcher(
       functionDecl(
           allOf(hasDescendant(returnStmt(hasReturnValue(consideredOwner))
                                   .bind("bad_owner_return")),
                 unless(returns(qualType(hasDeclaration(ownerDecl)))))),
       this);
 
   // Match on classes, that have an owner as member, but don't declare a
   // destructor to properly release the owner.
   Finder->addMatcher(
       cxxRecordDecl(
           allOf(has(fieldDecl(isOwnerType).bind("undestructed_owner_member")),
                 anyOf(unless(has(cxxDestructorDecl())),
                       has(cxxDestructorDecl(isDefaulted())))))
           .bind("non_destructor_class"),
       this);
 }
 
 void OwningMemoryCheck::check(const MatchFinder::MatchResult &Result) {
-  // std::clog << "Hier" << std::endl;
   const auto &Nodes = Result.Nodes;
 
   // Result of delete matchers.
   const auto *DeleteStmt = Nodes.getNodeAs<CXXDeleteExpr>("delete_expr");
   const auto *DeletedVariable =
       Nodes.getNodeAs<DeclRefExpr>("deleted_variable");
 
   // Result of function call matchers.
   const auto *ExpectedOwner = Nodes.getNodeAs<Expr>("expected_owner_argument");
 
   // Assignment and initialization of owner variables.
   const auto *OwnerAssignment =
       Nodes.getNodeAs<BinaryOperator>("owner_assignment");
   const auto *OwnerInitialization =
       Nodes.getNodeAs<VarDecl>("owner_initialization");
   const auto *OwnerInitializer =
       Nodes.getNodeAs<CXXCtorInitializer>("owner_member_initializer");
 
   // Problematic assignment and initializations, since the assigned value is a
   // newly created owner.
   const auto *BadOwnerAssignment =
       Nodes.getNodeAs<BinaryOperator>("bad_owner_creation_assignment");
   const auto *BadOwnerInitialization =
       Nodes.getNodeAs<VarDecl>("bad_owner_creation_variable");
   const auto *BadOwnerArgument =
       Nodes.getNodeAs<Expr>("bad_owner_creation_argument");
 
   // Function return statements, that are owners/resources, but the function
   // declaration does not declare its return value as owner.
   const auto *BadReturnType = Nodes.getNodeAs<ReturnStmt>("bad_owner_return");
 
   // Classes, that have owners as member, but do not declare destructors
   // accordingly.
   const auto *BadClass = Nodes.getNodeAs<CXXRecordDecl>("non_destructor_class");
 
   SourceLocation SourceStart;
   std::string DiagnosticMessage;
   SourceRange Range;
 
   // Deletion of non owners, with `delete variable;`
   if (DeletedVariable != nullptr) {
     assert(DeleteStmt != nullptr &&
            "Both the delete expression and the variable must be not null");
     SourceStart = DeleteStmt->getLocStart();
     DiagnosticMessage = "deleting unowned memory; use RAII or gsl::owner";
     Range = SourceRange(DeletedVariable->getLocStart(),
                         DeletedVariable->getLocEnd());
   }
   // Expected function argument to be owner.
   else if (ExpectedOwner != nullptr) {
     SourceStart = ExpectedOwner->getLocStart();
     DiagnosticMessage =
         "expected this argument to be an owner or a recognized resource";
     Range =
         SourceRange(ExpectedOwner->getLocStart(), ExpectedOwner->getLocEnd());
   }
   // Assignments to owners.
   else if (OwnerAssignment != nullptr) {
     SourceStart = OwnerAssignment->getLocStart();
     DiagnosticMessage = "assigning neither an owner nor a recognized resource";
     Range = SourceRange(OwnerAssignment->getLocStart(),
                         OwnerAssignment->getLocEnd());
   }
   // Initialization of owners.
   else if (OwnerInitialization != nullptr) {
     SourceStart = OwnerInitialization->getLocStart();
     DiagnosticMessage =
         "initializing neither with an owner nor a recognized resource";
     Range = SourceRange(OwnerInitialization->getLocStart(),
                         OwnerInitialization->getLocEnd());
   }
   // Initializer of class constructors, that initialize owners.
   else if (OwnerInitializer != nullptr) {
     SourceStart = OwnerInitializer->getSourceLocation();
     DiagnosticMessage = "initializing owner member variable neither with an "
                         "owner nor a recognized resource";
     Range = OwnerInitializer->getSourceRange();
   }
   // Bad assignments to non owners, where the RHS is a newly created owner.
   else if (BadOwnerAssignment != nullptr) {
     SourceStart = BadOwnerAssignment->getLocStart();
     DiagnosticMessage = "assigning newly created owner/resource to non-owner";
     Range = SourceRange(BadOwnerAssignment->getLocStart(),
                         BadOwnerAssignment->getLocEnd());
   }
   // Bad initialization of non owners, where the RHS is a newly create owner.
   else if (BadOwnerInitialization != nullptr) {
     SourceStart = BadOwnerInitialization->getLocStart();
     DiagnosticMessage =
         "initializing non owner with a newly created owner/resource";
     Range = SourceRange(BadOwnerInitialization->getLocStart(),
                         BadOwnerInitialization->getLocEnd());
     // FIXME FixitHint to rewrite the type if possible
 
     // If the type of the variable was deduced, the wrapping owner typedef is
     // eliminated, therefore the check emits a special note for that case.
     if (Nodes.getNodeAs<AutoType>("deduced_type") != nullptr) {
       diag(BadOwnerInitialization->getLocStart(),
            "type deduction did not result in an owner", DiagnosticIDs::Note);
     }
   }
   // Function call, where one arguments is a newly created owner
   else if (BadOwnerArgument != nullptr) {
     SourceStart = BadOwnerArgument->getLocStart();
     DiagnosticMessage =
         "initializing non owner argument with a newly created owner/resource";
     Range = SourceRange(BadOwnerArgument->getLocStart(),
                         BadOwnerArgument->getLocEnd());
   }
   // Function return values, that should be owners but aren't.
   else if (BadReturnType != nullptr) {
     SourceStart = BadReturnType->getLocStart();
     DiagnosticMessage = "returning an owner/resource from a function but not "
                         "declaring it as one";
     Range =
         SourceRange(BadReturnType->getLocStart(), BadReturnType->getLocEnd());
   }
   // Classes, that contains owners, but do not declare destructors
   else if (BadClass != nullptr) {
     const auto *DeclaredOwnerMember =
         Nodes.getNodeAs<FieldDecl>("undestructed_owner_member");
     assert(DeclaredOwnerMember != nullptr &&
            "Match on class with bad destructor, but without an declared owner");
 
     SourceStart = BadClass->getLocStart();
     DiagnosticMessage = "class with an owner as member but without declared "
                         "destructor to release the owner";
     diag(DeclaredOwnerMember->getLocStart(), "declared owner here",
          DiagnosticIDs::Note);
 
   }
   // Logical error if reaching this point.
   else {
     llvm_unreachable("Unexpected match occured");
   }
 
   diag(SourceStart, DiagnosticMessage) << Range;
 } // namespace cppcoreguidelines
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tidy/modernize/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyModernizeModule
   AvoidBindCheck.cpp
   DeprecatedHeadersCheck.cpp
   LoopConvertCheck.cpp
   LoopConvertUtils.cpp
   MakeSmartPtrCheck.cpp
   MakeSharedCheck.cpp
   MakeUniqueCheck.cpp
   ModernizeTidyModule.cpp
-  NoMallocCheck.cpp
   PassByValueCheck.cpp
   RawStringLiteralCheck.cpp
   RedundantVoidArgCheck.cpp
   ReplaceAutoPtrCheck.cpp
   ReplaceRandomShuffleCheck.cpp
   ReturnBracedInitListCheck.cpp
   ShrinkToFitCheck.cpp
   UnaryStaticAssertCheck.cpp

clang-tidy/modernize/LoopConvertCheck.cpp

void LoopConvertCheck::getAliasRange(SourceManager &SM, SourceRange &Range) {
   if (Invalid)
     return;
   unsigned Offset = std::strspn(TextAfter, " \t\r\n");
   Range =
       SourceRange(Range.getBegin(), Range.getEnd().getLocWithOffset(Offset));
 }
 
 /// \brief Computes the changes needed to convert a given for loop, and
-/// pplies them.
+/// applies them.
 void LoopConvertCheck::doConversion(
     ASTContext *Context, const VarDecl *IndexVar,
     const ValueDecl *MaybeContainer, const UsageResult &Usages,
     const DeclStmt *AliasDecl, bool AliasUseRequired, bool AliasFromForInit,
     const ForStmt *Loop, RangeDescriptor Descriptor) {
   auto Diag = diag(Loop->getForLoc(), "use range-based for loop instead");
 
   std::string VarName;

clang-tidy/modernize/ModernizeTidyModule.cpp

 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "AvoidBindCheck.h"
 #include "DeprecatedHeadersCheck.h"
 #include "LoopConvertCheck.h"
 #include "MakeSharedCheck.h"
 #include "MakeUniqueCheck.h"
-#include "NoMallocCheck.h"
 #include "PassByValueCheck.h"
 #include "RawStringLiteralCheck.h"
 #include "RedundantVoidArgCheck.h"
 #include "ReplaceAutoPtrCheck.h"
 #include "ReplaceRandomShuffleCheck.h"
 #include "ReturnBracedInitListCheck.h"
 #include "ShrinkToFitCheck.h"
 #include "UnaryStaticAssertCheck.h"

 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<AvoidBindCheck>("modernize-avoid-bind");
     CheckFactories.registerCheck<DeprecatedHeadersCheck>(
         "modernize-deprecated-headers");
     CheckFactories.registerCheck<LoopConvertCheck>("modernize-loop-convert");
     CheckFactories.registerCheck<MakeSharedCheck>("modernize-make-shared");
     CheckFactories.registerCheck<MakeUniqueCheck>("modernize-make-unique");
-    CheckFactories.registerCheck<NoMallocCheck>(
-        "modernize-no-malloc");
     CheckFactories.registerCheck<PassByValueCheck>("modernize-pass-by-value");
     CheckFactories.registerCheck<RawStringLiteralCheck>(
         "modernize-raw-string-literal");
     CheckFactories.registerCheck<RedundantVoidArgCheck>(
         "modernize-redundant-void-arg");
     CheckFactories.registerCheck<ReplaceAutoPtrCheck>(
         "modernize-replace-auto-ptr");
     CheckFactories.registerCheck<ReplaceRandomShuffleCheck>(

clang-tidy/modernize/NoMallocCheck.h

-//===--- NoMallocCheck.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_MODERNIZE_NO_MALLOC_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_NO_MALLOC_H
-
-#include "../ClangTidy.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-namespace clang {
-namespace tidy {
-namespace modernize {
-
-/// This checker is concerned with c-style memory management and tries to
-/// sanitize its use.
-/// For CPP, it follows cppcoreguidelines (Resource Management) and for C
-/// it checks for common bugs and tries to clarify the code.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-no-malloc.html ///
-/// github - CPPCoreGuidelines
-class NoMallocCheck : public ClangTidyCheck {
-public:
-  NoMallocCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-
-private:
-  /// implements the cast check, calling malloc check with in
-  void handle_cast(const CStyleCastExpr *MatchedDecl);
-
-  /// implements the malloc check and fixit hints for it
-  bool handle_malloc(const CallExpr *MatchedDecl, bool from_cast = false);
-
-  /// implements the realloc check, suggests using std::vector for this variable
-  void handle_realloc(const CallExpr *MatchedDecl);
-
-  /// implements the free call, suggest RAII
-  void handle_free(const CallExpr *MatchedDecl);
-
-  /// Helper for malloc checking, if binaryOp in malloc, which one is the size
-  /// and which the count
-  bool determine_type_and_count(const BinaryOperator *arg, QualType &type,
-                                bool &lhs_rhs_flag) const;
-
-  /// handle single element and raw bytesize mallocs
-  bool single_or_raw(const CallExpr *malloc_call);
-
-  /// handle malloc call with a multiplication as argument e.g. sizeof int *
-  /// count
-  bool multiplication(const CallExpr *call, const BinaryOperator *arg);
-
-  /// just warn about a suspicious malloc argument
-  void suspicious_binary(const CallExpr *call);
-
-  /// give a hint how to call malloc properly
-  void give_call_hint(const CallExpr *malloc_call);
-
-  /// give notes about alternative ways to create dynamic arrays
-  void give_array_hint(const CallExpr *malloc_call, const std::string &t_hint,
-                       const std::string &count_str);
-
-  /// give deletion hint, when malloc is removed. delete/delete[] must be
-  /// adopted!
-  void give_deletion_hint(const CallExpr *malloc_call);
-};
-
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_NO_MALLOC_H

clang-tidy/modernize/NoMallocCheck.cpp

-//===--- NoMallocCheck.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 "NoMallocCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include <iostream>
-#include <string>
-
-using namespace clang::ast_matchers;
-
-/*
-when calling diag(), supply a SourceRange as the first "argument" after the
-closing parens. e.g., diag(someLoc, "some message %0") << SomeSourceRange <<
-SomeArg;
- the source location corresponds to the ^ caret, the source range corresponds to
-the ~ underlines
-
- how to make better diagnostic
- */
-namespace clang {
-namespace tidy {
-namespace modernize {
-
-/// Register for all function calls, and filter malloc out
-void NoMallocCheck::registerMatchers(MatchFinder *Finder) {
-  // register function calls to malloc
-  // Finder->addMatcher(
-  // callExpr(callee(functionDecl(hasName("::malloc")))).bind("malloc"), this);
-
-  // this matcher finds statements in the form
-  // char* str = (char*) malloc(...);
-  //             ~~~~~~~~~~~~~~~~~~~~
-  Finder->addMatcher(
-      cStyleCastExpr(
-          hasDescendant(callExpr(callee(functionDecl(hasName("::malloc"))))
-                            .bind("malloc")))
-          .bind("c_cast"),
-      this);
-
-  // registers realloc calls, suggest std::vector
-  Finder->addMatcher(
-      callExpr(callee(functionDecl(hasName("::realloc")))).bind("realloc"),
-      this);
-
-  // registers free calls, suggest proper RAII and delete
-  Finder->addMatcher(
-      callExpr(callee(functionDecl(hasName("::free")))).bind("free"), this);
-}
-
-// --------------------
-// Helper Functionality
-// --------------------
-namespace {
-
-/// kinda inspired from here
-/// http://stackoverflow.com/questions/9607852/print-arguments-of-a-function-using-clang-ast
-std::string stmt_to_string(Stmt const *stmt, LangOptions l) {
-  // configuration
-  PrintingPolicy Policy(l);
-
-  // printing
-  std::string stmt_str;
-  llvm::raw_string_ostream s(stmt_str);
-  stmt->printPretty(s, 0, Policy);
-
-  return stmt_str;
-}
-
-/// helper functions, to check if the expr is a sizeof expression
-bool is_size_of(UnaryExprOrTypeTraitExpr const *expr) noexcept {
-  return expr->getKind() == UnaryExprOrTypeTrait::UETT_SizeOf;
-}
-
-// try to infere the type of a potential sizeof expression, if it fails return
-// false, otherwise true
-bool infer_sizeof_type(Expr const *side, QualType &type) {
-  auto const size_of = dyn_cast<UnaryExprOrTypeTraitExpr>(side);
-  if (size_of == nullptr) // could not cast expression to sizeof like expr
-    return false;
-  else {
-    // casted expression wasnt sizeof, maybe a typetrait of alignof
-    if (is_size_of(size_of) == false)
-      return false;
-    else { // we did find a sizeof expression, write the type and return true
-      type = size_of->getArgumentType();
-      return true;
-    }
-  }
-}
-
-std::string count_to_string(const BinaryOperator *expr, bool lhs_rhs_flag,
-                            LangOptions l) {
-  const auto *count_expr = lhs_rhs_flag ? expr->getLHS() : expr->getRHS();
-  return stmt_to_string(count_expr, l);
-}
-
-} // namespace
-
-/// Check if the catched function call was malloc, and warn, propose new
-void NoMallocCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *cast_match = Result.Nodes.getNodeAs<CStyleCastExpr>("c_cast");
-  if (cast_match != nullptr)
-    handle_cast(cast_match);
-
-  const auto *malloc_match = Result.Nodes.getNodeAs<CallExpr>("malloc");
-  if (malloc_match != nullptr)
-    handle_malloc(malloc_match);
-
-  const auto *realloc_match = Result.Nodes.getNodeAs<CallExpr>("realloc");
-  if (realloc_match != nullptr)
-    handle_realloc(realloc_match);
-
-  const auto *free_match = Result.Nodes.getNodeAs<CallExpr>("free");
-  if (free_match != nullptr)
-    handle_free(free_match);
-}
-
-/// handle cast expression, containing a malloc
-/// (int*) malloc(sizeof(int) * 10); would be one example
-void NoMallocCheck::handle_cast(const CStyleCastExpr *MatchedDecl) {
-  // first handle the malloc, check if a fix was supposed
-  const auto *malloc_call =
-      dyn_cast<CallExpr>(MatchedDecl->getSubExprAsWritten());
-  if (malloc_call == nullptr)
-    return;
-
-  // handle the malloc, give information that is called from a cast expression
-  if (handle_malloc(malloc_call, true)) {
-    diag(MatchedDecl->getLocStart(), "Cast not needed anymore")
-        << FixItHint::CreateRemoval(
-            {MatchedDecl->getLocStart(),
-             malloc_call->getLocStart().getLocWithOffset(-1)});
-  }
-}
-
-/// implements the malloc check and its fixit hints
-/// returns true, if a fix was supposed
-bool NoMallocCheck::handle_malloc(const CallExpr *MatchedDecl, bool from_cast) {
-  // i belive this is done by CSA, but i added it just in case!
-  // does not work with c++, how to check on c only in testcases?
-  LangOptions l = getLangOpts();
-  if (not from_cast and not(l.CPlusPlus or l.CPlusPlus11 or l.CPlusPlus14))
-    diag(MatchedDecl->getLocStart(),
-         "Use of malloc with out explicit cast to return value!");
-
-  // getting the bytesize argument of the malloc call
-  // if its a binaryoperator (mulitplication), infer more information!
-  auto arg = dyn_cast<BinaryOperator>(MatchedDecl->getArg(0));
-
-  // the arguent to malloc was not a computation -> no more information
-  // achievable
-  if (arg == nullptr) {
-    return single_or_raw(MatchedDecl);
-  }
-
-  // we have a binary operation, try to infer type and size information
-  else {
-    // multiplication should be the common case
-    // since malloc(sizeof(int) * count) - form
-    if (arg->isMultiplicativeOp()) {
-      return multiplication(MatchedDecl, arg);
-    }
-    // we dont have a multiplication, this is shady!
-    else {
-      suspicious_binary(MatchedDecl);
-      return false;
-    }
-  }
-  return false; // since the method is to big, just do it here. needs to get
-                // fixed
-}
-
-/// implements the realloc check and its suggestions (std::vector)
-void NoMallocCheck::handle_realloc(const CallExpr *MatchedDecl) {
-  diag(MatchedDecl->getLocStart(), "Reallocation memory suggests, that either "
-                                   "std::vector or std::string is a better "
-                                   "match for your usecase than C-Style memory "
-                                   "management. [R.10?]")
-      << SourceRange{MatchedDecl->getLocStart(), MatchedDecl->getLocEnd()};
-  diag(MatchedDecl->getLocStart(), "std::vector<>::resize does the job!",
-       DiagnosticIDs::Note);
-  give_deletion_hint(MatchedDecl);
-}
-
-/// implements the free check and its suggestions (RAII)
-void NoMallocCheck::handle_free(const CallExpr *MatchedDecl) {
-  diag(MatchedDecl->getLocStart(), "Do not use error prone C-Style memory "
-                                   "management. Consider using RAII Objects. "
-                                   "[R.10]")
-      << SourceRange{MatchedDecl->getLocStart(), MatchedDecl->getLocEnd()};
-  give_deletion_hint(MatchedDecl);
-}
-
-/// find out the type, if a sizeof expr exists
-/// flag is true, when count will be on lhs
-/// flag is false, when count will be on rhs
-bool NoMallocCheck::determine_type_and_count(const BinaryOperator *arg,
-                                             QualType &type,
-                                             bool &lhs_rhs_flag) const {
-  auto const *lhs = arg->getLHS();
-  auto const *rhs = arg->getRHS();
-
-  // on success, sets the type
-  // lhs inferes type
-  if (infer_sizeof_type(lhs, type) == true) {
-    lhs_rhs_flag = false; // rhs is count
-    return true;
-  }
-  // rhs inferes type
-  else if (infer_sizeof_type(rhs, type) == true) {
-    lhs_rhs_flag = true; // lhs is count
-    return true;
-  }
-  // could not infere type, therefore results are invalid!
-  else {
-    return false;
-  }
-}
-
-/// handle malloc call that has not a binary expression as argument
-/// returns true if a fix is suggested
-bool NoMallocCheck::single_or_raw(const CallExpr *malloc_call) {
-  // check if its malloc(sizeof(int)) and transform to normal new
-  // otherwise warn
-  QualType t;
-  bool is_size_of_t = infer_sizeof_type(malloc_call->getArg(0), t);
-
-  // we got a sizeof
-  if (is_size_of_t) {
-    Type const *type = t.split().asPair().first;
-    std::string replacement =
-        "new " + QualType::getAsString(type, Qualifiers());
-
-    diag(malloc_call->getLocStart(),
-         "Use new instead of malloc for object-creation. [R.10]")
-        << FixItHint::CreateReplacement(
-            {malloc_call->getLocStart(), malloc_call->getLocEnd()},
-            replacement);
-    give_deletion_hint(malloc_call);
-
-    return true;
-  }
-  // we got a suspicious malloc with no information
-  else {
-    diag(malloc_call->getLocStart(), "Could not infer your usecase of malloc!");
-    give_call_hint(malloc_call);
-
-    return false;
-  }
-}
-
-/// handles malloc calls with multiplication as argument
-/// returns true if a fix is suggested
-bool NoMallocCheck::multiplication(const CallExpr *call,
-                                   const BinaryOperator *arg) {
-  // determine_type_and_count sets this flag.
-  // on true -> lhs is count expression
-  // on false -> rhs is count expression
-  bool lhs_rhs_flag = false;
-  QualType size_of_type;
-
-  if (determine_type_and_count(arg, size_of_type, lhs_rhs_flag) == true) {
-    // either lhs or rhs are type/count. find it out and write to variables
-    // suggest an fix in the form 'new type[count]'
-
-    // get the expression for the count amount
-    std::string count_expr_str =
-        count_to_string(arg, lhs_rhs_flag, this->getLangOpts());
-
-    // remove qualifiers from the infered type
-    Type const *type = size_of_type.split().asPair().first;
-    // generate string from it
-    std::string t_hint = QualType::getAsString(type, Qualifiers());
-    std::string replacement = "new " + t_hint + "[" + count_expr_str + "]";
-
-    // warn the malloc and give a fix hint with new[] syntax
-    diag(call->getLocStart(),
-         "Create Dynamic Arrays with std::vector(resizeable), "
-         "std::make_unique<type[]>, gsl::dyn_array(both "
-         "dynamic, but fixed size) [Resource Management]")
-        << SourceRange{call->getLocStart(), call->getLocEnd()}
-        << FixItHint::CreateReplacement(
-               SourceRange{call->getLocStart(), call->getLocEnd()}, replacement);
-
-    give_array_hint(call, t_hint, count_expr_str);
-    give_deletion_hint(call);
-
-    return true;
-  }
-  // failed to infer type and count
-  else {
-    diag(call->getLocStart(),
-         "suspicious malloc. weired multiplication as argument!")
-        << SourceRange{call->getLocStart(), call->getLocEnd()};
-
-    give_call_hint(call);
-
-    return false;
-  }
-}
-
-/// warning about a suspicious, possibly buggy malloc call
-void NoMallocCheck::suspicious_binary(const CallExpr *call) {
-  // warn the suspicious malloc call
-  diag(call->getLocStart(),
-       "Suspicious malloc. Argument is a Binary Operation, but no "
-       "multiplication.")
-      << SourceRange{call->getLocStart(), call->getLocEnd()};
-
-  // note for a possible bug
-  diag(call->getLocStart(),
-       "Check for the 'malloc(sizeof(int) * 10 + 1)' - Bug",
-       DiagnosticIDs::Note)
-      << SourceRange{call->getLocStart(), call->getLocEnd()};
-
-  // note how to call properly
-  give_call_hint(call);
-}
-
-/// hint how to call malloc properly as Diagnostic::Note
-void NoMallocCheck::give_call_hint(const CallExpr *malloc_call) {
-  diag(malloc_call->getLocStart(),
-       "Write malloc in the form (type*) malloc(sizeof(type) * count)",
-       DiagnosticIDs::Note);
-}
-
-/// notes about other ways to create a dynamic array
-void NoMallocCheck::give_array_hint(const CallExpr *malloc_call,
-                                    const std::string &t_hint,
-                                    const std::string &count_str) {
-  std::string vec_hint =
-      "Consider std::vector<" + t_hint + ">(" + count_str + ")";
-  std::string uni_hint =
-      "Consider std::make_unique<" + t_hint + "[]>(" + count_str + ")";
-  std::string gsl_hint =
-      "Consider gsl::dyn_array<" + t_hint + ">(" + count_str + ")";
-
-  // notes on other possible replacements
-  diag(malloc_call->getLocStart(), vec_hint, DiagnosticIDs::Note);
-  diag(malloc_call->getLocStart(), uni_hint, DiagnosticIDs::Note);
-  diag(malloc_call->getLocStart(), gsl_hint, DiagnosticIDs::Note);
-}
-
-/// give hint on deletion of the memory resource
-void NoMallocCheck::give_deletion_hint(const CallExpr *malloc_call) {
-  diag(malloc_call->getLocStart(),
-       "You must manually remove free and replace it with delete/delete[]!",
-       DiagnosticIDs::Note);
-  diag(malloc_call->getLocStart(), "When using a RAII mechanism, remove the "
-                                   "explicit deleting of this variable!",
-       DiagnosticIDs::Note);
-}
-
-} // namespace modernize
-} // namespace tidy
-} // namespace clang

clang-tidy/performance/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyPerformanceModule
   FasterStringFindCheck.cpp
   ForRangeCopyCheck.cpp
   ImplicitCastInLoopCheck.cpp
   InefficientStringConcatenationCheck.cpp
   InefficientVectorOperationCheck.cpp
   PerformanceTidyModule.cpp
-  UlfexpressionsCheck.cpp
   TypePromotionInMathFnCheck.cpp
   UnnecessaryCopyInitialization.cpp
   UnnecessaryValueParamCheck.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTidyUtils
   )

clang-tidy/performance/PerformanceTidyModule.cpp

 //===--- PeformanceTidyModule.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 "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
-#include "InefficientStringConcatenationCheck.h"
-#include "UlfexpressionsCheck.h"
 #include "FasterStringFindCheck.h"
 #include "ForRangeCopyCheck.h"
 #include "ImplicitCastInLoopCheck.h"
 #include "InefficientStringConcatenationCheck.h"
 #include "InefficientVectorOperationCheck.h"
 #include "TypePromotionInMathFnCheck.h"
 #include "UnnecessaryCopyInitialization.h"
 #include "UnnecessaryValueParamCheck.h"

clang-tidy/performance/UlfexpressionsCheck.h

-//===--- UlfexpressionsCheck.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_PERFORMANCE_ULFEXPRESSIONS_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_ULFEXPRESSIONS_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace performance {
-
-/// FIXME: Write a short description.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/performance-UlfExpressions.html
-class UlfexpressionsCheck : public ClangTidyCheck {
-public:
-  UlfexpressionsCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-
-private:
-  void fixExpressionTemplate(const CXXOperatorCallExpr *expr,
-                             const DeclRefExpr *op1, const DeclRefExpr *op2);
-  void fixNegation(const DeclRefExpr *op);
-  void fixPointerAccess(const CXXOperatorCallExpr *calc,
-                        const UnaryOperator *op1, const UnaryOperator *op2);
-  void fixProblematicScalar(const CXXOperatorCallExpr *problematic);
-  void fixProblematicVector(const CXXOperatorCallExpr *problematic);
-  void fixTemporary(const CXXBindTemporaryExpr *tmp);
-
-  bool already_fixed(const SourceLocation &loc);
-
-  std::vector<SourceLocation> FixedLocations;
-};
-
-} // namespace performance
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_ULFEXPRESSIONS_H

clang-tidy/performance/UlfexpressionsCheck.cpp

-//===--- UlfexpressionsCheck.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 "UlfexpressionsCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include <algorithm>
-#include <iostream>
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace performance {
-
-void UlfexpressionsCheck::registerMatchers(MatchFinder *Finder) {
-  // expression templates only in c++ for now
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  // experimental matchers from clang-query
-  //
-  //
-  // match cxxBindTemporaryExpr(hasAncestor(cxxOperatorCallExpr()))
-  // gives the expression where calculation happens
-  //
-  // cxxBindTemporaryExpr(hasAncestor(cxxOperatorCallExpr(hasAnyArgument(hasType(cxxRecordDecl(hasName("fieldDataTmpl"))))))).bind("overloaded_operators")
-
-  // already pretty good
-  //
-  // cxxOperatorCallExpr(allOf(unless(cxxOperatorCallExpr(forEachDescendant(cxxBindTemporaryExpr()))),
-  // hasAnyArgument(hasType(cxxRecordDecl(hasName("fieldDataTmpl"))))))
-  //
-  // most likely wanted matcher
-  //
-  // cxxOperatorCallExpr(allOf(unless(cxxOperatorCallExpr(forEachDescendant(cxxBindTemporaryExpr()))),
-  // hasAnyArgument(hasType(cxxRecordDecl(hasName("fieldDataTmpl")))),
-  // anyOf(hasOverloadedOperatorName("+"), hasOverloadedOperatorName("-"),
-  // hasOverloadedOperatorName("*"), hasOverloadedOperatorName("/"))))
-  //
-
-  // match operatorcalls, with non temporaries, and fieldDataTmpl as one
-  // argument, and only arithmetic
-
-  Finder->addMatcher(
-      cxxOperatorCallExpr(
-          allOf(hasAnyArgument(hasType(
-                    cxxRecordDecl(hasAnyName("fieldDataTmpl", "fieldTmpl")))),
-                // hasArgument(0,
-                // hasType(cxxRecordDecl(hasName("fieldDataTmpl")))),
-                // hasArgument(1,
-                // hasType(cxxRecordDecl(hasName("fieldDataTmpl")))),
-                anyOf(hasArgument(0, declRefExpr().bind("op1")),
-                      hasArgument(0, anything())),
-                anyOf(hasArgument(1, declRefExpr().bind("op2")),
-                      hasArgument(1, anything())),
-                unless(cxxOperatorCallExpr(has(cxxBindTemporaryExpr()))),
-                anyOf(hasOverloadedOperatorName("+"),
-                      hasOverloadedOperatorName("-"),
-                      hasOverloadedOperatorName("*"),
-                      hasOverloadedOperatorName("/"))))
-          .bind("calculation"),
-      this);
-
-  // negations of fields
-  Finder->addMatcher(cxxOperatorCallExpr(allOf(
-                         hasOverloadedOperatorName("-"), argumentCountIs(1),
-                         hasAnyArgument(hasType(cxxRecordDecl(
-                             hasAnyName("fieldDataTmpl", "fieldTmpl")))),
-                         hasArgument(0, declRefExpr().bind("negation")))),
-                     this);
-
-  // pointer dereferencing in equations
-  Finder->addMatcher(
-      cxxOperatorCallExpr(
-          allOf(
-              hasAnyArgument(hasType(
-                  cxxRecordDecl(hasAnyName("fieldDataTmpl", "fieldTmpl")))),
-              anyOf(
-                  hasArgument(0, unaryOperator(
-                                     allOf(hasOperatorName("*"),
-                                           hasType(cxxRecordDecl(hasAnyName(
-                                               "fieldDataTmpl", "fieldTmpl")))))
-                                     .bind("deref1")),
-                  hasArgument(1, unaryOperator(
-                                     allOf(hasOperatorName("*"),
-                                           hasType(cxxRecordDecl(hasAnyName(
-                                               "fieldDataTmpl", "fieldTmpl")))))
-                                     .bind("deref2"))),
-              anyOf(hasOverloadedOperatorName("+"),
-                    hasOverloadedOperatorName("-"),
-                    hasOverloadedOperatorName("*"),
-                    hasOverloadedOperatorName("/"))))
-          .bind("calc_with_deref"),
-      this);
-
-#if 0
-  // calculation, that are not mathematically sound
-  Finder->addMatcher(
-      cxxOperatorCallExpr(
-          allOf(hasAnyArgument(hasType(cxxRecordDecl(
-                    anyOf(hasName("fieldDataTmpl"), hasName("fieldTmpl"))))),
-                hasAnyArgument(hasType(asString("double"))),
-                anyOf(hasOverloadedOperatorName("+"),
-                      hasOverloadedOperatorName("-"))))
-          .bind("problematic_scalar"),
-      this);
-#endif
-
-  // temporary
-  Finder->addMatcher(
-      cxxBindTemporaryExpr(allOf(hasType(cxxRecordDecl(
-                                     hasAnyName("fieldDataTmpl", "fieldTmpl"))),
-                                 unless(has(cxxOperatorCallExpr()))))
-          .bind("temporary_field"),
-      this);
-}
-
-void UlfexpressionsCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto &n = Result.Nodes;
-
-  if (const auto *expression =
-          n.getNodeAs<CXXOperatorCallExpr>("calculation")) {
-    const DeclRefExpr *op1 = n.getNodeAs<DeclRefExpr>("op1");
-    const DeclRefExpr *op2 = n.getNodeAs<DeclRefExpr>("op2");
-    fixExpressionTemplate(expression, op1, op2);
-  }
-
-  if (const auto *op = n.getNodeAs<DeclRefExpr>("negation")) {
-    fixNegation(op);
-  }
-
-  if (const auto *deref = n.getNodeAs<CXXOperatorCallExpr>("calc_with_deref")) {
-    diag(deref->getLocStart(), "Equation with pointer deref");
-    const auto *op1 = n.getNodeAs<UnaryOperator>("deref1");
-    const auto *op2 = n.getNodeAs<UnaryOperator>("deref2");
-    fixPointerAccess(deref, op1, op2);
-  }
-
-  if (const auto *problematic =
-          n.getNodeAs<CXXOperatorCallExpr>("problematic_scalar")) {
-    fixProblematicScalar(problematic);
-  }
-
-  if (const auto *problematic =
-          n.getNodeAs<CXXOperatorCallExpr>("problematic_vector")) {
-    fixProblematicVector(problematic);
-  }
-
-  if (const auto *temporary =
-          n.getNodeAs<CXXBindTemporaryExpr>("temporary_field")) {
-    fixTemporary(temporary);
-  }
-}
-
-namespace {
-bool isFieldData(const DeclRefExpr *op) {
-
-  bool result;
-  if (op == nullptr)
-    result = false;
-  else {
-
-    auto arg_type = op->getDecl()->getType();
-    Type const *t = arg_type.split().asPair().first;
-
-    // skip non fieldDatas
-    result = (QualType::getAsString(t, Qualifiers()).find("fieldData") !=
-              std::string::npos) ||
-             (QualType::getAsString(t, Qualifiers()).find("field") !=
-              std::string::npos);
-  }
-  // std::cout << "is fielddata? " << op << " - " << result << std::endl;
-  return result;
-}
-}
-
-/// use expression template for fieldData-fieldData operations
-void UlfexpressionsCheck::fixExpressionTemplate(const CXXOperatorCallExpr *expr,
-                                                const DeclRefExpr *op1,
-                                                const DeclRefExpr *op2) {
-  assert(expr->isInfixBinaryOp());
-
-  if (isFieldData(op1)) {
-    std::string op1_name = op1->getFoundDecl()->getNameAsString();
-    auto location = op1->getLocation().getLocWithOffset(op1_name.size());
-
-    if (!already_fixed(location)) {
-      auto Diag = diag(location, "use expression templates");
-      Diag << FixItHint::CreateInsertion(location, ".v()");
-      FixedLocations.push_back(location);
-    }
-  }
-
-  if (isFieldData(op2)) {
-    std::string op2_name = op2->getFoundDecl()->getNameAsString();
-    auto location = op2->getLocation().getLocWithOffset(op2_name.size());
-
-    if (!already_fixed(location)) {
-      auto Diag = diag(location, "use expression templates");
-      Diag << FixItHint::CreateInsertion(location, ".v()");
-      FixedLocations.push_back(location);
-    }
-  }
-}
-
-void UlfexpressionsCheck::fixNegation(const DeclRefExpr *op) {
-#if 0
-  std::string op_name = op->getFoundDecl()->getNameAsString();
-  auto location = op->getLocation().getLocWithOffset(op_name.size());
-
-  diag(location, "Enabling expression template for negation")
-      << FixItHint::CreateInsertion(location, ".v()");
-
-  FixedLocations.push_back(location);
-#endif
-}
-
-namespace {
-std::string stmt_to_string(Stmt const *stmt, LangOptions l) {
-  // configuration
-  PrintingPolicy Policy(l);
-
-  // printing
-  std::string stmt_str;
-  llvm::raw_string_ostream s(stmt_str);
-  stmt->printPretty(s, 0, Policy);
-
-  return stmt_str;
-}
-}
-
-void UlfexpressionsCheck::fixPointerAccess(const CXXOperatorCallExpr *calc,
-                                           const UnaryOperator *op1,
-                                           const UnaryOperator *op2) {
-  if (op1) {
-    std::string stmt = stmt_to_string(op1, this->getLangOpts());
-    stmt += "->v()";
-    stmt.erase(0, 1);
-    diag(op1->getLocStart(), "Dereferencing") << FixItHint::CreateReplacement(
-        SourceRange(op1->getLocStart(), op1->getLocEnd()), stmt);
-  }
-  if (op2) {
-    std::string stmt = stmt_to_string(op2, this->getLangOpts());
-    stmt += "->v()";
-    stmt.erase(0, 1);
-    diag(op2->getLocStart(), "Dereferencing") << FixItHint::CreateReplacement(
-        SourceRange(op2->getLocStart(), op2->getLocEnd()), stmt);
-  }
-}
-
-/// scalar +/- vector, not defined in math
-void UlfexpressionsCheck::fixProblematicScalar(
-    const CXXOperatorCallExpr *problematic) {
-  assert(problematic->isInfixBinaryOp());
-
-  // create the warning
-  auto Diag =
-      diag(problematic->getLocStart(),
-           "do not use problematic vector-scalar math")
-      << SourceRange{problematic->getLocStart(), problematic->getLocEnd()};
-
-#if 0
-  // generate the fixit hint
-  auto *args = problematic->getArgs();
-  auto n = problematic->getNumArgs();
-
-  assert(n == 2); // we have binary expression
-
-  for (unsigned short i = 0; i < n; ++i) {
-    auto arg_type = args[i]->getType();
-    Type const *t = arg_type.split().asPair().first;
-
-    // skip fieldData
-    if (QualType::getAsString(t, Qualifiers()).find("fieldData") !=
-        std::string::npos)
-      continue;
-
-    Diag << FixItHint::CreateInsertion(args[i]->getLocEnd(), " * ONES");
-  }
-#endif
-}
-
-/// vector vector division
-void UlfexpressionsCheck::fixProblematicVector(
-    const CXXOperatorCallExpr *problematic) {
-  assert(problematic->isInfixBinaryOp());
-
-  auto Diag =
-      diag(problematic->getLocStart(), "dont use problematic vector math");
-
-#if 0
-  // generate the fixit hint
-  auto *args = problematic->getArgs();
-  auto n = problematic->getNumArgs();
-
-  assert(n == 2); // we have binary expression
-
-  for (unsigned short i = 0; i < n; ++i) {
-    auto arg_type = args[i]->getType();
-    Type const *t = arg_type.split().asPair().first;
-
-    if (QualType::getAsString(t, Qualifiers()).find("fieldData") ==
-        std::string::npos)
-      continue;
-
-    Diag << FixItHint::CreateInsertion(args[i]->getLocEnd(), ".v()");
-  }
-#endif
-}
-
-void UlfexpressionsCheck::fixTemporary(const CXXBindTemporaryExpr *tmp) {
-  auto Diag =
-      diag(tmp->getLocStart(), "created temporary field, check necessity")
-      << SourceRange{tmp->getLocStart(), tmp->getLocEnd()};
-  auto location = tmp->getLocEnd().getLocWithOffset(1);
-
-  if (!already_fixed(location)) {
-    Diag << FixItHint::CreateInsertion(location, ".v()");
-    FixedLocations.push_back(location);
-  }
-}
-
-bool UlfexpressionsCheck::already_fixed(const SourceLocation &loc) {
-  auto pos =
-      std::find(std::begin(FixedLocations), std::end(FixedLocations), loc);
-  return pos != std::end(FixedLocations);
-}
-
-} // namespace performance
-} // namespace tidy
-} // namespace clang

docs/clang-tidy/checks/cppcoreguidelines-naked_new.rst

-.. title:: clang-tidy - cppcoreguidelines-naked_new
-
-cppcoreguidelines-naked_new
-===========================
-
-FIXME: Describe what patterns does the check detect and why. Give examples.

docs/clang-tidy/checks/list.rst

.. toctree::
    cert-err60-cpp
    cert-err61-cpp (redirects to misc-throw-by-value-catch-by-reference) <cert-err61-cpp>
    cert-fio38-c (redirects to misc-non-copyable-objects) <cert-fio38-c>
    cert-flp30-c
    cert-msc30-c (redirects to cert-msc50-cpp) <cert-msc30-c>
    cert-msc50-cpp
    cert-oop11-cpp (redirects to misc-move-constructor-init) <cert-oop11-cpp>
    cppcoreguidelines-interfaces-global-init
-   cppcoreguidelines-naked_new
    cppcoreguidelines-no-malloc
    cppcoreguidelines-owning-memory
    cppcoreguidelines-pro-bounds-array-to-pointer-decay
    cppcoreguidelines-pro-bounds-constant-array-index
    cppcoreguidelines-pro-bounds-pointer-arithmetic
    cppcoreguidelines-pro-type-const-cast
    cppcoreguidelines-pro-type-cstyle-cast
    cppcoreguidelines-pro-type-member-init
.. toctree::
    google-runtime-references
    hicpp-explicit-conversions
    hicpp-function-size
    hicpp-invalid-access-moved
    hicpp-member-init
    hicpp-named-parameter
    hicpp-new-delete-operators
    hicpp-no-assembler
    hicpp-noexcept-move
    hicpp-special-member-functions
    hicpp-undelegated-constructor
    hicpp-use-equals-default
    hicpp-use-equals-delete
    hicpp-use-override
    llvm-header-guard
    llvm-include-order
    llvm-namespace-comment
.. toctree::
    misc-unused-using-decls
    misc-use-after-move
    misc-virtual-near-miss
    modernize-avoid-bind
    modernize-deprecated-headers
    modernize-loop-convert
    modernize-make-shared
    modernize-make-unique
-   modernize-no-malloc
    modernize-pass-by-value
    modernize-raw-string-literal
    modernize-redundant-void-arg
    modernize-replace-auto-ptr
    modernize-replace-random-shuffle
    modernize-return-braced-init-list
    modernize-shrink-to-fit
    modernize-unary-static-assert
    modernize-use-auto
    modernize-use-bool-literals
    modernize-use-default-member-init
    modernize-use-emplace
    modernize-use-equals-default
    modernize-use-equals-delete
    modernize-use-noexcept
    modernize-use-nullptr
    modernize-use-override
    modernize-use-transparent-functors
    modernize-use-using
    mpi-buffer-deref
    mpi-type-mismatch
-   performance-UlfExpressions
    performance-faster-string-find
    performance-for-range-copy
    performance-implicit-cast-in-loop
    performance-inefficient-string-concatenation
    performance-inefficient-vector-operation
    performance-type-promotion-in-math-fn
    performance-unnecessary-copy-initialization
    performance-unnecessary-value-param

docs/clang-tidy/checks/modernize-no-malloc.rst

-.. title:: clang-tidy - modernize-no-malloc
-
-modernize-no-malloc
-===================
-
-This check handles C-Style memory management using ``malloc()``, ``realloc()`` 
-and ``free()``. It warns about its use and tries to replace ``malloc()`` with
-corresponding ``new`` expressions. If it fails to do so, a note will be emitted
-how to write malloc calls with more information, making it easier to reason 
-about.
-See `CppCoreGuidlines
-<https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#r-resource-management>`
-
-Both array...
-
-.. code-block:: c++
-
-  char* some_string = (char*) malloc(sizeof(char) * 20);
-
-  // becomes
-
-  char* some_string = new char[20];
-
-... and single element creation are supported.
-
-.. code-block:: c++
-
-  int* integer = (int*) malloc(sizeof(int));
-
-  // becomes
-
-  int* integer = new int;
-
-
-Furthermore it warns about suspicious calls to malloc.
-
-.. code-block:: c++
-
-  // suspicious because not an multiplication of sizeof() and count
-  int* int_array = (int*) malloc(25);
-  int* buggy_array = (int*) malloc(sizeof(int) * 10 + 1);
-
-
-Since general replacement of malloc with new requires the replacement of the
-free calls as well, automatic fixing should be used with caution. The check will
-warn about C-Style Memory Management, give hints how to do it better and 
-reference the cppcoreguidelines.
-
-Know Bug
-========
-
-The fixit-hint for struct, class and enum objects are incorrect.
-

docs/clang-tidy/checks/performance-UlfExpressions.rst

-.. title:: clang-tidy - performance-UlfExpressions
-
-performance-UlfExpressions
-===========================
-
-FIXME: Describe what patterns does the check detect and why. Give examples.

test/clang-tidy/cppcoreguidelines-owning-memory.cpp

 // RUN: %check_clang_tidy %s cppcoreguidelines-owning-memory %t
 
-#if 0
-// Copied from NoMallocCheck
-using size_t = __SIZE_TYPE__;
-void *malloc(size_t size);
-void *align_malloc(size_t size, unsigned short aligmnent);
-void *calloc(size_t num, size_t size);
-void *realloc(void *ptr, size_t size);
-void *align_realloc(void *ptr, size_t size, unsigned short alignment);
-#endif
-
 namespace gsl {
 template <class T>
 using owner = T;
 } // namespace gsl
 
 template <typename T>
 class unique_ptr {
 public:

 }
 
 gsl::owner<int *> returns_owner1() { return gsl::owner<int *>(new int(42)); } // Ok
 gsl::owner<int *> returns_owner2() { return new int(42); } // Ok
 
 int *returns_no_owner1() { return nullptr; }
 int *returns_no_owner2() {
   return new int(42);
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: returning an owner/resource from a function but not declaring it as one
 }
 int *returns_no_owner3() {
   int *should_be_owner = new int(42);
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non owner with a newly created owner/resource
   return should_be_owner;
 }
 int *returns_no_owner4() {
   gsl::owner<int *> owner = new int(42);
void test_assignment_and_initialization() {
   int *unowned_int7 = new int(42); // Bad, since resource not assigned to an owner
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non owner with a newly created owner/resource
 
   int *unowned_int8;
   unowned_int8 = new int(42);
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: assigning newly created owner/resource to non-owner
 
   gsl::owner<int *> owned_int13 = nullptr; // Ok
-
-#if 0
-  gsl::owner<int *> owned_int14 = (int *)malloc(20 * sizeof(int)); // Ok
-  gsl::owner<int *> owned_int15 = static_cast<int *>(malloc(20 * sizeof(int))); // Ok
-  int *unowned_int9 = (int *)malloc(20 * sizeof(int)); // Bad, since must be catched by an owner
-  // CHECK - MESSAGES: [[@LINE-1]]:3: warning: assigning newly created owner/resource to non-owner
-#endif
 }
 
 void test_deletion() {
   gsl::owner<int *> owned_int1 = new int(42);
   delete owned_int1; // Good
 
   gsl::owner<int *> owned_int2 = new int[42];
   delete[] owned_int2; // Good
void test_templates() {
   int *stack_ptr2 = Owner1.getVal(); // Bad, initializing nonowner with owner
 
   TemplateValue<int *> NonOwner1(new int(42)); // Bad, T is int *, hence dynamic memory to non owner
   gsl::owner<int *> IntOwner1 = NonOwner1.getVal(); // Bad, since owner initialized with nonowner
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing neither with an owner nor a recognized resource
 
   template_function(IntOwner1); // Ok, but not actually ok, since typededuction removes owner
   template_function(stack_ptr1); // Bad, but typededuction gets it wrong
 }