GeezerVison

Replace the substring-matching SymbolGraphParser with SymbolGraphLoader,
which reads symbol graphs with llvm::json into a Swift-specific IR
(src/Swift/SwiftIR.h) instead of the Objective-C Meta model.

The IR records every public declaration with its USR, kind, access,
parameters (labels, internal names, inout/ownership, type attributes,
defaults), effects, settability, failable initializers, generics,
availability, extension info and actor attributes, and resolves
memberOf/requirementOf/conformsTo/inheritsFrom/overrides relationships,
including members of types declared in other modules. Parameters are
parsed from declarationFragments because functionSignature reports the
internal name instead of the argument label for unlabeled parameters and
drops @autoclosure and default values; parsed labels are cross-checked
against the symbol name. Load problems surface as diagnostics with stable
codes, and errors make the generator exit non-zero.

- swift!<Module>.d.ts is explicitly type-only: top-level type names, no
  members, until Swift members are callable.
- --swift-ir-output writes a deterministic JSON dump of the IR.
- swift-symbolgraph-tests (CTest) covers the loader against checked-in
  SwiftDemo graphs, with IR and .d.ts snapshots.
- SwiftDemo gains declarations for every shape the loader models;
  generate-symbolgraphs.sh reproduces the checked-in graphs.

Objective-C output is unchanged: metadata.bin and all .d.ts files for the
iOS simulator SDK are byte-identical to origin/main's generator.

Running the loader over Apple SDK Swift modules (SwiftUI, Foundation,
Charts, SwiftData, RegexBuilder, WeatherKit, Observation) surfaced
declaration shapes the fixture did not cover and a memory blow-up.

- Parse each symbol and relationship separately with a structural
  skimmer instead of building one llvm::json DOM per file. SwiftUI's
  465 MB of graphs went from 23.5 GB peak RSS and 22.6 s to 1.2 GB and
  6.9 s.
- Parameter attributes before the label (`@ViewBuilder content:`) and
  attributes with argument or generic lists (`@attached(...)`,
  `@abi(func ...)`, `@KeyframesBuilder<Value>`) no longer derail
  parameter parsing.
- Keep both symbols when Swift imports an Objective-C completion-handler
  method or property a second time as `async` under the same USR
  (`<usr>#async`), and when a subclass redeclares an Objective-C member
  (`<usr>#<Owner>`), instead of dropping one as a duplicate. Membership
  edges attach only to the variant declared in the target type.
- Record conformances a module adds to external types through extensions
  on the external type rather than reporting dangling relationships.
- Record effects declared in accessor blocks (`{ get async }`).

All seven modules now load without diagnostics.

…ompiler verification

PR 2 of the Swift interop plan: decide, per declaration, whether it can be
reached from JavaScript, report it, and have the Swift compiler confirm
every decision that claims a declaration is callable.

- SwiftTypes parses TypeRefs into a type tree (nominal and member types,
  generics, optionals, collections, tuples, function types with effects
  and attributes, metatypes, existentials, opaque types, compositions),
  normalizing Optional/Array/Dictionary and resolving generic parameters
  in scope.
- CapabilityClassifier assigns each symbol one tier (objc-direct,
  swift-generated, swift-specialized, type-only, unsupported,
  not-applicable) with stable reason codes, the JS bridge of every
  parameter and result, JS names, and overload ambiguity. The generated
  surface bridges primitives, String, optionals, module classes/actors
  (handles), structs (boxes) and payload-less enums (case names).
- CoverageReport writes <Module>.coverage.json with per-tier and per-kind
  counts, a reason histogram, effective (ObjC + Swift) callable counts and
  every symbol's classification.
- ProbeEmitter writes Swift that calls each generated declaration the way
  a thunk will, through the shared SwiftSource invocation rendering.
  ProbeVerifier type-checks the probes, maps compiler errors back to
  symbols, demotes them as compiler-rejected and reclassifies until the
  probes type-check; symbol graphs cannot express facts like ~Copyable.
- New flags: --swift-coverage-output, --swift-probe-output, --swift-verify
  (with --swift-sdk, --swift-target, --swift-search-path,
  --swift-framework-search-path, --swift-compiler, --swift-work-dir) and
  --swift-deployment-target.
- Graphs from cross-import overlays record their declaring module so
  generated code imports and qualifies it correctly.

Across SwiftUI, Foundation, Charts, SwiftData, RegexBuilder, WeatherKit and
Observation at an iOS 18 deployment target, all generated probes type-check
after at most two passes; the compiler rejects two Foundation declarations
that use the noncopyable Subprogress. Objective-C output is unchanged.

…tions

PR 3-5 of the Swift interop plan, generator side: emit the Swift code the
runtime calls, and declare exactly that surface to TypeScript.

- SwiftSurface is the registration model (type table, member kinds, flags
  and signature codes of NativeScript/runtime/SwiftInterop.h) shared by
  the thunk emitter and the TypeScript writer, so the two cannot disagree.
- ThunkEmitter (--swift-thunk-output) writes <Module>+NativeScript.swift:
  one thunk per generated callable, reading 24-byte argument slots and
  reporting through the runtime's API table without importing runtime
  headers, plus ns_swift_register_<Module> (@c when the compiler has it,
  @_cdecl otherwise). Classes and actors cross as retained handles with
  their dynamic type index, structs as boxes the JS object owns, payload-
  less enums as case names; availability is checked at call time.
  Enum cases are qualified so a case named `none` is not Optional.none.
- SwiftDefinitionWriter now writes swift!<Module>.d.ts as
  `declare module "ns:swift/<Module>"`, mirroring the runtime's member
  groups, inherited overloads, signature keys and ambiguity rules, and
  augments ns:swift's SwiftModules interface.
- The SwiftDemo fixture gains value, error and lifetime declarations, a
  checked-in Interop/ copy of its generated thunks (kept identical to the
  generator's output by a test) and a two-module Package.swift.
- Tests type-check the thunks against the separately compiled fixture
  module and the declarations with tsc when available.

All thunks generated for SwiftUI, Foundation, Charts, SwiftData,
RegexBuilder, WeatherKit and Observation (about 1,860) type-check against
the iOS 18 simulator SDK.

coderabbitai Bot left a comment