Resolve a default against the parameter list it is written in

A default is read where the parameters are, so its names resolve against
the parameter list before the declarations around it. The first cut
rendered a default as a type and stopped there, which left three ways for
one to reach something other than the Rust it came from. All three are the
same missing step, so `resolve_defaults` now makes it once, next to the
`TsTypeParam` it settles, for the derive and `#[declare]` alike.

**A type whose TypeScript name a parameter has taken.** The check only
judged refs whose source is `TypeParam`, so a concrete type went through
unexamined:

    struct Later<U = crate::T, T = String>    // export interface Later<U = T, T = string>
    struct Earlier<T, U = crate::T>           // export interface Earlier<T, U = T>

`crate::T` loses its qualification when it renders. `Later` is a `TS2744` --
a default may only name a parameter declared before it -- and `Earlier` is
worse, because it compiles and `T` now means the parameter. Neither can be
spelled around inside a parameter list, where a parameter shadows, so the
default goes and the trailing-run rule takes the defaults before it.

**A default inside a namespace.** The alias collection and `prefix_type_refs`
walked `type_ann` and nothing else, so a default was left to resolve against
the namespace it is printed in:

    enum Outcome<T = crate::Error> { Done(T), Error(String) }

`Outcome.Done`'s `T` meant the sibling variant rather than the interface --
nothing in the declaration is a syntax error, so it surfaced only where the
two met. A default is collected and rewritten like any other reference now,
and reaches the same `__OutcomeError` alias.

**A renamed declaration named in a default** is not fixed here, and is not
particular to defaults: a field of the same type emits the same dangling
`Original`, which is #103. Both are pinned side by side so the day #103
lands, they move together. `#[tsify(type_params = "T = Renamed")]` says it
in the meantime.

The e2e crate follows #111's shape -- one source built under both features,
since a default renders like any other type and `Option` and `HashMap`
inside one move with the feature. It also records what a default does to
#76: the signature still loses its argument, and `Wrapper` now resolves
through the default rather than failing, so that line should change when #76
is fixed.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: Timo Lehnertz

CHANGELOG.md

@@ -2,7 +2,8 @@
 
 ## Unreleased
 
