[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

16

Please remove this line.

docs/ReleaseNotes.rst

60–62

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

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

7

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

30

Can elide the braces.

33

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

40

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

56

non-owners

76

Can remove the first comma.

84

Can remove the first comma.

94

Can remove the first comma.

102

Can remove the first comma.

109

Can remove the first comma.

118

Can remove the first comma.

129

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

clang-tidy/cppcoreguidelines/OwningMemoryCheck.h

20

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

150

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.

154

"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.

155–156

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

158

No else after a return (same applies elsewhere).

169

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.

189

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

150

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

154

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.

169

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

189

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

168

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

185

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

189

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.

192

No else after a return. Same applies elsewhere.

[aaron.ballman]

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

209

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

231

Are you intending to address this in this patch?

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

[JonasToth]

clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

231

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

192

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

203

Can remove the comma.

240

s/non owner/non-owner

257

s/non owner/non-owner

293

s/an declared/a declared

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

295

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).

296

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

295

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

12

s/an/a/

18

s/it/It/

28

s/caught/checked/

98

s/an/a/

132

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

141

Can assert CheckExecuted and drop the explicit equality test.

142

did execute, -> executed;

207

initializing -> intialization

304–306

Please remove the commented-out lines.

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

40

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

[JonasToth]

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

40

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

40

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

40

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

142

Non -> None

295

Missing a full stop at the end of the sentence.

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

40

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

355

typededuction -> type deduction

(here and elsewhere)

373

harmfull -> harmful

375

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/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyCppCoreGuidelinesModule
   CppCoreGuidelinesTidyModule.cpp
   InterfacesGlobalInitCheck.cpp
   NoMallocCheck.cpp
+  OwningMemoryCheck.cpp
   ProBoundsArrayToPointerDecayCheck.cpp
   ProBoundsConstantArrayIndexCheck.cpp
   ProBoundsPointerArithmeticCheck.cpp
   ProTypeConstCastCheck.cpp
   ProTypeCstyleCastCheck.cpp
   ProTypeMemberInitCheck.cpp
   ProTypeReinterpretCastCheck.cpp
   ProTypeStaticCastDowncastCheck.cpp

clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

 //===--- CppCoreGuidelinesModule.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 "../misc/UnconventionalAssignOperatorCheck.h"
 #include "InterfacesGlobalInitCheck.h"
 #include "NoMallocCheck.h"
+#include "OwningMemoryCheck.h"
 #include "ProBoundsArrayToPointerDecayCheck.h"
 #include "ProBoundsConstantArrayIndexCheck.h"
 #include "ProBoundsPointerArithmeticCheck.h"
 #include "ProTypeConstCastCheck.h"
 #include "ProTypeCstyleCastCheck.h"
 #include "ProTypeMemberInitCheck.h"
 #include "ProTypeReinterpretCastCheck.h"
 #include "ProTypeStaticCastDowncastCheck.h"
 #include "ProTypeUnionAccessCheck.h"
 #include "ProTypeVarargCheck.h"
 #include "SlicingCheck.h"
 #include "SpecialMemberFunctionsCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
 /// A module containing checks of the C++ Core Guidelines
 class CppCoreGuidelinesModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<InterfacesGlobalInitCheck>(
         "cppcoreguidelines-interfaces-global-init");
     CheckFactories.registerCheck<NoMallocCheck>("cppcoreguidelines-no-malloc");
+    CheckFactories.registerCheck<OwningMemoryCheck>(
+        "cppcoreguidelines-owning-memory");
     CheckFactories.registerCheck<ProBoundsArrayToPointerDecayCheck>(
         "cppcoreguidelines-pro-bounds-array-to-pointer-decay");
     CheckFactories.registerCheck<ProBoundsConstantArrayIndexCheck>(
         "cppcoreguidelines-pro-bounds-constant-array-index");
     CheckFactories.registerCheck<ProBoundsPointerArithmeticCheck>(
         "cppcoreguidelines-pro-bounds-pointer-arithmetic");
     CheckFactories.registerCheck<ProTypeConstCastCheck>(
         "cppcoreguidelines-pro-type-const-cast");

clang-tidy/cppcoreguidelines/OwningMemoryCheck.h

