Fix shadowing default method type parameters

When copying default methods to impls, rename type parameters of the
methods so that they won't be shadowed by the impl's type parameters.

For example, when copying this default method:

    trait Iterator[iter, item, exn]:
        map(self: iter, f: Fn(item) b / exn) Map[iter, item, b, exn]:
            ...

to impl:

    impl[Iterator[iter, a, exn]] Iterator[Map[iter, a, b, exn], b, exn]:
        ...

If we naively copy, we get:

    impl[Iterator[iter, a, exn]] Iterator[Map[iter, a, b, exn], b, exn]:
        # iter -> Map[iter, a, b, exn]
        # item -> b
        # exn -> exn
        map(self: Map[iter, a, b, exn], f: Fn(b) b / exn) Map[Map[iter, a, b, exn], b, b, exn]:
            Map(iter = self, f = f)

Note that the return type of the callback argument (originally `b`) is
still `b`, but `b` is now bound in impl head.

To fix, we rename type parameters of copied methods by adding a `$copy`
suffix. New copied method:

    impl[Iterator[iter, a, exn]] Iterator[Map[iter, a, b, exn], b, exn]:
        # iter -> Map[iter, a, b, exn]
        # item -> b
        # exn -> exn
        map(self: Map[iter, a, b, exn], f: Fn(b) b$copy / exn) Map[Map[iter, a, b, exn], b, b$copy, exn]:
            Map(iter = self, f = f)

Fixes #275.

Author: osa1

src/type_checker.rs

@@ -530,6 +530,27 @@ fn collect_cons(module: &mut ast::Module) -> TyMap {
 
             let mut impl_fun_decl = trait_method_decl.fun_decl.clone();
 
+            // Rename copied function's type parameters so that they won't be shadowed by the impl's
+            // type parameters.
+            let mut new_type_params: Vec<(Id, Kind)> =
+                Vec::with_capacity(impl_fun_decl.node.sig.context.type_params.len());
+
+            let renaming_substs: HashMap<Id, ast::Type> = impl_fun_decl
+                .node
+                .sig
+                .context
+                .type_params
+                .iter()
+                .map(|(ty_param, kind)| {
+                    let new_param = SmolStr::new(format!("{}$copy", ty_param));
+                    new_type_params.push((new_param.clone(), kind.clone()));
+                    (ty_param.clone(), ast::Type::Var(new_param))
+                })
+                .collect();
+
+            impl_fun_decl.node.sig.context.type_params = new_type_params;
+            impl_fun_decl.node.sig.subst_ty_ids(&renaming_substs);
+
             // Map type parameters of the trait to the impl types.
             let substs: HashMap<Id, ast::Type> = trait_type_params
                 .iter()
@@ -539,6 +560,7 @@ fn collect_cons(module: &mut ast::Module) -> TyMap {
 
             if let Some(body) = &mut impl_fun_decl.node.body {
                 for stmt in body {
+                    stmt.node.subst_ty_ids(&renaming_substs);
                     stmt.node.subst_ty_ids(&substs);
                 }
             }

tests/Issue275.fir

@@ -0,0 +1,8 @@
+# This program was compiled to ill-typed C because of a substitution bug when
+# copying default trait methods.
+
+main():
+    let vec: Vec[Str] = Vec.withCapacity(1)
+    let iter1 = vec.iter()
+    let iter2 = iter1.map(\(s: Str): u32(1))
+    let iter3 = iter2.map(\(n: U32): (key = n, val = ()))