fix(dts): follow alias chains of any length and keep U+2028 / U+2029 line breaks whole

An import-equals alias chain is followed until it ends, stopping only on a
cycle, instead of giving up after 16 aliases (`A17.T` through 18 aliases is
`T`, like ngtsc). Looking back for a `//` before a union now steps over a
U+2028 / U+2029 line break by its full UTF-8 length, where it used to slice
inside the character and panic.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: Brooooooklyn

crates/oxc_angular_compiler/src/directive/dts_type.rs

@@ -228,15 +228,22 @@ impl<'a> TypePrinter<'_, 'a> {
         'a: 'p,
     {
         let mut aliased = false;
-        // Aliases can name aliases; a cycle is a TypeScript error.
-        for _ in 0..16 {
+        // Aliases can name aliases, through any number of them. Meeting one
+        // again is a cycle (`import A = B; import B = A;`, `import A = A.B;`),
+        // which TypeScript reports.
+        let mut seen: std::vec::Vec<std::vec::Vec<&'p str>> = std::vec::Vec::new();
+        loop {
             let (len, target) = match self.scope.alias(parts[0]) {
                 Some(target) => (1, target),
                 None => match self.scope.namespace_alias(&parts) {
                     Some(found) => found,
                     None => return Some(Resolved::Name(parts, aliased)),
                 },
             };
+            if seen.iter().any(|alias| alias[..] == parts[..len]) {
+                return None;
+            }
+            seen.push(parts[..len].to_vec());
             aliased = true;
             match target {
                 // `import Core = require('@angular/core')`: `Core.X` is
@@ -252,7 +259,6 @@ impl<'a> TypePrinter<'_, 'a> {
                 }
             }
         }
-        None
     }
 
     /// [`Self::type_name`] for a name whose head isn't an alias: `parts`, head
@@ -703,7 +709,11 @@ fn token_end_before(source: &str, start: usize) -> Option<usize> {
         let before = &source[..end];
         let trimmed = before.trim_end();
         if before[trimmed.len()..].contains(is_line_break) {
-            let line_start = trimmed.rfind(is_line_break).map_or(0, |i| i + 1);
+            // After the line break, which can be more than one byte (U+2028).
+            let line_start = trimmed
+                .char_indices()
+                .rfind(|&(_, c)| is_line_break(c))
+                .map_or(0, |(i, c)| i + c.len_utf8());
             if trimmed[line_start..].contains("//") {
                 return None;
             }

crates/oxc_angular_compiler/tests/dts_input_transform_type_test.rs

@@ -83,6 +83,18 @@ const COMMENTS_NOT_KEPT: &[(&str, &str, &str)] = &[
     ("(x: string /** y */) => void", "(x: string /** y */) => void", "(x: string) => void"),
     ("Array<string /** y */>", "Array<string /** y */>", "Array<string>"),
     ("string |\n /** j */ number", "string | \n    /** j */ number", "string | number"),
+    // TypeScript reads past a U+2028 / U+2029 for the comments after `<` (it
+    // only stops at `\n` and `\r`), and prints this one twice.
+    (
+        "Array<\u{2028}/* c */\nstring | number>",
+        "Array</* c */ /* c */ string | number>",
+        "Array<string | number>",
+    ),
+    (
+        "Array<\u{2029}/* c */\nstring | number>",
+        "Array</* c */ /* c */ string | number>",
+        "Array<string | number>",
+    ),
 ];
 
 #[test]
@@ -302,6 +314,31 @@ export class Dir {{
     );
 }
 
+/// A chain of aliases is followed to its end however long it is: ngtsc 22.1.7
+/// writes `T` for `A17.T` through 18 aliases, and `T | number` through 40. A
+/// cycle (a TypeScript error, on which ngtsc throws) gives `unknown`.
+#[test]
+fn import_equals_alias_chains_are_followed_to_the_end() {
+    let chain =
+        |n: usize| -> String { (1..n).map(|i| format!("import A{i} = A{};\n", i - 1)).collect() };
+    let types = ["A17.T", "A39.T | number", "X.T", "S.T"];
+    let source = format!(
+        "import {{Directive, Input}} from '@angular/core';
+namespace NS {{ export type T = string; }}
+import A0 = NS;
+{}import X = Y;
+import Y = X;
+import S = S.B;
+@Directive({{selector: '[d]'}})
+export class Dir {{
+{}}}
+",
+        chain(40),
+        members_typed(&types)
+    );
+    assert_eq!(accept_members(&source), expect_members(&["T", "T | number", "unknown", "unknown"]));
+}
+
 /// An alias of another module (`import R = require('./other')`, or of an
 /// import) follows the rule for other modules: `unknown`. ngtsc 22.1.7 writes
 /// the bare name there (`Other`, `T`), which doesn't resolve in its `.d.ts`.
@@ -739,6 +776,10 @@ const MATCH: &[(&str, &str)] = &[
     ("'\\x00'", "\"\\0\""),
     ("'\\0' | '\\u00001'", "\"\\0\" | \"\\x001\""),
     ("'\u{2028}\u{2029}\\u0085'", "\"\\u2028\\u2029\\u0085\""),
+    // A U+2028 / U+2029 (a line break, but three bytes long) on the line
+    // before a union.
+    ("{ a: 1;\u{2028} b:\n string | number }", "{ a: 1; b: string | number; }"),
+    ("{ a: 1;\u{2029} b:\n string | number }", "{ a: 1; b: string | number; }"),
     ("'\\v\\f\\b'", "\"\\v\\f\\b\""),
     ("'\\x7f'", "\"\u{7f}\""),
     ("'a\"b\\'c`d'", "\"a\\\"b'c`d\""),