-- **A default type parameter is now declared with its default.** `struct Foo<T = bool>(T)` declared `export type Foo<T> = T;` and now declares `export type Foo<T = boolean> = T;`, the same for interfaces, enums and `#[declare]` aliases. **Your `.d.ts` changes if you use one.** A default that cannot be honoured is dropped: one naming a parameter no field mentions, and then every default before it, since TypeScript only allows them on a trailing run
+- **A default type parameter is now declared with its default.** `struct Foo<T = bool>(T)` declared `export type Foo<T> = T;` and now declares `export type Foo<T = boolean> = T;`, the same for interfaces, enums and `#[declare]` aliases. **Your `.d.ts` changes if you use one.**
+- A default is read where the parameters are, so a name in it resolves against the parameter list before the declarations around it. One that would land somewhere other than the Rust says is dropped — naming a parameter that is declared nowhere or declared after it, or a type whose name a parameter has taken — and so is every default before it, since TypeScript only allows them on a trailing run. Inside `#[tsify(namespace)]`, a default is rewritten to the hoisted alias like any other reference, so a sibling variant cannot capture it
 - While [#76](https://github.com/madonoharu/tsify/issues/76) is open this makes it quieter — `fn bar(foo: Ts<Foo<i64>>)` still writes `bar(foo: Foo)`, which the default now resolves to `Foo<boolean>` rather than raising `TS2314`
 
 ## v0.5.8

tests-e2e/reference_output/test_defaults1/test_defaults1.d.ts

@@ -1,5 +1,13 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * A default is rendered like any other type, so the feature moves it.
+ */
+export interface Rendered<T = number | null, U = Record<string, number>> {
+    t: T;
+    u: U;
+}
+
 /**
  * A reference names its argument, whatever the declaration defaults to.
  */
@@ -8,16 +16,56 @@ export interface Holder {
     outcome: Outcome<number>;
 }
 
-declare namespace Outcome {
-    export type Done<T = string> = { Done: T };
-    export type Failed = { Failed: number };
+/**
+ * A type of our own whose TypeScript name the parameter lists below also use.
+ */
+export interface T {
+    z: number;
 }
 
-export type Outcome<T = string> = Outcome.Done<T> | Outcome.Failed;
+/**
+ * Accepted by TypeScript, but `T` there means the parameter and not the
+ * interface — the same default reading as a different type.
+ */
+export interface Earlier<T, U> {
+    t: T;
+    u: U;
+}
+
+/**
+ * TypeScript reads the `T` in `U`'s default as the parameter declared after
+ * it, and rejects that outright as `TS2744`.
+ */
+export interface Later<U, T = string> {
+    u: U;
+    t: T;
+}
+
+export interface Error {
+    m: string;
+}
 
 export interface Wrapper<T = number> {
     value: T;
 }
 
+type __OutcomeError = Error;
+/**
+ * Read from inside the namespace, `Error` would reach the sibling variant. The
+ * alias the namespace hoists its other references to is what it resolves to.
+ */
+declare namespace Outcome {
+    export type Done<T = __OutcomeError> = { Done: T };
+    export type Error = { Error: string };
+}
+
+/**
+ * Read from inside the namespace, `Error` would reach the sibling variant. The
+ * alias the namespace hoists its other references to is what it resolves to.
+ */
+export type Outcome<T = Error> = Outcome.Done<T> | Outcome.Error;
+
 
 export function into_js(): Holder;
+
+export function wrapped(v: Wrapper): void;

tests-e2e/reference_output/test_defaults_js1/test_defaults_js1.d.ts

@@ -0,0 +1,71 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * A default is rendered like any other type, so the feature moves it.
+ */
+export interface Rendered<T = number | undefined, U = Map<string, number>> {
+    t: T;
+    u: U;
+}
+
+/**
+ * A reference names its argument, whatever the declaration defaults to.
+ */
+export interface Holder {
+    wrapped: Wrapper<number>;
+    outcome: Outcome<number>;
+}
+
+/**
+ * A type of our own whose TypeScript name the parameter lists below also use.
+ */
+export interface T {
+    z: number;
+}
+
+/**
+ * Accepted by TypeScript, but `T` there means the parameter and not the
+ * interface — the same default reading as a different type.
+ */
+export interface Earlier<T, U> {
+    t: T;
+    u: U;
+}
+
+/**
+ * TypeScript reads the `T` in `U`'s default as the parameter declared after
+ * it, and rejects that outright as `TS2744`.
+ */
+export interface Later<U, T = string> {
+    u: U;
+    t: T;
+}
+
+export interface Error {
+    m: string;
+}
+
+export interface Wrapper<T = number> {
+    value: T;
+}
+
+type __OutcomeError = Error;
+/**
+ * Read from inside the namespace, `Error` would reach the sibling variant. The
+ * alias the namespace hoists its other references to is what it resolves to.
+ */
+declare namespace Outcome {
+    export type Done<T = __OutcomeError> = { Done: T };
+    export type Error = { Error: string };
+}
+
+/**
+ * Read from inside the namespace, `Error` would reach the sibling variant. The
+ * alias the namespace hoists its other references to is what it resolves to.
+ */
+export type Outcome<T = Error> = Outcome.Done<T> | Outcome.Error;
+
+
+export function into_js(): Holder;
+
+export function wrapped(v: Wrapper): void;

tests-e2e/test_defaults1/Cargo.toml

@@ -13,6 +13,11 @@ serde_json = "1.0"
 [dev-dependencies]
 wasm-bindgen-test = "0.3"
 
+# `test_defaults_js1` shares this crate's `entry_point.rs` and turns this
+# on. Declared here as well so the `cfg` in the shared source is known to both.
+[features]
+js = ["tsify/js"]
+
 [lib]
 path = "entry_point.rs"
 crate-type = ["cdylib"]

tests-e2e/test_defaults1/entry_point.rs

@@ -1,7 +1,20 @@
 //! A default type parameter is declared with its default.
-#![allow(deprecated)]
+//!
+//! This file is built twice: here with the default features, and by
+//! `test_defaults_js1`, which points its `[lib] path` at it and turns on `js`.
+//! The pair of reference outputs is what that feature changes — a default is
+//! rendered like any other type, so `Option` and `HashMap` inside one move with
+//! it.
+//!
+//! A default is read where the parameters are, so a name in it resolves against
+//! the parameter list before the declarations around it. The cases below are
+//! the ones where those two disagree.
+#![allow(deprecated, dead_code)]
+
+use std::collections::HashMap;
 
 use serde::{Deserialize, Serialize};
+use tsify::Ts;
 use tsify::Tsify;
 use wasm_bindgen::prelude::*;
 
@@ -10,11 +23,47 @@ pub struct Wrapper<T = i32> {
     value: T,
 }
 
+/// A default is rendered like any other type, so the feature moves it.
+#[derive(Tsify, Serialize, Deserialize)]
+pub struct Rendered<T = Option<u32>, U = HashMap<String, u32>> {
+    t: T,
+    u: U,
+}
+
+/// A type of our own whose TypeScript name the parameter lists below also use.
+#[derive(Tsify, Serialize, Deserialize)]
+pub struct T {
+    z: u32,
+}
+
+/// TypeScript reads the `T` in `U`'s default as the parameter declared after
+/// it, and rejects that outright as `TS2744`.
+#[derive(Tsify, Serialize, Deserialize)]
+pub struct Later<U = crate::T, T = String> {
+    u: U,
+    t: T,
+}
+
+/// Accepted by TypeScript, but `T` there means the parameter and not the
+/// interface — the same default reading as a different type.
+#[derive(Tsify, Serialize, Deserialize)]
+pub struct Earlier<T, U = crate::T> {
+    t: T,
+    u: U,
+}
+
+#[derive(Tsify, Serialize, Deserialize)]
+pub struct Error {
+    m: String,
+}
+
+/// Read from inside the namespace, `Error` would reach the sibling variant. The
+/// alias the namespace hoists its other references to is what it resolves to.
 #[derive(Tsify, Serialize, Deserialize)]
 #[tsify(namespace)]
-pub enum Outcome<T = String> {
+pub enum Outcome<T = crate::Error> {
     Done(T),
-    Failed(u32),
+    Error(String),
 }
 
 /// A reference names its argument, whatever the declaration defaults to.
@@ -29,6 +78,18 @@ pub struct Holder {
 pub fn into_js() -> Holder {
     Holder {
         wrapped: Wrapper { value: 0 },
-        outcome: Outcome::Failed(0),
+        outcome: Outcome::Done(0),
     }
 }
+
+// This records #76 the way the `test_generic_args1` references do, and what a
+// default does to it: the signature loses its argument, and `Wrapper` then
+// resolves through the default to `Wrapper<number>` rather than failing. The
+// Rust is `Wrapper<u32>`, so the two agree here only by accident of `i32` and
+// `u32` sharing a TypeScript name. This line should name its argument when #76
+// is fixed.
+#[wasm_bindgen]
+pub fn wrapped(v: Ts<Wrapper<u32>>) -> Result<(), JsError> {
+    let _: Wrapper<u32> = v.to_rust()?;
+    Ok(())
+}

tests-e2e/test_defaults_js1/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "test_defaults_js1"
+publish = false
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+wasm-bindgen = "0.2"
+tsify = { path = "../..", version = "*" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+
+[dev-dependencies]
+wasm-bindgen-test = "0.3"
+
+# The same source as `test_defaults1`, built with `js` instead. The pair of
+# reference outputs is what that feature changes.
+[features]
+default = ["js"]
+js = ["tsify/js"]
+
+[lib]
+path = "../test_defaults1/entry_point.rs"
+crate-type = ["cdylib"]
+
+[build-dependencies]
+wasm-bindgen-cli = "0.2"