Auto-recover constructor expressions

.release-notes/4124.md

@@ -0,0 +1,22 @@
+## Allow constructor expressions to be auto-recovered in assignments or arguments
+
+Previously for the following code:
+
+```pony
+actor Main
+  new create(env: Env) =>
+    Bar.take_foo(Foo(88))
+    let bar: Foo iso = Foo(88)
+
+class Foo
+  new create(v: U8) =>
+    None
+
+primitive Bar
+  fun take_foo(foo: Foo iso) =>
+    None
+```
+
+You'd get compilation errors "argument not assignable to parameter" and "right side must be a subtype of left side" for the two lines in `Main.create()`.
+
+We've added checks to see if the constructor expressions can be implicitly auto-recovered, and if they can, no compilation error is generated.

src/libponyc/expr/call.c

@@ -194,6 +194,51 @@ static bool apply_default_arg(pass_opt_t* opt, ast_t* param, ast_t** argp)
   return true;
 }
 
+static ast_t* method_receiver_type(ast_t* method);
+
+bool check_auto_recover_newref(ast_t* ast)
+{
+  while (ast != NULL && ast_id(ast) != TK_CALL)
+    ast = ast_child(ast);
+
+  if (ast == NULL)
+    return false;
+
+  AST_GET_CHILDREN(ast, newref, positional, named);
+  if (ast_id(newref) != TK_NEWREF)
+    return false;
+
+  // sometimes newrefs are nested?
+  ast_t* child = ast_child(newref);
+  if (child != NULL && ast_id(child) == TK_NEWREF)
+    newref = child;
+
+  ast_t* receiver_type = method_receiver_type(newref);
+
+  ast_t* arg = ast_child(positional);
+  while (arg != NULL)
+  {
+    ast_t* arg_type = ast_type(arg);
+    if (is_typecheck_error(arg_type))
+      return false;
+
+    ast_t* arg_type_aliased = alias(arg_type);
+    bool ok = safe_to_autorecover(receiver_type, arg_type_aliased, WRITE);
+    ast_free_unattached(arg_type_aliased);
+
+    if (!ok)
+      return false;
+
+    arg = ast_sibling(arg);
+  }
+
+  token_id tcap = ast_id(cap_fetch(receiver_type));
+  if (tcap == TK_REF || tcap == TK_BOX)
+    return true;
+
+  return false;
+}
+
 static bool check_arg_types(pass_opt_t* opt, ast_t* params, ast_t* positional,
   bool partial)
 {
@@ -235,8 +280,16 @@ static bool check_arg_types(pass_opt_t* opt, ast_t* params, ast_t* positional,
       return false;
     }
 
-    ast_t* wp_type = consume_type(p_type, TK_NONE, false);
     errorframe_t info = NULL;
+    ast_t* wp_type;
+    if(check_auto_recover_newref(arg))
+    {
+      wp_type = unisolated(p_type);
+    }
+    else
+    {
+      wp_type = consume_type(p_type, TK_NONE, false);
+    }
 
     if(wp_type == NULL)
     {

src/libponyc/expr/call.h

@@ -8,6 +8,7 @@
 PONY_EXTERN_C_BEGIN
 
 bool method_check_type_params(pass_opt_t* opt, ast_t** astp);
+bool check_auto_recover_newref(ast_t* ast);
 
 bool expr_call(pass_opt_t* opt, ast_t** astp);
 

src/libponyc/expr/operator.c

@@ -3,6 +3,7 @@
 #include "postfix.h"
 #include "control.h"
 #include "reference.h"
+#include "call.h"
 #include "../ast/astbuild.h"
 #include "../ast/id.h"
 #include "../ast/lexer.h"
@@ -373,7 +374,16 @@ bool expr_assign(pass_opt_t* opt, ast_t* ast)
 
     default: {}
   }
-  ast_t* wl_type = consume_type(fl_type, TK_NONE, false);
+
+  ast_t* wl_type;
+  if(check_auto_recover_newref(right))
+  {
+    wl_type = unisolated(fl_type);
+  }
+  else
+  {
+    wl_type = consume_type(fl_type, TK_NONE, false);
+  }
 
   // Assignment is based on the alias of the right hand side.
   errorframe_t info = NULL;

src/libponyc/type/cap.c

@@ -1012,15 +1012,13 @@ bool cap_immutable_or_opaque(token_id cap)
   return false;
 }
 
-
-
 static ast_t* modified_cap_single(ast_t* type, cap_mutation* mutation)
 {
   ast_t* cap = cap_fetch(type);
   ast_t* ephemeral = ast_sibling(cap);
 
   token_id cap_token = ast_id(cap);
-  token_id eph_token = ast_id(cap);
+  token_id eph_token = ast_id(ephemeral);
 
   if (mutation(&cap_token, &eph_token))
   {
@@ -1153,4 +1151,3 @@ ast_t* unisolated(ast_t* type)
 {
   return modified_cap(type, unisolated_mod);
 }
-

test/libponyc-run/ctor-autorecover/main.pony

@@ -0,0 +1,12 @@
+actor Main
+  new create(env: Env) =>
+    Bar.take_foo(Foo(88))
+    let bar: Foo iso = Foo(88)
+
+class Foo
+  new create(v: U8) =>
+    None
+
+primitive Bar
+  fun take_foo(foo: Foo iso) =>
+    None