rsscript: generic type aliases expand at every comparison site

Type aliases were only resolved for `let` bindings, and only by exact name — so a
non-generic alias used as a parameter type (`xs: read IntList`) and any generic
alias (`Pair<Int>`) failed type comparison (RS0207).

Add `Analyzer::expand_type_alias`: it expands an alias reference (generic or not)
by looking up the alias root and substituting the reference's arguments for the
alias's parameters (via text_util::substitute_type_args), chasing the chain with a
depth bound. Applied at the call-argument, return, and binding comparison sites;
generic aliases now resolve as param/return/binding types.

Test: tests/fixtures/pass/type-alias-generic.rss (Pair<T>=Result<T,String>,
IntList=List<Int> across all positions). lib/frontend/lowering green.

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

Author: olwang

crates/rsscript/src/analyzer.rs

@@ -178,13 +178,22 @@ fn analyze_program(
         type_aliases.extend(type_aliases_from_program(interface));
     }
     type_aliases.extend(type_aliases_from_program(&syntax_program));
+    let mut type_alias_params = std::collections::BTreeMap::new();
+    for interface in builtin_interface_programs()
+        .iter()
+        .chain(interface_programs.iter())
+    {
+        type_alias_params.extend(type_alias_params_from_program(interface));
+    }
+    type_alias_params.extend(type_alias_params_from_program(&syntax_program));
     let mut analyzer = Analyzer {
         tokens: &tokens,
         syntax_program,
         interface_programs,
         hir,
         diagnostics: Vec::new(),
         type_aliases,
+        type_alias_params,
         in_task_group: false,
         async_let_names: Vec::new(),
     };
@@ -207,6 +216,28 @@ fn type_aliases_from_program(
     })
 }
 
+/// The generic parameter names of each type alias (`type Pair<T> = ...` → `T`),
+/// so generic aliases can be expanded by substituting arguments for parameters.
+fn type_alias_params_from_program(
+    program: &crate::syntax::ast::Program,
+) -> impl Iterator<Item = (String, Vec<String>)> + '_ {
+    use crate::syntax::ast::Item;
+    program.items.iter().filter_map(|item| {
+        if let Item::TypeAlias(alias) = item {
+            Some((
+                alias.name.clone(),
+                alias
+                    .type_params
+                    .iter()
+                    .map(|param| param.name.clone())
+                    .collect(),
+            ))
+        } else {
+            None
+        }
+    })
+}
+
 fn analyze_syntax_program(
     tokens: Vec<Token>,
     syntax_program: crate::syntax::ast::Program,
@@ -219,6 +250,7 @@ fn analyze_syntax_program(
         hir,
         diagnostics: Vec::new(),
         type_aliases: Default::default(),
+        type_alias_params: Default::default(),
         in_task_group: false,
         async_let_names: Vec::new(),
     };
@@ -251,6 +283,9 @@ pub(crate) struct Analyzer<'a> {
     pub(crate) hir: Hir,
     pub(crate) diagnostics: Vec<Diagnostic>,
     pub(crate) type_aliases: std::collections::BTreeMap<String, String>,
+    /// Type-alias name -> its generic parameter names (empty for non-generic
+    /// aliases), used to expand generic aliases like `Pair<Int>`.
+    pub(crate) type_alias_params: std::collections::BTreeMap<String, Vec<String>>,
     in_task_group: bool,
     pub(crate) async_let_names: Vec<String>,
 }
@@ -1039,6 +1074,40 @@ impl Analyzer<'_> {
         current
     }
 
