fix: recognize last uses (including of this)

regression-tests/pure2-deducing-pointers-error.cpp2

@@ -28,11 +28,6 @@ main: () -> int = {
     pa5 := pppa**;
     pa5 = 0;      // caught
 
-    //  TODO: @filipsajdak please take a look
-    //  The bugfix in get_declaration_of(t) to add `&& ri->position() <= t.position()`
-    //  to the condition is correct; it fixes issue #669 by not looking past the first
-    //  declaration of the name in t. However, that change made the following two
-    //  "caught" cases no longer be caught.
     fun(a)++;     // caught
     fp := fun(a);
     fp = 0;       // caught

regression-tests/pure2-last-use.cpp2

@@ -0,0 +1,74 @@
+f_inout: (inout x: int) -> _ = {
+    x *= 2;
+    return x;
+}
+
+issue_350: () = {
+    x := 21;
+
+    l1 := :(forward x) = {
+        std::cout << f_inout(forward x) << std::endl;
+    };
+
+    l1(x);
+
+    x++;
+}
+
+issue_683: (args) = {
+    for args do (n) {
+        _ = n;
+    }
+
+    n: int;
+    n = 0;
+}
+
+issue_825: () = {
+  _ = :(copy b) _ = b;
+  _ = :(move c) _ = c;
+  _ = :(forward d) _ = d;
+}
+
+issue_832: () = {
+  i := 0;
+  while i { }
+}
+
+f_inout: (inout _: std::unique_ptr<int>) = { }
+f_copy: (copy _...) = { }
+
+issue_857: type = {
+  a: std::unique_ptr<int>;
+  b: std::unique_ptr<int>;
+  operator=: (out this, move that) = { }
+  operator=: (move this) = f_copy(a, this.b);
+  f: (move this) = f_copy(this);
+  f: (move this, move that) = f_copy(this, that);
+  g: (move this) = f_copy(this.a);
+  g: (move this, move that) = f_copy(this.a, that.a);
+  h: (inout this) = f_inout(a);
+  i: (move this) = f_copy(a);
+  j: (move this) = f_copy(a);
+  k: (move this) = f_copy(a, b);
+}
+
+issue_857_2: @struct type = {
+  a: std::unique_ptr<int>; // OK: No error about 'a' being unused.
+}
+
+gi: int = 0;
+issue_857_3: @struct type = {
+  i: std::add_lvalue_reference_t<int> = gi;
+  f: (move this) = _ = f_inout(i);
+}
+
+//draw: () = {
+//  pos       := 0;
+//  vertex    := :(_) = { };
+//  _ = (pos).vertex();
+//}
+
+main: (args) = {
+  issue_683(args);
+}

regression-tests/test-results/pure2-deducing-pointers-error.cpp2.output

@@ -5,5 +5,8 @@ pure2-deducing-pointers-error.cpp2(20,9): error: = - pointer assignment from nul
 pure2-deducing-pointers-error.cpp2(21,9): error: += - pointer assignment from null or integer is illegal
 pure2-deducing-pointers-error.cpp2(25,9): error: = - pointer assignment from null or integer is illegal
 pure2-deducing-pointers-error.cpp2(29,9): error: = - pointer assignment from null or integer is illegal
+pure2-deducing-pointers-error.cpp2(31,11): error: ++ - pointer arithmetic is illegal - use std::span or gsl::span instead
+pure2-deducing-pointers-error.cpp2(33,8): error: = - pointer assignment from null or integer is illegal
   ==> program violates lifetime safety guarantee - see previous errors
+  ==> program violates bounds safety guarantee - see previous errors
 

regression-tests/test-results/pure2-last-use.cpp

@@ -0,0 +1,155 @@
+
+#define CPP2_IMPORT_STD          Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+#line 1 "pure2-last-use.cpp2"
+
+#line 41 "pure2-last-use.cpp2"
+class issue_857;
+
+
+#line 56 "pure2-last-use.cpp2"
+class issue_857_2;
+
+
+#line 61 "pure2-last-use.cpp2"
+class issue_857_3;
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+#line 1 "pure2-last-use.cpp2"
+[[nodiscard]] auto f_inout(int& x) -> auto;
+
+#line 6 "pure2-last-use.cpp2"
+auto issue_350() -> void;
+
+#line 18 "pure2-last-use.cpp2"
+auto issue_683(auto const& args) -> void;
+
+#line 27 "pure2-last-use.cpp2"
+auto issue_825() -> void;
+
+#line 33 "pure2-last-use.cpp2"
+auto issue_832() -> void;
+
+#line 38 "pure2-last-use.cpp2"
+auto f_inout([[maybe_unused]] std::unique_ptr<int>& unnamed_param_1) -> void;
+auto f_copy([[maybe_unused]] auto ...unnamed_param_1) -> void;
+
+class issue_857 {
+  private: std::unique_ptr<int> a; 
+  private: std::unique_ptr<int> b; 
+  public: issue_857(issue_857&& that) noexcept;
+#line 44 "pure2-last-use.cpp2"
+  public: auto operator=(issue_857&& that) noexcept -> issue_857& ;
+  public: ~issue_857() noexcept;
+  public: auto f() && -> void;
+  public: auto f(issue_857&& that) && -> void;
+  public: auto g() && -> void;
+  public: auto g(issue_857&& that) && -> void;
+  public: auto h() & -> void;
+  public: auto i() && -> void;
+  public: auto j() && -> void;
+  public: auto k() && -> void;
+};
+
+class issue_857_2 {
+  public: std::unique_ptr<int> a; // OK: No error about 'a' being unused.
+};
+
+extern int gi;
+class issue_857_3 {
+  public: std::add_lvalue_reference_t<int> i {gi}; 
+  public: auto f() && -> void;
+};
+
+//draw: () = {
+//  pos       := 0;
+//  vertex    := :(_) = { };
+//  _ = (pos).vertex();
+//}
+
+auto main(int const argc_, char** argv_) -> int;
+
+//=== Cpp2 function definitions =================================================
+
+#line 1 "pure2-last-use.cpp2"
+[[nodiscard]] auto f_inout(int& x) -> auto{
+#line 2 "pure2-last-use.cpp2"
+    x *= 2;
+    return x; 
+}
+
+auto issue_350() -> void{
+    auto x {21}; 
+
+    auto l1 {[](auto&& x) mutable -> void{
+        std::cout << f_inout(CPP2_FORWARD(x)) << std::endl;
+    }}; 
+
+    std::move(l1)(x);
+
+    ++x;
+}
+
+auto issue_683(auto const& args) -> void{
+    for ( auto const& n : args ) {
+        static_cast<void>(n);
+    }
+
+    cpp2::deferred_init<int> n; 
+    n.construct(0);
+}
+
+auto issue_825() -> void{
+  static_cast<void>([](auto b) mutable -> auto { return static_cast<void>(std::move(b));  });
+  static_cast<void>([](auto&& c) mutable -> auto { return static_cast<void>(std::move(c));  });
+  static_cast<void>([](auto&& d) mutable -> auto { return static_cast<void>(CPP2_FORWARD(d));  });
+}
+
+auto issue_832() -> void{
+  auto i {0}; 
+  while( i ) {}
+}
+
+auto f_inout([[maybe_unused]] std::unique_ptr<int>& unnamed_param_1) -> void{}
+auto f_copy([[maybe_unused]] auto ...unnamed_param_1) -> void{}
+
+#line 44 "pure2-last-use.cpp2"
+  issue_857::issue_857(issue_857&& that) noexcept
+                                       : a{ std::move(that).a }
+                                       , b{ std::move(that).b }{}
+#line 44 "pure2-last-use.cpp2"
+  auto issue_857::operator=(issue_857&& that) noexcept -> issue_857& {
+                                       a = std::move(that).a;
+                                       b = std::move(that).b;
+                                       return *this; }
+#line 45 "pure2-last-use.cpp2"
+  issue_857::~issue_857() noexcept { f_copy(std::move(*this).a, std::move((*this)).b);  }
+  auto issue_857::f() && -> void { f_copy(std::move((*this)));  }
+  auto issue_857::f(issue_857&& that) && -> void { f_copy(std::move((*this)), std::move(that));  }
+  auto issue_857::g() && -> void { f_copy(std::move((*this)).a);  }
+  auto issue_857::g(issue_857&& that) && -> void { f_copy(std::move((*this)).a, std::move(that).a);  }
+  auto issue_857::h() & -> void { f_inout(a);  }
+  auto issue_857::i() && -> void { f_copy(std::move(*this).a);  }
+  auto issue_857::j() && -> void { f_copy(std::move(*this).a);  }
+  auto issue_857::k() && -> void { f_copy(std::move(*this).a, std::move(*this).b);  }
+
+#line 60 "pure2-last-use.cpp2"
+int gi {0}; 
+
+#line 63 "pure2-last-use.cpp2"
+  auto issue_857_3::f() && -> void { static_cast<void>(f_inout(std::move(*this).i));  }
+
+#line 72 "pure2-last-use.cpp2"
+auto main(int const argc_, char** argv_) -> int{
+  auto const args = cpp2::make_args(argc_, argv_); 
+#line 73 "pure2-last-use.cpp2"
+  issue_683(args);
+}
+

regression-tests/test-results/pure2-last-use.cpp2.output

@@ -0,0 +1,2 @@
+pure2-last-use.cpp2... ok (all Cpp2, passes safety checks)
+

regression-tests/test-results/pure2-types-inheritance.cpp

@@ -123,7 +123,7 @@ namespace N {
         std::cout << "printing: " + cpp2::to_string(name) + " lives at " + cpp2::to_string(address) + "\n";  }
 
     Cyborg::~Cyborg() noexcept { 
-        std::cout << "Tired but satisfied after another successful day, " + cpp2::to_string(name) + " checks out and goes home to their family\n";  }
+        std::cout << "Tired but satisfied after another successful day, " + cpp2::to_string(std::move(name)) + " checks out and goes home to their family\n";  }
 
 #line 38 "pure2-types-inheritance.cpp2"
 auto make_speak(cpp2::in<Human> h) -> void{

source/common.h

@@ -127,7 +127,7 @@ struct string_parts {
 
     string_parts(const std::string& beginseq,
                  const std::string& endseq,
-                 adds_sequences     strateg) 
+                 adds_sequences     strateg)
      : begin_seq{beginseq}
      , end_seq{endseq}
      , strategy{strateg}
@@ -144,16 +144,16 @@ struct string_parts {
     void clear() { parts.clear(); }
 
     auto generate() const -> std::string {
-        
-        if (parts.empty()) { 
-            return (strategy & on_the_beginning ? begin_seq : std::string{}) 
-                 + (strategy & on_the_end ? end_seq : std::string{}); 
+
+        if (parts.empty()) {
+            return (strategy & on_the_beginning ? begin_seq : std::string{})
+                 + (strategy & on_the_end ? end_seq : std::string{});
         }
 
-        auto result = std::visit(begin_visit{begin_seq, strategy}, 
+        auto result = std::visit(begin_visit{begin_seq, strategy},
                                  parts.front());
 
-        if (std::ssize(parts) > 1) { 
+        if (std::ssize(parts) > 1) {
             auto it1 = parts.cbegin();
             auto it2 = parts.cbegin()+1;
             for(;it2 != parts.cend(); ++it1, ++it2) {
@@ -918,7 +918,7 @@ class stackinstr
 
     static auto print(auto&& ee, std::string_view label) {
         std::cout << "\n=== Stack debug information: " << label << " stack ===\n";
-        for (auto& e: ee) 
+        for (auto& e: ee)
         if  (e.ptr) {
             std::cout
                 << "  " << std::setw(6)