Fix false positive in _final send checking for generic classes

The finalisers pass conservatively reports FINAL_MAY_SEND when it
encounters a method call on an unknown type. When _final calls a method
on a generic class instantiated with concrete type args (e.g.,
Generic[Prim]), the pass follows into the method body where expressions
still reference the generic type parameter A. Since A's constraint is a
trait, is_known(A) returns false and the pass reports a false positive.

Fix by reifying the method body with the entity's concrete type
arguments before analyzing it. This replaces type parameters with their
concrete types so is_known sees the actual type. The recursion guard is
set on the original body (not the reified copy) so that recursive
lookups correctly detect cycles.

Closes #4249

Author: SeanTAllen

.release-notes/fix-finaliser-generic-false-positive.md

@@ -0,0 +1,5 @@
+## Fix false positive in `_final` send checking for generic classes
+
+The compiler incorrectly rejected `_final` methods that called methods on generic classes instantiated with concrete type arguments. For example, calling a method on a `Generic[Prim]` where `Generic` has a trait-constrained type parameter would produce a spurious "_final cannot create actors or send messages" error, even though the concrete type is known and does not send messages.
+
+The finaliser pass now resolves generic type parameters to their concrete types before analyzing method bodies for potential message sends.

src/libponyc/pass/finalisers.c

@@ -126,7 +126,44 @@ static int check_call_send(ast_t* ast, bool in_final)
   pony_assert(fun != NULL);
 
   AST_GET_CHILDREN(fun, cap, id, typeparams, params, result, can_error, body);
-  int r = check_body_send(body, false);
+
+  // If the receiver type has type arguments and the entity has type parameters,
+  // reify the method body so generic type parameters are replaced with their
+  // concrete types. Without this, expressions like `_min.lt(_max)` inside
+  // `Range[USize]` have receiver type `A` (the type parameter), which fails
+  // is_known() and produces a false positive FINAL_MAY_SEND.
+  ast_t* reified_body = NULL;
+  int r;
+
+  if(ast_id(type) == TK_NOMINAL)
+  {
+    ast_t* typeargs = ast_childidx(type, 2);
+    ast_t* entity_typeparams = ast_childidx(def, 1);
+
+    if((ast_id(typeargs) == TK_TYPEARGS) &&
+      (ast_id(entity_typeparams) == TK_TYPEPARAMS))
+    {
+      reified_body = reify(body, entity_typeparams, typeargs, NULL, true);
+    }
+  }
+
+  if(reified_body != NULL)
+  {
+    // Set the recursion guard on the original body so that recursive calls
+    // (which look up the original, not the reified copy) see FINAL_RECURSE.
+    bool already_recursing = ast_checkflag(body, AST_FLAG_RECURSE_1);
+    if(!already_recursing)
+      ast_setflag(body, AST_FLAG_RECURSE_1);
+
+    r = check_body_send(reified_body, false);
+
+    if(!already_recursing)
+      ast_clearflag(body, AST_FLAG_RECURSE_1);
+
+    ast_free_unattached(reified_body);
+  } else {
+    r = check_body_send(body, false);
+  }
 
   if(r == FINAL_NO_SEND)
   {

test/libponyc/finalisers.cc

@@ -111,6 +111,53 @@ TEST_F(FinalisersTest, FinalCannotCallChainedBehaviour)
   TEST_ERRORS_1(src, "_final cannot create actors or send messages");
 }
 
+TEST_F(FinalisersTest, FinalCanCallMethodOnGenericClassWithConcreteTypeArgs)
+{
+  const char* src =
+    "trait Gettable\n"
+    "  fun get(): U32\n"
+    "primitive Prim is Gettable\n"
+    "  fun get(): U32 => 0\n"
+    "class Generic[A: Gettable val]\n"
+    "  let _value: A\n"
+    "  new val create(value: A) =>\n"
+    "    _value = value\n"
+    "  fun get(): U32 =>\n"
+    "    _value.get()\n"
+    "class Foo\n"
+    "  fun _final() =>\n"
+    "    Generic[Prim](Prim).get()";
+
+  TEST_COMPILE(src);
+}
+
+TEST_F(FinalisersTest, FinalCannotCallMethodOnGenericClassThatSends)
+{
+  // The send_msg method sends a message via a behavior call on an actor field.
+  // Even though Generic is instantiated with concrete type args (U32),
+  // the finaliser pass should still detect the send inside send_msg.
+  const char* src =
+    "actor Ping\n"
+    "  new create() => None\n"
+    "  be ping() => None\n"
+    "class Holder\n"
+    "  let _p: Ping\n"
+    "  new create(p: Ping) => _p = p\n"
+    "  fun get(): Ping => _p\n"
+    "class Generic[A]\n"
+    "  let _h: Holder\n"
+    "  new create(h: Holder) => _h = h\n"
+    "  fun send_msg() =>\n"
+    "    _h.get().ping()\n"
+    "class Foo\n"
+    "  let _g: Generic[U32]\n"
+    "  new create(h: Holder) => _g = Generic[U32](h)\n"
+    "  fun _final() =>\n"
+    "    _g.send_msg()";
+
+  TEST_ERRORS_1(src, "_final cannot create actors or send messages");
+}
+
 TEST_F(FinalisersTest, CannotLookupFinal)
 {
   const char* src =