+    /// Expand a type-alias reference, including generic aliases, to its target
+    /// type. `IntList` -> `List<Int>`; `Pair<Int>` -> `Result<Int, String>` for
+    /// `type Pair<T> = Result<T, String>`. Non-aliases pass through unchanged.
+    pub(crate) fn expand_type_alias(&self, type_name: &str) -> String {
+        use crate::text_util::{substitute_type_args, type_arg_names, type_root_name};
+        let mut current = type_name.trim().to_string();
+        for _ in 0..16 {
+            let root = type_root_name(&current);
+            let Some(target) = self.type_aliases.get(root) else {
+                break;
+            };
+            let params = self.type_alias_params.get(root).cloned().unwrap_or_default();
+            if params.is_empty() {
+                current = target.clone();
+            } else {
+                // Generic alias: substitute the reference's arguments for the
+                // alias's parameters. On arity mismatch, leave it for the normal
+                // type checks to report.
+                let Some(args) = type_arg_names(&current) else {
+                    break;
+                };
+                if args.len() != params.len() {
+                    break;
+                }
+                let subs: std::collections::HashMap<String, String> = params
+                    .into_iter()
+                    .zip(args.into_iter().map(str::to_string))
+                    .collect();
+                current = substitute_type_args(target, &subs);
+            }
+        }
+        current
+    }
+
     fn run(&mut self) {
         self.check_single_feature_declaration();
         self.check_unknown_file_features();

crates/rsscript/src/checks/calls.rs

@@ -357,8 +357,8 @@ fn check_binding_type(
     if unresolved_generic_type(actual) {
         return;
     }
-    let resolved_expected = analyzer.resolve_type_alias(expected).to_string();
-    let resolved_actual = analyzer.resolve_type_alias(actual).to_string();
+    let resolved_expected = analyzer.expand_type_alias(expected);
+    let resolved_actual = analyzer.expand_type_alias(actual);
     if json_value_accepts_literal(&resolved_expected, value) {
         return;
     }
@@ -723,7 +723,10 @@ fn check_return_expr_type(
     if check_list_literal_type(analyzer, &expected, value, "return value") {
         return;
     }
-    if !argument_type_matches(&expected, actual) {
+    if !argument_type_matches(
+        &analyzer.expand_type_alias(&expected),
+        &analyzer.expand_type_alias(actual),
+    ) {
         return_type_mismatch_diagnostic(analyzer, &function.name, actual, &expected, span);
     }
 }
@@ -1344,7 +1347,10 @@ fn check_call_args(
         if check_list_literal_type(analyzer, &expected_type, &arg.value, "argument") {
             continue;
         }
-        if !argument_type_matches(&expected_type, actual_type) {
+        if !argument_type_matches(
+            &analyzer.expand_type_alias(&expected_type),
+            &analyzer.expand_type_alias(actual_type),
+        ) {
             analyzer.diagnostics.push(
                 Diagnostic::error(
                     code::ARGUMENT_TYPE_MISMATCH,

crates/rsscript/tests/fixtures/pass/type-alias-generic.rss

@@ -0,0 +1,21 @@
+// Generic and non-generic type aliases expand at every type-comparison site —
+// parameter, return, and binding positions — including aliases that reference
+// imported/builtin generic types.
+
+type Pair<T> = Result<T, String>
+type IntList = List<Int>
+
+fn first_ok() -> fresh Pair<Int> {
+    return Ok(1)
+}
+
+fn count(xs: read IntList) -> Int {
+    return List.len(list: read xs)
+}
+
+fn main() -> Unit {
+    let p: Pair<Int> = first_ok()
+    let n: IntList = List.new<Int>()
+    Log.write(message: read String.from_int(value: count(xs: read n)))
+    return Unit
+}

docs/tinygrad-port-todo.md

@@ -7,17 +7,12 @@ aliasing, qualified `module.fn`/`.Type`/value access, `use module.*` glob,
 qualified variant patterns), pattern matching (variants/options/constants/tuples/
 lists), tuples & destructuring, `#lower_name` escape hatch, source-qualified
 symbol inventory, type-associated constants & static methods, value-semantics
-clone/derives, Option ergonomics (`?`-on-Option + combinators), and default
-parameters (Copy and non-Copy).
+clone/derives, Option ergonomics (`?`-on-Option + combinators), default
+parameters (Copy and non-Copy), and type aliases (generic + non-generic, expanded
+at every comparison site).
 
 ## Must unblock awkward valid ports
 
-- [ ] **Generic type aliases.** Basic `type X = Y` aliases work; add *generic*
-  aliases (`type Pair<T> = ...`) that can reference imported types and appear in
-  the symbol inventory as type-level symbols, without creating value-namespace
-  placeholders.
-  _Why:_ Python `TypeVar`/generic-alias symbols otherwise become dummy constants.
-
 - [ ] **Method/property lowering ergonomics.** Provide a simple way to model
   Python-style getter properties and method-like computed fields.
   _Why:_ tinygrad has many small property methods where the body is simple but the