[BridgeJS] Synthesize typed-closure init access from declaration surface (#709)

[matthewa26]

Summary

Fixes#709. The extension JSTypedClosure where Signature == ... { init(...) } synthesized by BridgeJS is always emitted as internal, so a public @JSClass exposing a JSTypedClosure<...> parameter cannot be consumed from another target — downstream callers have no way to construct the closure value without hand-rolling a public wrapper.

This change derives the synthesized init's access level from the originating Swift declaration:

• Imported skeleton entries (ImportedFunctionSkeleton, ImportedTypeSkeleton, ImportedConstructorSkeleton, ImportedGetterSkeleton, ImportedSetterSkeleton) record the source access level (new BridgeJSAccessLevel enum: internal < package < public, default internal).
• BridgeSkeletonWalker threads the enclosing decl's access level into BridgeSkeletonVisitor.visitClosure(...). Exported decls reuse the existing explicitAccessControl: String? field ("public" / "package" / "internal" / nil → inherit).
• ClosureSignatureCollectorVisitor now stores [ClosureSignature: BridgeJSAccessLevel] and takes the max access level across every surface that references a given signature, so a closure shape used by both a public and an internal method becomes public (one extension is generated per signature). signatures: Set<ClosureSignature> is preserved as a computed view for BridgeJSLink.
• ClosureCodegen.renderClosureHelpers prefixes the synthesized init with public / package (or leaves it bare for internal). Mirrors the pattern JSClassMacro already uses for init(unsafelyWrapping:).

The user's example from #709 now generates public init(...):

@JSClass(jsName:"Document")publicstructJSDocument{@JSFunctionpublicfunc addEventListener(_ type:String, _ listener:JSTypedClosure<(JSEvent)->Void>)throws(JSException)}
// →
extension JSTypedClosure where Signature ==(JSEvent)->Void{public init(fileID: StaticString = #fileID, line: UInt32 = #line, _ body:@escaping(JSEvent)-> Void){...}}

Test plan

• New input fixture SwiftTypedClosureAccess.swift covering: a public @JSClass/@JSFunction (→ public init), a package surface (→ package init), an internal-only surface (→ bare init), and a closure shape shared between a public and an internal method (→ merges to public init).
• swift test --package-path Plugins/BridgeJS — all 107 tests in 9 suites pass.
• Codegen JSON snapshots re-recorded to include the new accessLevel field on imported decls (defaults to "internal" for unchanged fixtures, so no semantic drift).
• swift build --package-path Examples/Basic builds clean end-to-end.

[krodak]

Hey Matthew, appreciate clean fix for a real usability problem 👌🏻
The approach of threading access levels through the skeleton/walker and merging via max fits the existing architecture well. Test fixture covers the key scenarios. A few suggestions below, nothing blocking.

[krodak]

The "check existing, take max, else insert" pattern here is duplicated in recordInjectedSignature below. If the merge logic ever needs to change (e.g. adding a diagnostic for conflicting levels), you'd need to update both spots.

Small extract:

privatemutatingfunc recordSignature(
_ signature:ClosureSignature,
accessLevel:BridgeJSAccessLevel){iflet existing =signatureAccessLevels[signature]{signatureAccessLevels[signature]=max(existing, accessLevel)}else{signatureAccessLevels[signature]= accessLevel
}}

Then both visitClosure and recordInjectedSignature call through to it.

[krodak]

rawLevel.flatMap(BridgeJSAccessLevel.init(rawValue:)) silently drops unknown strings (e.g. "open", "private") and falls back to inheriting the outer level. That's fine today since the macros reject those, but it's a quiet invariant. An assertion for unexpected values would save debugging time if the exported side ever gains new access strings:

privatemutatingfunc withAccessLevel(
_ rawLevel:String?,
_ body:(inoutBridgeSkeletonWalker)->Void){letlevel:BridgeJSAccessLevel?iflet rawLevel {
level =BridgeJSAccessLevel(rawValue: rawLevel)assert(level !=nil,"Unexpected access level string: \(rawLevel)")}else{
level =nil}withAccessLevel(level, body)}

[krodak]

This seeds every pre-existing signature as .internal. That's correct for the only current caller (BridgeJSLink, exported side), but the API doesn't communicate the assumption. If someone later pre-seeds signatures that should be public, they'd silently get capped.

Two options (both low-effort):

1. Add a doc comment on this init noting the assumption:

/// Convenience for callers that only need to seed signatures without
/// access metadata (e.g. exported-side walking where closure init
/// access is irrelevant). All seeded signatures default to `.internal`.
publicinit(moduleName:String, signatures:Set<ClosureSignature>){

2. Or offer a dictionary-based init alongside it:

publicinit(moduleName:String, signatureAccessLevels:[ClosureSignature:BridgeJSAccessLevel]=[:]){self.moduleName = moduleName
self.signatureAccessLevels = signatureAccessLevels
}

[krodak]

@matthewa26 please address feedback at your convenience and have a read on CONTRIBUTING.md to make sure to update artifacts checked by CI 🙏🏻

[matthewa26]

@krodak Will do! Just now seeing this.

[matthewa26]

@krodak Looks like everything is green now. Thanks for the review and the follow up!

[kateinoigakukun]

Seems good to me, thanks @matthewa26 (and thanks @krodak for reviewing!)