fix(directive): assume globals declared outside the file are transform functions

ngtsc resolves a global like the DOM's `atob` or a project's
`declare function f(v: string): number` to its declaration, and accepts it as
an input transform. oxc only knew the ES2022 lib, so it reported "Input
transform must be a function" for these.

A name the file doesn't declare or import, and that isn't an ES2022 lib global,
is now assumed to be a function, like an imported transform: it's emitted as
written and only the `ngAcceptInputType_` clash is checked. Everywhere else it
stays dynamic, as before, and so does a shorthand `{ transform }` naming one,
which ngtsc never accepts. `Intl` and `Reflect` join the known lib globals (so
they keep ngtsc's "reference to" error), `globalThis` stays dynamic, and a
namespace or `import x = ...` declared in the file isn't taken for a global.

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

Author: Brooooooklyn

crates/oxc_angular_compiler/src/directive/evaluator.rs

@@ -61,6 +61,9 @@ pub(crate) struct FileScope<'a> {
     /// ngtsc's diagnostics point at it: the whole statement (with `export`) for
     /// a function or class, the declarator (`x: T`) for a variable.
     declaration_spans: HashMap<&'a str, Span>,
+    /// Namespaces and `import x = ...` aliases: declared in the file, but not
+    /// read by the evaluator (their values are dynamic).
+    unread: HashSet<&'a str>,
 }
 
 /// A top-level variable binding.
@@ -150,6 +153,21 @@ impl<'a> FileScope<'a> {
                 }
             }
         }
+        for stmt in &program.body {
+            let decl = match stmt {
+                Statement::ExportDeclaration(export) => Some(&export.declaration),
+                _ => stmt.as_declaration(),
+            };
+            match decl {
+                Some(Declaration::TSNamespaceDeclaration(ns)) => {
+                    scope.unread.insert(ns.id.name.as_str());
+                }
+                Some(Declaration::TSImportEqualsDeclaration(alias)) => {
+                    scope.unread.insert(alias.id.name.as_str());
+                }
+                _ => {}
+            }
+        }
         scope
     }
 
@@ -447,6 +465,13 @@ pub(crate) enum RefKind<'a> {
     /// An identifier with no declaration in this file that names a standard
     /// ECMAScript global (see [`ES_GLOBALS`]).
     Global,
+    /// Any other identifier this file doesn't declare or import: a global
+    /// declared outside it, in a lib such as the DOM's (`atob`, `window`) or in
+    /// a project `.d.ts`, which ngtsc resolves to that declaration, or a name
+    /// declared nowhere, which ngtsc can't resolve. oxc can't tell these apart,
+    /// so it's dynamic (see [`Value::is_dynamic`]), except that an input
+    /// transform assumes it's a function, as it does an imported one.
+    Ambient,
     /// A static getter or setter, or a static property without an
     /// initializer, declared at the span.
     StaticMember(Span),
@@ -526,6 +551,12 @@ impl<'a> Value<'a> {
         matches!(self, Value::Reference { kind: RefKind::Import { .. }, .. })
     }
 
