{"record":{"id":"88974d76f0fe4198","repo":"swc-project/swc","slug":"unable-to-access-unknown-nodes-88974d","errorCode":null,"errorMessage":"unable to access unknown nodes","messagePattern":"unable to access unknown nodes","errorType":"panic","errorClass":null,"httpStatus":null,"severity":"error","filePath":"crates/swc_typescript/src/fast_dts/function.rs","lineNumber":47,"sourceCode":"    }\n\n    pub(crate) fn transform_fn_return_type(&mut self, func: &mut Function) {\n        if func.return_type.is_none() && !func.is_async && !func.is_generator {\n            func.return_type = self.infer_function_return_type(func);\n        }\n    }\n\n    pub(crate) fn transform_fn_params(&mut self, params: &mut [Param]) {\n        // If there is required param after current param.\n        let mut is_required = false;\n        for param in params.iter_mut().rev() {\n            is_required |= match &param.pat {\n                Pat::Ident(binding_ident) => !binding_ident.optional,\n                Pat::Array(array_pat) => !array_pat.optional,\n                Pat::Object(object_pat) => !object_pat.optional,\n                Pat::Assign(_) | Pat::Invalid(_) | Pat::Expr(_) | Pat::Rest(_) => false,\n                #[cfg(swc_ast_unknown)]\n                _ => panic!(\"unable to access unknown nodes\"),\n            };\n            self.transform_fn_param(param, is_required);\n        }\n    }\n\n    pub(crate) fn transform_function_params(&mut self, function: &mut Function) {\n        self.check_this_param(function.this_param.as_deref());\n        self.transform_fn_params(&mut function.params);\n    }\n\n    pub(crate) fn check_this_param(&mut self, this_param: Option<&TsThisParam>) {\n        let Some(this_param) = this_param else {\n            return;\n        };\n        if this_param.type_ann.is_none() {\n            self.parameter_must_have_explicit_type(this_param.span);\n        }\n    }","sourceCodeStart":29,"sourceCodeEnd":65,"githubUrl":"https://github.com/swc-project/swc/blob/5176682b65416c6b5de6b47379ae1588ea3ecb3f/crates/swc_typescript/src/fast_dts/function.rs#L29-L65","documentation":"transform_fn_params iterates function parameters in reverse, matching each Pat (Ident/Array/Object carry optionality; Assign/Invalid/Expr/Rest do not) to compute whether later params must stay required in .d.ts output. Under the swc_ast_unknown cfg (`--cfg=swc_ast_unknown`, set for wasm plugin builds) Pat has an Unknown(tag, payload) variant; this arm panics because optionality of an unknown pattern kind cannot be determined.","triggerScenarios":"Running fast_dts on any function or method whose parameter binding pattern deserialized as Unknown — a plugin compiled with --cfg=swc_ast_unknown receiving a Program from a newer host @swc/core that emitted a binding-pattern kind absent from the plugin's swc_ecma_ast.","commonSituations":"Upgrading @swc/core without rebuilding plugins; plugins built against old lockfiles; new Pat variants introduced upstream.","solutions":["Rebuild the plugin with the swc_core version matching the host @swc/core","Update swc_core to the latest release so the pattern decodes as a known Pat variant","Pre-check params for Unknown patterns and skip fast_dts for those functions","Automate plugin rebuilds as part of host SWC upgrades"],"exampleFix":"// before\ntransform.run(&mut program); // fast_dts hits Pat::Unknown in fn params -> panic\n\n// after (guard under the plugin cfg)\n#[cfg(swc_ast_unknown)]\nfn fn_params_have_unknown_pat(f: &swc_ecma_ast::Function) -> bool {\n    f.params.iter().any(|p| matches!(p.pat, swc_ecma_ast::Pat::Unknown(..)))\n}\nif !fn_params_have_unknown_pat(&function) { transform.run(&mut program); }","handlingStrategy":"type-guard","validationCode":"#[cfg(swc_ast_unknown)]\nfn program_fns_contain_unknown_param_pat(m: &swc_ecma_ast::Module) -> bool {\n    use swc_ecma_ast::*;\n    fn any_unknown(params: &[Param]) -> bool {\n        params.iter().any(|p| matches!(p.pat, Pat::Unknown(..)))\n    }\n    m.body.iter().any(|i| matches!(i, ModuleItem::Stmt(Stmt::Decl(Decl::Fn(f)))\n        if any_unknown(&f.function.params)))\n}","typeGuard":"#[cfg(swc_ast_unknown)]\nfn pat_is_unknown(p: &swc_ecma_ast::Pat) -> bool {\n    matches!(p, swc_ecma_ast::Pat::Unknown(..))\n}","tryCatchPattern":"let out = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {\n    run_fast_dts(&mut program)\n}));\nif out.is_err() {\n    return Err(\"unknown param pattern; plugin swc_core is older than host\".into());\n}","preventionTips":["Rebuild the plugin against the swc_core bundled with the host @swc/core","Scan function params for Unknown patterns before running fast_dts","Upgrade host and plugin together, never independently","Run a version-consistency assertion at plugin load time"],"tags":["fast-dts","swc-plugin","wasm","version-skew","unknown-node","function-params","binding-pattern"],"backgroundTag":"ast-version-mismatch","analyzedSha":"5176682b65416c6b5de6b47379ae1588ea3ecb3f","analyzedAt":"2026-08-17T16:16:52.067Z","contentChangedAt":"2026-08-17T16:16:52.067Z","schemaVersion":2},"datasetVersion":"2026-09-14T05:17:10.506Z"}