Platform-specific code

Per-platform code is tagged with the targets it is built for. --platform ios drops what that target does not build. cg platforms divergence lists variants that leave a declared target uncovered, and calls that are live where the callee is absent.

$ cg impact open_logs --db out/app.db --platform windows
platform: windows (4 nodes and 13 references not built for it left out)
not built for windows: function:dirs_demo::open_logs

$ cg platforms divergence --db out/app.db
== VARIANTS: dirs_demo::paths::config_dir  covered: windows, linux, macos
== REFERENCED WHERE THE CALLEE IS NOT BUILT: 1
  main -CALLS-> open_logs  missing on: windows, macos  (callee: linux)

Targets

Known targets: windows, linux, macos, ios, android, web, tvos, watchos, visionos. --platform also takes aliases (win32, darwin, wasm, xros, …). A project's targets come from the first source that names them:

#if os(Linux) and a Vapor / Hummingbird dependency add linux to a SwiftPM package. An Xcode app with no root Package.swift uses only the platforms its project lists. cg platforms prints the targets and where each came from.

Apple

canImport(UIKit) is ios, tvos, visionos (and macos in a Catalyst app). canImport(AppKit) is macos. targetEnvironment(simulator) is not a platform. @available(iOS 17, *) is a minimum OS version (attrs.available, Swift), not a target filter. @available(iOS, unavailable) is a platform condition.

What is recognised

A guard (if (Platform.OS !== 'ios') return) tags the rest of the block with the negated condition. A JS branch without braces ends at its line. Electron and Tauri process roles are recorded by bridges. Bridge receiver files take the platform of android/ / ios/ / macos/.

A condition that does not decide the target (feature = "x", Platform.Version > 30) is unknown. The code under it stays in every target's view. cg platforms and cg coverage count unknown conditions.

In the graph

A Swift member a variant does not define is not missing when the variant conforms to a protocol that requires it, or when init comes from an SDK superclass (attrs.external_supers). Kotlin common code binds to expect; a call from an actual binds to that actual. iosTest / androidUnitTest are built for that platform.

Re-exports in a variant file count as its definitions (TS export {a as b}, Dart export … show, a top-level tear-off). API-surface and missing-callee findings count them.

Queries

reaches, impact, downstream, path, routes and search take --platform TARGET (MCP: platform). The first line names the filter and how many conditions could not be evaluated. A target symbol that is not built for the platform is named as such. Without --platform the answer is the full graph, with labels like [ios, android]. An unknown name exits 2 and lists the known targets.

Not findings: an import that spells ./Cam.ios (that file is used on every target the importer builds for); a test file named release.web.test.ts; a Swift call that uses an SDK initializer where the project's extension is not built; C functions of the same name in separate main() programs; a reference to code built for no declared target (sunos.c, counted, not listed).

Test code whose platforms are only the project default (no #if, no Xcode membership) is listed under FROM TEST CODE WHOSE PLATFORMS ARE THE PROJECT DEFAULT. A test narrowed by #if or by its target's SUPPORTED_PLATFORMS stays in the main missing-callee list.

--target ios keeps one target. --kind variants|api_surface|missing_callee|missing_callee_tests keeps one kind. MCP: platforms, platform_divergence(target, kind).

platforms:
  targets: [ios, android, web]
  paths:
    "src/win32/**": [windows]
    "src/posix/**": [unix]     # native = every non-web target
  file_suffixes: true          # .ios.ts / .android.ts
  path_conventions: true       # win/ and *_win.c
  xcode_membership: true

cg config show lists the effective values and where each one came from. cg index records platforms in the stats: targets, conditions, tagged symbols and references, per-target counts, divergence findings, seconds.

$ cg impact function:lib/storage/storage_web.dart#save --db out/app.db --platform ios
platform: ios (5 nodes and 11 references not built for it left out; 0 conditions could not be evaluated)
not built for ios: function:lib/storage/storage_web.dart#save

Rust exact mode resolves the host configuration, then runs once per other target the cfg conditions name (up to 3, CG_RUST_TARGETS). References under another target's cfg are exact (attrs.exact_target). What none of those runs resolves is added from the syntax layer (via: cfg-inactive), so every target's callers are in the graph.

A call that resolves to one variant (storage.ios.ts, the stub of a conditional import, the host cfg in rust-analyzer, a Swift function defined once per #if) is also linked to its siblings, with attrs.platform_variant_of. impact on storage.android.ts#save finds callers that import ./storage. Re-exports in a variant file count as its definitions: TS export {a as b} from './m', export *, export const X = Y (attrs.reexports), Dart export 'src/x.dart' show f and a top-level tear-off in a conditional-import library. A call through the variant reaches the re-exported definition.

Parentheses in a Swift condition ((os(iOS) && canImport(CoreTelephony)) || os(tvOS)) are evaluated as written. Comments and other declarations between #if branches do not merge the types. A nested type follows its variant.

Kingfisher's tests are built for watchOS (build only, never test), which gives 35 project-default test findings. Spot checks on ripgrep, alacritty, libuv, curl, dart-lang/http, localsend and bluesky social-app: platform-specific code .