+//===--- OwningMemoryCheck.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_CPPCOREGUIDELINES_OWNING_MEMORY_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_OWNING_MEMORY_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace cppcoreguidelines {
+
+/// Checks for common usecases for gsl::owner and enforces the unique owner nature
+/// of it whenever possible.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-owning-memory.html
+class OwningMemoryCheck : public ClangTidyCheck {
+public:
+  OwningMemoryCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace cppcoreguidelines
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_OWNING_MEMORY_H

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 {
+
+/// 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)))))));
+  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) {
+  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/utils/Matchers.h

 
 #include "TypeTraits.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 
 namespace clang {
 namespace tidy {
 namespace matchers {
 
+AST_MATCHER(BinaryOperator, isAssignmentOperator) {
+  return Node.isAssignmentOp();
+}
+
 AST_MATCHER(BinaryOperator, isRelationalOperator) {
   return Node.isRelationalOp();
 }
 
 AST_MATCHER(BinaryOperator, isEqualityOperator) { return Node.isEqualityOp(); }
 
 AST_MATCHER(BinaryOperator, isComparisonOperator) {
   return Node.isComparisonOp();

docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
-The improvements are...
+- New `cppcoreguidelines-owning-memory <http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-owning-memory.html>`_ check 
+  This check implements the type-based semantic of ``gsl::owner<T*>``, but without
+  flow analysis.
 
 Improvements to include-fixer
 -----------------------------
 
 The improvements are...
 
 Improvements to modularize
 --------------------------
 
 The improvements are...

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

+.. title:: clang-tidy - cppcoreguidelines-owning-memory
+
+cppcoreguidelines-owning-memory
+===============================
+
+This check implements the type-based semantics of ``gsl::owner<T*>``, which allows 
+static analysis on code, that uses raw pointers to handle resources like 
+dynamic memory, but won't introduce RAII concepts.
+
+The relevant sections in the `C++ Core Guidelines <https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md>`_ are I.11, C.33, R.3 and GSL.Views
+The definition of an ``gsl::owner<T*>`` is straight forward
+
+.. code-block:: c++
+
+  namespace gsl { template <typename T> owner = T; }
+
+it is therefore simple to introduce the owner even without using an implementation of
+the `Guideline Support Library <https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gsl-guideline-support-library>`_.
+
+All checks are purely type based and not (yet) flow sensitive.
+
+The following examples will demonstrate the correct and incorrect initializations
+of owners, assignment is handled the same way.
+
+.. code-block:: c++
+
+  // Creating an owner with factory functions is caught.
+  gsl::owner<int*> function_that_returns_owner() { return gsl::owner<int*>(new int(42)); }
+
+  // Dynamic memory must be assigned to an owner
+  int* Something = new int(42); // BAD, will be caught
+  gsl::owner<int*> Owner = new int(42); // Good
+  gsl::owner<int*> Owner = new int[42]; // Good as well
+
+  // Returned owner must be assigned to an owner
+  int* Something = function_that_returns_owner(); // Bad, factory function
+  gsl::owner<int*> Owner = function_that_returns_owner(); // Good, result lands in owner
+
+  // Something not a resource or owner should not be assigned to owners
+  int Stack = 42;
+  gsl::owner<int*> Owned = &Stack; // Bad, not an resource assigned
+
+In the case of dynamic memory as resource, only ``gsl::owner<T*>`` variables are allowed
+to be deleted.
+
+.. code-block:: c++
+
+  // Example Bad, non-owner as resource handle, will be caught.
+  int* NonOwner = new int(42); // First warning here, since new must land in an owner
+  delete NonOwner; // Second warning here, since only owners are allowed to be deleted
+
+  // Example Good, Ownership correclty stated
+  gsl::owner<int*> Owner = new int(42); // Good
+  delete Owner; // Good as well, statically enforced, that only owners get deleted
+  
+The check will furthermore ensure, that functions, that expect an ``gsl::owner<T*>`` as
+argument get called with either an ``gsl::owner<T*>`` or a newly created resource.
+
+.. code-block:: c++
+
+  void expects_owner(gsl::owner<int*> o) { delete o; }
+
+  // Bad Code
+  int NonOwner = 42;
+  expects_owner(&NonOwner); // Bad, will get caught
+
+  // Good Code
+  gsl::owner<int*> Owner = new int(42);
+  expects_owner(Owner); // Good
+  expects_owner(new int(42)); // Good as well, recognized created resource
+
+Limitations
+-----------
+
+The ``gsl::owner<T*>`` is declared as a templated type alias.
+In template functions and classes, like in the example below, the information
+of the type aliases gets lost. Therefore using ``gsl::owner<T*>`` in a heavy templated
+code base might lead to false positives.
+
+.. code-block:: c++
+
+  // This template function works as expected. Type information doesn't get lost.
+  template <typename T>
+  void delete_owner(gsl::owner<T*> owned_object) {
+    delete owned_object; // Everything alright
+  }
+
+  gsl::owner<int*> function_that_returns_owner() { return gsl::owner<int*>(new int(42)); }
+
+  // Type deduction does not work for auto variables. 
+  // This is caught by the check and will be noted accordingly.
+  auto OwnedObject = function_that_returns_owner(); // Type of OwnedObject will be int*
+
+  // Problematic function template that looses the typeinformation on owner
+  template <typename T>
+  void bad_template_function(T some_object) {
+    // This line will trigger the warning, that an non-owner is assigned to an owner
+    gsl::owner<T*> new_owner = some_object;
+  }
+
+  // Calling the function with an owner still yields a false positive.
+  bad_template_function(gsl::owner<int*>(new int(42)));
+
+
+  // The same issue occurs with templated classes like the following.
+  template <typename T>
+  class OwnedValue {
+  public:
+    const T getValue() const { return _val; }
+  private:
+    T _val;
+  };
+
+  // Code, that yields a false positive.
+  OwnedValue<gsl::owner<int*>> Owner(new int(42)); // Type deduction yield T -> int * 
+  // False positive, getValue returns int* and not gsl::owner<int*>
+  gsl::owner<int*> OwnedInt = Owner.getValue(); 
+
+Another limitation of the current implementation is only the type based checking.
+Suppose you have code like the following:
+
+.. code-block:: c++
+
+  // Two owners with assigned resources
+  gsl::owner<int*> Owner1 = new int(42); 
+  gsl::owner<int*> Owner2 = new int(42);
+
+  Owner2 = Owner1; // Conceptual Leak!
+  Owner1 = nullptr;
+
+The semantic of an ``gsl::owner<T*>`` is mostly like a ``std::unique_ptr<T>``, therefore
+assignment of two ``gsl::owner<T*>`` is considered a move, but therefore the resource
+``Owner2`` must have been released before the assignment.
+This kind of condition could be catched in later improvements of this check with 
+flowsensitive analysis. Currently, the `Clang Static Analyzer` catches this bug
+for dynamic memory, but not for general types of resources.

docs/clang-tidy/checks/list.rst

.. toctree::
    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-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
    cppcoreguidelines-pro-type-reinterpret-cast
    cppcoreguidelines-pro-type-static-cast-downcast
.. 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

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

+// RUN: %check_clang_tidy %s cppcoreguidelines-owning-memory %t
+
+namespace gsl {
+template <class T>
+using owner = T;
+} // namespace gsl
+
+template <typename T>
+class unique_ptr {
+public:
+  unique_ptr(gsl::owner<T> resource) : memory(resource) {}
+  unique_ptr(const unique_ptr<T> &) = default;
+
+  ~unique_ptr() { delete memory; }
+
+private:
+  gsl::owner<T> memory;
+};
+
+void takes_owner(gsl::owner<int *> owned_int) {
+}
+
+void takes_pointer(int *unowned_int) {
+}
+
+void takes_owner_and_more(int some_int, gsl::owner<int *> owned_int, float f) {
+}
+
+template <typename T>
+void takes_templated_owner(gsl::owner<T> owned_T) {
+}
+
+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);
+  return owner;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: returning an owner/resource from a function but not declaring it as one
+}
+
+unique_ptr<int *> returns_no_owner5() {
+  return unique_ptr<int *>(new int(42)); // Ok
+}
+
+/// FIXME CSA finds it, but the report is misleading.
+void csa_not_finding_leak() {
+  gsl::owner<int *> o1 = new int(42); // Ok
+
+  gsl::owner<int *> o2 = o1; // Ok
+  o2 = new int(45); // conceptual leak, the memory from o1 is now leaked, since its considered moved in the guideLINEs
+
+  delete o2;
+  // actual leak occurs here, its found, but mixed
+  delete o1;
+}
+
+void test_assignment_and_initialization() {
+  int stack_int1 = 15;
+  int stack_int2;
+
+  gsl::owner<int *> owned_int1 = &stack_int1; // BAD
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing neither with an owner nor a recognized resource
+
+  gsl::owner<int *> owned_int2;
+  owned_int2 = &stack_int2; // BAD since no owner, bad since uninitialized
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: assigning neither an owner nor a recognized resource
+
+  gsl::owner<int *> owned_int3 = new int(42); // Good
+  owned_int3 = nullptr; // Good
+
+  gsl::owner<int *> owned_int4(nullptr); // Ok
+  owned_int4 = new int(42); // Good
+
+  gsl::owner<int *> owned_int5 = owned_int3; // Good
+
+  gsl::owner<int *> owned_int6{nullptr}; // Ok
+  owned_int6 = owned_int4; // Good
+
+  // FIXME, flow analysis for the case of reassignment. Value must be released before
+  owned_int6 = owned_int3; // BAD, because reassignment without resource release
+
+  auto owned_int7 = returns_owner1(); // Bad, since typededuction eliminates the owner wrapper
+  // CHECK-MESSAGES: [[@LINE-1]]:3: note: type deduction did not result in an owner
+  // CHECK-MESSAGES: [[@LINE-2]]:3: warning: initializing non owner with a newly created owner/resource
+
+  const auto owned_int8 = returns_owner2(); // Bad, since typededuction eliminates the owner wrapper
+  // CHECK-MESSAGES: [[@LINE-1]]:3: note: type deduction did not result in an owner
+  // CHECK-MESSAGES: [[@LINE-2]]:3: warning: initializing non owner with a newly created owner/resource
+
+  gsl::owner<int *> owned_int9 = returns_owner1(); // Ok
+  int *unowned_int3 = returns_owner1(); // Bad
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non owner with a newly created owner/resource
+
+  gsl::owner<int *> owned_int10;
+  owned_int10 = returns_owner1(); // Ok
+
+  int *unowned_int4;
+  unowned_int4 = returns_owner1(); // Bad
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: assigning newly created owner/resource to non-owner
+
+  gsl::owner<int *> owned_int11 = returns_no_owner1(); // Bad since no owner
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing neither with an owner nor a recognized resource
+
+  gsl::owner<int *> owned_int12;
+  owned_int12 = returns_no_owner1(); // Bad since no owner
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: assigning neither an owner nor a recognized resource
+
+  int *unowned_int5 = returns_no_owner1(); // Ok
+  int *unowned_int6;
+  unowned_int6 = returns_no_owner1(); // Ok
+
+  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
+}
+
+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
+
+  int *unowned_int1 = new int(42); // BAD, since new creates and owner
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non owner with a newly created owner/resource
+  delete unowned_int1; // BAD, since no owner
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: deleting unowned memory; use RAII or gsl::owner
+
+  int *unowned_int2 = new int[42]; // BAD, since new creates and owner
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non owner with a newly created owner/resource
+  delete[] unowned_int2; // BAD since no owner
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: deleting unowned memory; use RAII or gsl::owner
+
+  delete new int(42); // Technically ok, but stupid
+  delete[] new int[42]; // Technically ok, but stupid
+}
+
+void test_owner_function_calls() {
+  int stack_int = 42;
+  int *unowned_int1 = &stack_int;
+  takes_owner(&stack_int); // BAD
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: expected this argument to be an owner or a recognized resource
+  takes_owner(unowned_int1); // BAD
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: expected this argument to be an owner or a recognized resource
+
+  gsl::owner<int *> owned_int1 = new int(42);
+  takes_owner(owned_int1); // Ok
+
+  takes_owner_and_more(42, &stack_int, 42.0f); // BAD
+  // CHECK-MESSAGES: [[@LINE-1]]:28: warning: expected this argument to be an owner or a recognized resource
+  takes_owner_and_more(42, unowned_int1, 42.0f); // BAD
+  // CHECK-MESSAGES: [[@LINE-1]]:28: warning: expected this argument to be an owner or a recognized resource
+
+  takes_owner_and_more(42, new int(42), 42.0f); // Ok, since new is consumed by owner
+  takes_owner_and_more(42, owned_int1, 42.0f); // Ok, since owner as argument
+
+  takes_templated_owner(owned_int1); // Ok
+  takes_templated_owner(new int(42)); // Ok
+  takes_templated_owner(unowned_int1); // Bad
+  // CHECK-MESSAGES: [[@LINE-1]]:25: warning: expected this argument to be an owner or a recognized resource
+
+  takes_owner(returns_owner1()); // Ok
+  takes_owner(returns_no_owner1()); // BAD
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: expected this argument to be an owner or a recognized resource
+}
+
+void test_unowned_function_calls() {
+  int stack_int = 42;
+  int *unowned_int1 = &stack_int;
+  gsl::owner<int *> owned_int1 = new int(42);
+
+  takes_pointer(&stack_int); // Ok
+  takes_pointer(unowned_int1); // Ok
+  takes_pointer(owned_int1); // Ok
+  takes_pointer(new int(42)); // Bad, since new creates and owner
+  // CHECK-MESSAGES: [[@LINE-1]]:17: warning: initializing non owner argument with a newly created owner/resource
+
+  takes_pointer(returns_owner1()); // Bad
+  // CHECK-MESSAGES: [[@LINE-1]]:17: warning: initializing non owner argument with a newly created owner/resource
+
+  takes_pointer(returns_no_owner1()); // Ok
+}
+
+struct ArbitrayClass {};
+struct ClassWithOwner { // Does not define destructor, necessary with owner
+  // CHECK-MESSAGES: [[@LINE-1]]:1: warning: class with an owner as member but without declared destructor to release the owner
+  ClassWithOwner() : owner_var(nullptr) {} // Ok
+
+  ClassWithOwner(ArbitrayClass &other) : owner_var(&other) {}
+  // CHECK-MESSAGES: [[@LINE-1]]:42: warning: initializing owner member variable neither with an owner nor a recognized resource
+
+  // FIXME Bad Note generation
+  // CHECK-MESSAGES: [[@LINE+24]]:3: note: declared owner here
+
+  ClassWithOwner(gsl::owner<ArbitrayClass *> other) : owner_var(other) {} // Ok
+
+  ClassWithOwner(gsl::owner<ArbitrayClass *> data, int /* unused */) { // Ok
+    owner_var = data; // Ok
+  }
+
+  ClassWithOwner(ArbitrayClass *bad_data, int /* unused */, int /* unused */) {
+    owner_var = bad_data;
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: assigning neither an owner nor a recognized resource
+  }
+
+  ClassWithOwner(ClassWithOwner &&other) : owner_var{other.owner_var} {} // Ok
+
+  ClassWithOwner &operator=(ClassWithOwner &&other) {
+    owner_var = other.owner_var; // Ok
+    return *this;
+  }
+
+  // Returning means, that the owner is "moved", so the class should not access this
+  // variable anymore after this method gets called.
+  gsl::owner<ArbitrayClass *> buggy_but_returns_owner() { return owner_var; }
+
+  gsl::owner<ArbitrayClass *> owner_var;
+};
+
+void test_class_with_owner() {
+  ArbitrayClass A;
+  ClassWithOwner C1; // Ok
+  ClassWithOwner C2{A}; // Bad, since the owner would be initialized with an nonowner, but catched in the class
+  ClassWithOwner C3{gsl::owner<ArbitrayClass *>(new ArbitrayClass)}; // Ok
+
+  const auto Owner1 = C3.buggy_but_returns_owner(); // BAD, deduces Owner1 to ArbitrayClass *const
+  // CHECK-MESSAGES: [[@LINE-1]]:3: note: type deduction did not result in an owner
+  // CHECK-MESSAGES: [[@LINE-2]]:3: warning: initializing non owner with a newly created owner/resource
+
+  auto Owner2 = C2.buggy_but_returns_owner(); // BAD, deduces Owner2 to ArbitrayClass *
+  // CHECK-MESSAGES: [[@LINE-1]]:3: note: type deduction did not result in an owner
+  // CHECK-MESSAGES: [[@LINE-2]]:3: warning: initializing non owner with a newly created owner/resource
+
+  Owner2 = &A; // Ok, since type deduction did NOT result in owner<int*>
+
+  gsl::owner<ArbitrayClass *> Owner3 = C1.buggy_but_returns_owner(); // Ok, still an owner
+  Owner3 = &A; // Bad, since assignment of nonowner to owner
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: assigning neither an owner nor a recognized resource
+}
+
+template <typename T>
+struct HeapArray { // Ok, since destructor with owner
+  HeapArray() : _data(nullptr), size(0) {} // Ok
+  HeapArray(int size) : _data(new int[size]), size(size) {} // Ok
+  HeapArray(int size, T val) {
+    _data = new int[size]; // Ok
+    size = size;
+    for (auto i = 0u; i < size; ++i)
+      _data[i] = val; // Ok
+  }
+  HeapArray(int size, T val, int *problematic) : _data{problematic}, size(size) {} // Bad
+  // CHECK-MESSAGES: [[@LINE-1]]:50: warning: initializing owner member variable neither with an owner nor a recognized resource
+
+  HeapArray(HeapArray &&other) : _data(other._data), size(other.size) { // Ok
+    other._data = nullptr; // Ok
+    other.size = 0;
+  }
+
+  HeapArray<T> &operator=(HeapArray<T> &&other) {
+    _data = other._data; // Ok, NOLINT warning here about bad types, why?
+    size = other.size;
+    return *this;
+  }
+
+  ~HeapArray() { delete[] _data; } // Ok
+
+  T *data() { return _data; } // Ok NOLINT, because it "looks" like a factory
+
+  gsl::owner<T *> _data;
+  unsigned int size;
+};
+
+void test_inner_template() {
+  HeapArray<int> Array1;
+  HeapArray<int> Array2(100);
+  HeapArray<int> Array3(100, 0);
+
+  Array1 = static_cast<HeapArray<int> &&>(Array2);
+  HeapArray<int> Array4(static_cast<HeapArray<int> &&>(Array3));
+
+  int *NonOwningPtr = Array1.data(); // Ok
+  gsl::owner<int *> OwningPtr = Array1.data(); // Bad, since it does not return the owner
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing neither with an owner nor a recognized resource
+}
+
+class DefaultedDestructor { // Bad since default constructor with owner
+  // CHECK-MESSAGES: [[@LINE+3]]:3: note: declared owner here
+  // CHECK-MESSAGES: [[@LINE-2]]:1: warning: class with an owner as member but without declared destructor to release the owner
+  ~DefaultedDestructor() = default; // Bad, since will not destroy the owner
+  gsl::owner<int *> Owner;
+};
+
+// FIXME Typededuction removes the owner - wrapper, therefore gsl::owner can not be used
+// with Template classes like this. Is there a walkaround?
+template <typename T>
+struct TemplateValue {
+  TemplateValue() = default;
+  TemplateValue(T t) : val{t} {}
+
+  void setVal(const T &t) { val = t; }
+  const T getVal() const { return val; }
+
+  T val;
+};
+
+// FIXME Same typededcution problems
+template <typename T>
+void template_function(T t) {
+  gsl::owner<int *> owner_t = t; // Probably bad, since typededuction still wrong
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing neither with an owner nor a recognized resource
+}
+
+// FIXME Same typededcution problems
+void test_templates() {
+  int stack_int = 42;
+  int *stack_ptr1 = &stack_int;
+
+  TemplateValue<gsl::owner<int *>> Owner0; // Ok, T should be owner, but is int*
+
+  TemplateValue<gsl::owner<int *>> Owner1(new int(42)); // Ok, T should be owner, but is int*
+  Owner1.setVal(&stack_int); // Bad since non owner assignment
+  Owner1.setVal(stack_ptr1); // Bad since non owner assignment
+  //Owner1.setVal(new int(42)); // Ok, but since typededuction is wrong, this one is considered harmfull
+
+  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
+}