[analyzer][NFC] Add tests for D132236

[tomasz-kaminski-sonarsource]

Summary

D132236 would have introduced regressions in the symbol lifetime
handling. However, the testsuite did not catch this, so here we have
some tests, which would have break if D132236 had landed.

This patch addresses the comment https://reviews.llvm.org/D132236#3753238

Co-authored-by: Balazs Benics <[e-mail]>

[tomasz-kaminski-sonarsource]

Added new line

[martong]

Thank you! Increasing coverage in tests is always great.

clang/test/Analysis/NewDeleteLeaks.cpp

196

Could you please add some explanation for the test case? Thinking of the related patch, something like this could be a good explanation:

Check that memory leak is reported against a symbol if the last place it's mentioned is a base region of a lazy compound value, as the program cannot possibly free that memory.

And below, we should mention that p is that symbol and p->data is the lazy compound value.

clang/test/Analysis/symbol-reaper-lambda.cpp

9

Maybe it is just me, but this test case is a bit hard to follow. I guess it is a result of creduce. But still, could you please elaborate the following:

1. What is the lazy compound value? (My weak guess is param)
2. What is the base region?
3. Which symbol is being reaped and where?

15

Did D132236 produce an FP warning for this?

[tomasz-kaminski-sonarsource]

Added requested comment for the example.
Included additional false-positive test.

[tomasz-kaminski-sonarsource]

clang/test/Analysis/symbol-reaper-lambda.cpp

15

Yes, it created false-positive for ref_capture load producing initialized value.

[martong]

Thanks for the update! LGTM.

clang/test/Analysis/trivial-copy-struct.cpp

57 ↗

(On Diff #464657)

clang/test/Analysis/NewDeleteLeaks.cpp

 void use_ret() {
   char *v;
   v = malloc_wrapper_ret(); // expected-note {{Calling 'malloc_wrapper_ret'}}
                             // expected-note@-1 {{Returned allocated memory}}
 } // expected-warning {{Potential leak of memory pointed to by 'v' [unix.Malloc]}}
 // expected-note@-1 {{Potential leak of memory pointed to by 'v'}}
 
 } // namespace refkind_from_unoallocated_to_allocated
+
+namespace symbol_reaper_lifetime {
+struct Nested {
+  int buf[2];
+};
+struct Wrapping {
+  Nested data;
+};
+
+Nested allocateWrappingAndReturnNested() {
+  // expected-note@+1 {{Memory is allocated}}
+  Wrapping const* p = new Wrapping();
+  // expected-warning@+2 {{Potential leak of memory pointed to by 'p'}}
+  // expected-note@+1    {{Potential leak of memory pointed to by 'p'}}
+  return p->data;
+}
+
+void caller() {
+  // expected-note@+1 {{Calling 'allocateWrappingAndReturnNested'}}
+  Nested n = allocateWrappingAndReturnNested();
+  (void)n;
+} // no-warning: No potential memory leak here, because that's been already reported.
+} // namespace symbol_reaper_lifetime

clang/test/Analysis/symbol-reaper-lambda.cpp

+// RUN: %clang_analyze_cc1 -analyzer-checker=core -verify %s
+// expected-no-diagnostics
+
+template <typename... Ts>
+void escape(Ts&...);
+struct Dummy {};
+
+int strange(Dummy param) {
+  Dummy local_pre_lambda;
+  int ref_captured = 0;
+
+  auto fn = [&] {
+    escape(param, local_pre_lambda);
+    return ref_captured; // no-warning: The value is not garbage.
+  };
+
+  int local_defined_after_lambda; // Unused, but necessary! Important that it's before the call.
+  return fn();
+}
 No newline at end of file