+    /// Whether ngtsc's value is unknown: dynamic, or a global declared outside
+    /// the file, which is only kept as a name so a transform can refer to it.
+    pub(crate) fn is_dynamic(&self) -> bool {
+        matches!(self, Value::Dynamic | Value::Reference { kind: RefKind::Ambient, .. })
+    }
+
     /// ngtsc's `describeResolvedType`, one level deep like its diagnostics.
     pub(crate) fn describe(&self) -> String {
         self.describe_to(1)
@@ -563,6 +594,7 @@ impl<'a> Value<'a> {
                     .join(", ")
             ),
             Value::Module => "(module)".into(),
+            _ if self.is_dynamic() => "(not statically analyzable)".into(),
             Value::Reference { name, .. } | Value::Enum { name, .. } => name.clone(),
             Value::Builtin(_) => "Function".into(),
             Value::Dynamic | Value::Function(_) => "(not statically analyzable)".into(),
@@ -572,9 +604,8 @@ impl<'a> Value<'a> {
     /// The chained line ngtsc's `createValueHasWrongTypeError` adds after a message.
     pub(crate) fn wrong_type_suffix(&self) -> String {
         match self {
-            Value::Dynamic | Value::Function(_) => {
-                " Value could not be determined statically.".into()
-            }
+            Value::Function(_) => " Value could not be determined statically.".into(),
+            _ if self.is_dynamic() => " Value could not be determined statically.".into(),
             Value::Reference { name, .. } => format!(" Value is a reference to '{name}'."),
             _ => format!(" Value is of type '{}'.", self.describe()),
         }
@@ -617,10 +648,11 @@ fn quote_key(key: &str) -> String {
     }
 }
 
-/// The `declare var` / `declare function` globals of TypeScript's ES2022
-/// library (lib.es5.d.ts ... lib.es2022.*.d.ts). ngtsc resolves these to a
-/// reference to their declaration; any other undeclared name is unknown to it.
-/// DOM globals depend on the `lib` option and are treated as unknown.
+/// The `declare var` / `declare function` / `declare namespace` globals of
+/// TypeScript's ES2022 library (lib.es5.d.ts ... lib.es2022.*.d.ts), which
+/// ngtsc resolves to a reference to their declaration. Other globals (the
+/// DOM's, a project's `.d.ts`) depend on the program, and are
+/// [`RefKind::Ambient`].
 const ES_GLOBALS: &[&str] = &[
     "AggregateError",
     "Array",
@@ -648,6 +680,7 @@ const ES_GLOBALS: &[&str] = &[
     "Int16Array",
     "Int32Array",
     "Int8Array",
+    "Intl",
     "isFinite",
     "isNaN",
     "JSON",
@@ -662,6 +695,7 @@ const ES_GLOBALS: &[&str] = &[
     "Proxy",
     "RangeError",
     "ReferenceError",
+    "Reflect",
     "RegExp",
     "Set",
     "SharedArrayBuffer",
@@ -969,7 +1003,12 @@ impl<'s, 'a> Evaluator<'s, 'a> {
                                 None if self.consts.scope().variables.contains_key(name) => {
                                     self.top_level(name, depth)
                                 }
-                                None => self.eval(&p.value, depth, frame),
+                                // ngtsc never resolves a shorthand to a global
+                                // it can use as a transform.
+                                None => match self.eval(&p.value, depth, frame) {
+                                    value if value.is_dynamic() => Value::Dynamic,
+                                    value => value,
+                                },
                             }
                         }
                         (value, None) => self.eval(value, depth, frame),
@@ -1022,7 +1061,7 @@ impl<'s, 'a> Evaluator<'s, 'a> {
         frame: &Frame<'a>,
     ) -> Value<'a> {
         let object = self.eval(&m.object, depth, frame);
-        if matches!(object, Value::Dynamic) {
+        if object.is_dynamic() {
             return Value::Dynamic;
         }
         match self.eval(&m.expression, depth, frame) {
@@ -1041,7 +1080,7 @@ impl<'s, 'a> Evaluator<'s, 'a> {
         frame: &Frame<'a>,
     ) -> Value<'a> {
         match self.eval(&c.test, depth, frame) {
-            Value::Dynamic => Value::Dynamic,
+            test if test.is_dynamic() => Value::Dynamic,
             test if test.is_import() => test,
             test if test.truthy() => self.eval(&c.consequent, depth, frame),
             _ => self.eval(&c.alternate, depth, frame),
@@ -1060,7 +1099,7 @@ impl<'s, 'a> Evaluator<'s, 'a> {
             return Value::Dynamic;
         }
         match self.eval(&u.argument, depth, frame) {
-            Value::Dynamic => Value::Dynamic,
+            value if value.is_dynamic() => Value::Dynamic,
             value if value.is_import() => value,
             value => unary(u.operator, &value),
         }
@@ -1095,7 +1134,7 @@ impl<'s, 'a> Evaluator<'s, 'a> {
         let left = self.eval(&l.left, depth, frame);
         let right = self.eval(&l.right, depth, frame);
         match (left, right) {
-            (Value::Dynamic, _) | (_, Value::Dynamic) => Value::Dynamic,
+            (left, right) if left.is_dynamic() || right.is_dynamic() => Value::Dynamic,
             (value, _) | (_, value) if value.is_import() => value,
             (left, right) => match (l.operator, left.truthy()) {
                 (LogicalOperator::And, true) | (LogicalOperator::Or, false) => right,
@@ -1187,8 +1226,11 @@ impl<'s, 'a> Evaluator<'s, 'a> {
             _ if ES_GLOBALS.contains(&name) => {
                 Value::Reference { name: name.into(), kind: RefKind::Global }
             }
-            // ngtsc can't find a declaration for it.
-            _ => Value::Dynamic,
+            // TypeScript declares `globalThis` without a declaration ngtsc
+            // can find.
+            "globalThis" => Value::Dynamic,
+            _ if scope.unread.contains(name) => Value::Dynamic,
+            _ => Value::Reference { name: name.into(), kind: RefKind::Ambient },
         }
     }
 
@@ -1720,6 +1762,9 @@ pub(crate) fn transform_error<'a>(
         {
             return clash();
         }
+        // A global declared outside the file (`atob`) is assumed to be a
+        // function, like an imported one.
+        Value::Reference { kind: RefKind::Ambient, .. } => return clash(),
         Value::Reference { .. } | Value::Dynamic => {
             return Some((format!("Input transform must be a function{suffix}"), node()));
         }

crates/oxc_angular_compiler/tests/decorator_metadata_ngtsc_test.rs

@@ -299,7 +299,7 @@ fn decorator_metadata_matches_ngtsc() {
         failures.len(),
         failures.join("\n\n")
     );
-    assert_eq!(compared, 431, "fixtures compared");
+    assert_eq!(compared, 451, "fixtures compared");
 }
 
 fn transform(source: &str) -> TransformResult {
@@ -663,10 +663,10 @@ export class Dir { @Input({transform: core.booleanAttribute}) v: any; }
 }
 
 /// A transform declared in another file (an import, a namespace member or a
-/// global from TypeScript's lib): ngtsc 22.1.7 reports these at that
-/// declaration, which the snapshot can't record (the fixtures below are
-/// skipped for that reason, with the diagnostics ngtsc reported). oxc reports
-/// the same message on the expression.
+/// global from TypeScript's lib, like `Intl` or the DOM's `atob`): ngtsc
+/// 22.1.7 reports these at that declaration, which the snapshot can't record
+/// (the fixtures below are skipped for that reason, with the diagnostics ngtsc
+/// reported). oxc reports the same message on the expression.
 #[test]
 fn transform_declared_in_another_file_is_reported_on_the_expression() {
     let fixtures: Value = serde_json::from_str(FIXTURES).unwrap();
@@ -678,6 +678,9 @@ fn transform_declared_in_another_file_is_reported_on_the_expression() {
         ("probe: transform-globalNumberClash", "Number"),
         ("probe: transform-globalString", "String"),
         ("probe: transform-nsClash", "u.toNum"),
+        ("probe: transform-global-Intl", "Intl"),
+        ("probe: transform-global-Reflect", "Reflect"),
+        ("probe: transform-global-clashAtob", "atob"),
     ];
     for (name, expression) in cases {
         let fixture = fixtures["fixtures"]
@@ -697,6 +700,58 @@ fn transform_declared_in_another_file_is_reported_on_the_expression() {
     }
 }
 
+/// A name the file declares as a namespace or an `import x = ...` alias isn't
+/// a global declared elsewhere, so it isn't assumed to be a function the way
+/// `atob` is. ngtsc 22.1.7 rejects `transform: U` too, as "Value is a reference
+/// to 'U'" (oxc doesn't evaluate namespaces), and accepts `transform: f`
+/// (oxc doesn't follow the alias).
+#[test]
+fn file_namespaces_and_aliases_are_not_assumed_to_be_global_functions() {
+    let namespace = "namespace U { export function f(v: string) { return 1; } }\n";
+    for (pre, expr) in
+        [(namespace.to_string(), "U"), (format!("{namespace}import f = U.f;\n"), "f")]
+    {
+        let source = format!(
+            "import {{Directive, Input}} from '@angular/core';\n{pre}\
+             @Directive({{selector: '[d]'}})\n\
+             export class Dir {{\n  @Input({{transform: {expr}}}) x: any;\n}}\n"
+        );
+        assert_eq!(
+            errors(&transform(&source), &source),
+            vec![(
+                "Input transform must be a function Value could not be determined statically."
+                    .to_string(),
+                expr.to_string()
+            )],
+            "{expr}"
+        );
+    }
+}
+
+/// A shorthand `{ transform }` naming a global is looked up through
+/// TypeScript's shorthand symbol, which ngtsc 22.1.7 never accepts as a
+/// transform: "could not be determined statically" when nothing declares
+/// it, and an error about the declaration when a lib or `.d.ts` does (at
+/// that declaration). So unlike `transform: atob`, it isn't assumed to be a
+/// function.
+#[test]
+fn shorthand_transform_naming_a_global_is_rejected() {
+    let source = "import {Directive} from '@angular/core';
+@Directive({selector: '[d]', inputs: [{name: 'x', transform}]})
+export class Dir {
+  x!: any;
+}
+";
+    assert_eq!(
+        errors(&transform(source), source),
+        vec![(
+            "Input transform must be a function Value could not be determined statically."
+                .to_string(),
+            "transform".to_string()
+        )]
+    );
+}
+
 /// ngtsc checks an overloaded static method's first declaration, not its
 /// implementation (checked with @angular/compiler-cli 22.1.7, which compiles
 /// this; the snapshot can't hold it because ngtsc emits the method's bare name,