fix(dts): resolve import-equals aliases in computed property names

A computed name in a transform's parameter type (`{ [Core.ɵSIGNAL]: string }`)
skipped the alias resolution type names get, so an alias of
`@angular/core` (`import Core = require('@angular/core')`, `import C = ng`,
`import S = Core.ɵSIGNAL`, or one declared in a namespace) was written as
is, another module's alias didn't make the type `unknown`, and a global's
alias wasn't written as its target. Computed names now resolve aliases
the way type names do: `i0.ɵSIGNAL`, `unknown`, and `G.k`. ngtsc 22.1.7
copies all of these as written, which doesn't resolve in its `.d.ts`. An
alias of a name the file declares stays as written, like ngtsc.

The snapshot's `scope-typeOnly-*` probes (added earlier in the stack,
before `.d.ts` transform types) now also compare ngtsc's
`ngAcceptInputType_*` types, including `typeof name` for a helper's
parameter used as a type.

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

Author: Brooooooklyn

crates/oxc_angular_compiler/src/directive/dts_type.rs

@@ -32,7 +32,7 @@ pub(crate) struct TypePrinter<'s, 'a> {
     pub other_module: bool,
 }
 
-impl TypePrinter<'_, '_> {
+impl<'a> TypePrinter<'_, 'a> {
     /// `unknown` when the type has a form ngtsc can't emit either (an
     /// `import('...')` type) or that isn't valid in a type annotation.
     pub(crate) fn print(&mut self, ty: &TSType<'_>) -> String {
@@ -211,26 +211,42 @@ impl TypePrinter<'_, '_> {
     fn type_name(&mut self, name: &TSTypeName<'_>) -> Option<String> {
         let mut parts = std::vec::Vec::new();
         entity_parts(name, &mut parts)?;
+        Some(match self.resolve_aliases(parts)? {
+            Resolved::Core(rest) => format!("i0{rest}"),
+            Resolved::OtherModule(parts) => {
+                self.other_module = true;
+                parts.join(".")
+            }
+            Resolved::Name(parts, _) => self.resolved_name(&parts),
+        })
+    }
+
+    /// `parts` (a name, head first) with the import-equals aliases it starts
+    /// with replaced by their targets, until its head isn't one.
+    fn resolve_aliases<'p>(&self, mut parts: std::vec::Vec<&'p str>) -> Option<Resolved<'p>>
+    where
+        'a: 'p,
+    {
+        let mut aliased = false;
         // Aliases can name aliases; a cycle is a TypeScript error.
         for _ in 0..16 {
             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(self.resolved_name(&parts)),
+                    None => return Some(Resolved::Name(parts, aliased)),
                 },
             };
+            aliased = true;
             match target {
                 // `import Core = require('@angular/core')`: `Core.X` is
                 // `i0.X`, like a namespace import's member.
                 AliasTarget::Module("@angular/core") => {
-                    let rest: String = parts[len..].iter().map(|m| format!(".{m}")).collect();
-                    return Some(format!("i0{rest}"));
-                }
-                AliasTarget::Module(_) => {
-                    self.other_module = true;
-                    return Some(parts.join("."));
+                    return Some(Resolved::Core(
+                        parts[len..].iter().map(|m| format!(".{m}")).collect(),
+                    ));
                 }
+                AliasTarget::Module(_) => return Some(Resolved::OtherModule(parts)),
                 AliasTarget::Entity(target) => {
                     parts.splice(0..len, target);
                 }
@@ -413,24 +429,53 @@ impl TypePrinter<'_, '_> {
     /// `@angular/core` value becomes `i0.token`, another module's makes the
     /// type `unknown`, and a local or global one stays as written (ngtsc copies
     /// the expression, which doesn't resolve for an import).
+    ///
+    /// Through an import-equals alias too, although ngtsc copies those as
+    /// written: an alias of `@angular/core` gives `i0.token` and one of another
+    /// module `unknown`, where ngtsc's name doesn't resolve in the `.d.ts`. An
+    /// alias of a global is written as its target (`[Symbol.iterator]` for
+    /// `import S = Symbol`), and one of a name the file declares stays as
+    /// written, like ngtsc.
     fn key(&mut self, key: &PropertyKey<'_>, computed: bool) -> Option<String> {
         let text = match key {
             PropertyKey::StaticIdentifier(id) => id.name.to_string(),
             PropertyKey::StringLiteral(s) => quote_literal(s),
             PropertyKey::NumericLiteral(n) => format_number_like_js(n.value),
             PropertyKey::TemplateLiteral(t) if t.expressions.is_empty() => self.slice(t.span),
-            PropertyKey::Identifier(id) => self.value_name(&id.name, ""),
+            PropertyKey::Identifier(id) => self.computed_name(std::vec![id.name.as_str()])?,
             PropertyKey::StaticMemberExpression(m) => {
-                let chain = member_chain(&m.object, &m.property.name)?;
-                let (head, rest) = chain.split_once('.').unwrap_or((&chain, ""));
-                let rest = if rest.is_empty() { String::new() } else { format!(".{rest}") };
-                self.value_name(head, &rest)
+                let mut parts = std::vec::Vec::new();
+                member_parts(&m.object, &mut parts)?;
+                parts.push(m.property.name.as_str());
+                self.computed_name(parts)?
             }
             _ => return None,
         };
         Some(if computed { format!("[{text}]") } else { text })
     }
 
+    /// A computed property name `a.b.c` (`parts`, head first), as [`Self::key`]
+    /// writes it.
+    fn computed_name(&mut self, parts: std::vec::Vec<&str>) -> Option<String> {
+        let written = parts.join(".");
+        Some(match self.resolve_aliases(parts)? {
+            Resolved::Core(rest) => format!("i0{rest}"),
+            Resolved::OtherModule(_) => {
+                self.other_module = true;
+                written
+            }
+            Resolved::Name(parts, aliased) => {
+                let (head, members) = (parts[0], &parts[1..]);
+                if aliased && self.scope.import(head).is_none() && self.scope.declares(head) {
+                    written
+                } else {
+                    let rest: String = members.iter().map(|m| format!(".{m}")).collect();
+                    self.value_name(head, &rest)
+                }
+            }
+        })
+    }
+
     fn params(
         &mut self,
         this: Option<&TSThisParameter<'_>>,
@@ -592,15 +637,27 @@ fn entity_parts<'n>(name: &'n TSTypeName<'_>, out: &mut Vec<&'n str>) -> Option<
     Some(())
 }
 
-fn member_chain(object: &Expression<'_>, property: &str) -> Option<String> {
-    let object = match object {
-        Expression::Identifier(id) => id.name.to_string(),
+/// The parts of a computed name's object, `a.b` in `[a.b.c]`, head first.
+fn member_parts<'n>(object: &'n Expression<'_>, out: &mut Vec<&'n str>) -> Option<()> {
+    match object {
+        Expression::Identifier(id) => out.push(id.name.as_str()),
         Expression::StaticMemberExpression(m) if !m.optional => {
-            member_chain(&m.object, &m.property.name)?
+            member_parts(&m.object, out)?;
+            out.push(m.property.name.as_str());
         }
         _ => return None,
-    };
-    Some(format!("{object}.{property}"))
+    }
+    Some(())
+}
+
+/// A name with its import-equals aliases replaced by their targets.
+enum Resolved<'p> {
+    /// An alias of `@angular/core`: the `.member`s after it.
+    Core(String),
+    /// An alias of another module: the name as written.
+    OtherModule(std::vec::Vec<&'p str>),
+    /// Any other name, head first, and whether an alias was replaced.
+    Name(std::vec::Vec<&'p str>, bool),
 }
 
 fn is_line_break(c: char) -> bool {

crates/oxc_angular_compiler/tests/dts_input_transform_type_test.rs

@@ -503,6 +503,89 @@ fn computed_names_from_imports_follow_type_name_rules() {
     ]);
 }
 
+/// A computed property name through an import-equals alias (top level, in a
+/// namespace, or of an alias) resolves it the way a type name does. ngtsc
+/// 22.1.7 copies every one of these as written. An alias of a name the file
+/// declares stays as written, as ngtsc wrote it (the last group). The rest
+/// follow oxc's rules for imports and globals, since type-checking ngtsc's
+/// `.d.ts` reports "Cannot find name" for each (except `Ex`, which is
+/// exported): an alias of `@angular/core` gives `i0.X`, one of another module
+/// makes the type `unknown`, and one of a global (`G`, declared in a separate
+/// `.d.ts` for ngtsc) is written as its target.
+#[test]
+fn computed_names_through_import_equals_aliases() {
+    let cases: [(&str, &[&str], &[&str]); 4] = [
+        (
+            "import Core = require('@angular/core');\nimport S = Core.ɵSIGNAL;\nimport C2 = Core;\nexport import Ex = require('@angular/core');\nimport * as ng from '@angular/core';\nimport C = ng;\nimport S2 = ng.ɵSIGNAL;\nnamespace W { export import C3 = Core; export import S3 = Core.ɵSIGNAL; }\n",
+            &[
+                "{ [Core.ɵSIGNAL]: string }",
+                "{ [Core.ɵSIGNAL](): void }",
+                "{ [S]: string }",
+                "{ [C2.ɵSIGNAL]: string }",
+                "{ [Ex.ɵSIGNAL]: string }",
+                "{ [C.ɵSIGNAL]: string }",
+                "{ [S2]: string }",
+                "{ [W.C3.ɵSIGNAL]: string }",
+                "{ [W.S3]: string }",
+            ],
+            &[
+                "{ [i0.ɵSIGNAL]: string; }",
+                "{ [i0.ɵSIGNAL](): void; }",
+                "{ [i0.ɵSIGNAL]: string; }",
+                "{ [i0.ɵSIGNAL]: string; }",
+                "{ [i0.ɵSIGNAL]: string; }",
+                "{ [i0.ɵSIGNAL]: string; }",
+                "{ [i0.ɵSIGNAL]: string; }",
+                "{ [i0.ɵSIGNAL]: string; }",
+                "{ [i0.ɵSIGNAL]: string; }",
+            ],
+        ),
+        (
+            "import R = require('./other');\nimport * as o from './other';\nimport O = o;\nimport T = o.token;\nimport {Inner} from './other';\nimport I = Inner;\nnamespace W { export import O2 = o; }\n",
+            &[
+                "{ [R.token]: string }",
+                "{ [R.Inner.k]: string }",
+                "{ [O.token]: string }",
+                "{ [T]: string }",
+                "{ [I.k]: string }",
+                "{ [W.O2.token]: string }",
+            ],
+            &["unknown", "unknown", "unknown", "unknown", "unknown", "unknown"],
+        ),
+        (
+            "import GA = G;\nimport GK = G.k;\nimport GI = G.In;\nnamespace W { export import GA2 = G; }\n",
+            &[
+                "{ [GA.k]: string }",
+                "{ [GK]: string }",
+                "{ [GI.j]: string }",
+                "{ [W.GA2.k]: string }",
+            ],
+            &[
+                "{ [G.k]: string; }",
+                "{ [G.k]: string; }",
+                "{ [G.In.j]: string; }",
+                "{ [G.k]: string; }",
+            ],
+        ),
+        (
+            "namespace NS { export const k = 'nk'; }\nimport A = NS;\nimport K = NS.k;\nnamespace W { export import A2 = NS; }\n",
+            &["{ [A.k]: string }", "{ [K]: string }", "{ [W.A2.k]: string }"],
+            &["{ [A.k]: string; }", "{ [K]: string; }", "{ [W.A2.k]: string; }"],
+        ),
+    ];
+    for (imports, types, expected) in cases {
+        let source = format!(
+            "import {{Directive, Input}} from '@angular/core';
+{imports}@Directive({{selector: '[d]'}})
+export class Dir {{
+{}}}
+",
+            members_typed(types)
+        );
+        assert_eq!(accept_members(&source), expect_members(expected), "{imports}");
+    }
+}
+
 /// An overloaded static method is typed from its first declaration, as an
 /// overloaded function is (ngtsc 22.1.7 writes `string` here). The snapshot
 /// can't hold this case: ngtsc compiles the transform to the bare method name