Fix support for recursive constraints in iftype conditions.

By defining the shadowing TK_TYPEPARAM on the entire iftype clause, which
contains both the constraint and the body, the appropriate definition
of the type variable is used when it appears in the constraint.

Fixes #1960

src/libponyc/pass/scope.c

@@ -203,22 +203,22 @@ static ast_result_t scope_iftype_clause(pass_opt_t* opt, ast_t* ast)
 {
   pony_assert(ast_id(ast) == TK_IFTYPE_CLAUSE);
 
-  AST_GET_CHILDREN(ast, subtype, supertype, body);
+  AST_GET_CHILDREN(ast, subtype, supertype);
 
   ast_t* typeparams = ast_from(ast, TK_TYPEPARAMS);
 
   switch(ast_id(subtype))
   {
     case TK_NOMINAL:
     {
-      ast_t* typeparam = make_iftype_typeparam(opt, subtype, supertype, body);
+      ast_t* typeparam = make_iftype_typeparam(opt, subtype, supertype, ast);
       if(typeparam == NULL)
       {
         ast_free_unattached(typeparams);
         return AST_ERROR;
       }
 
-      if(!set_scope(opt, body, ast_child(typeparam), typeparam, true))
+      if(!set_scope(opt, ast, ast_child(typeparam), typeparam, true))
       {
         ast_free_unattached(typeparams);
         return AST_ERROR;
@@ -253,14 +253,14 @@ static ast_result_t scope_iftype_clause(pass_opt_t* opt, ast_t* ast)
       while(sub_child != NULL)
       {
         ast_t* typeparam = make_iftype_typeparam(opt, sub_child, super_child,
-          body);
+          ast);
         if(typeparam == NULL)
         {
           ast_free_unattached(typeparams);
           return AST_ERROR;
         }
 
-        if(!set_scope(opt, body, ast_child(typeparam), typeparam, true))
+        if(!set_scope(opt, ast, ast_child(typeparam), typeparam, true))
         {
           ast_free_unattached(typeparams);
           return AST_ERROR;

test/libponyc/iftype.cc

@@ -274,6 +274,57 @@ TEST_F(IftypeTest, UnconstrainedTypeparam)
   TEST_COMPILE(src);
 }
 
+TEST_F(IftypeTest, RecursiveConstraint)
+{
+  const char* src =
+    "trait T[X: T[X] #any]\n"
+    "  fun tag m(): X\n"
+
+    "class val C is T[C]\n"
+    "  fun tag m(): C => C.create()\n"
+
+    "actor Main\n"
+    "  new create(env: Env) =>\n"
+    "    foo[C](C)\n"
+
+    "  fun foo[A](x': A) =>\n"
+    "    var x = x'\n"
+    "    iftype A <: T[A] then\n"
+    "      x = x.m()\n"
+    "    end";
+
+  TEST_COMPILE(src);
+}
+
+
+TEST_F(IftypeTest, Tuple_MutuallyRecursiveConstraint)
+{
+  const char* src =
+    "trait T[X]\n"
+    "  fun tag m(): X\n"
+
+    "class val C is T[D]\n"
+    "  fun tag m(): D => D.create()\n"
+
+    "class val D is T[C]\n"
+    "  fun tag m(): C => C.create()\n"
+
+    "actor Main\n"
+    "  new create(env: Env) =>\n"
+    "    foo[C,D](C, D)\n"
+
+    "  fun foo[A, B](x': A, y': B) =>\n"
+    "    var x = x'\n"
+    "    var y = y'\n"
+    "    iftype (A, B) <: (T[B], T[A]) then\n"
+    "      x = y.m()\n"
+    "      y = x.m()\n"
+    "    end";
+
+  TEST_COMPILE(src);
+}
+
+
 TEST_F(IftypeTest, NestedCond)
 {
   const char* src =