"shared/yeast-schema",

"ruby/extractor",

"unified/extractor",

"unified/swift-syntax-rs",

"rust/extractor",

"rust/extractor/macros",

This is a CodeQL extractor that maps a language's parse tree onto a shared AST

using the `yeast` desugaring engine. Swift, the only language so far, is parsed

by Apple's swift-syntax rather than by tree-sitter.

- To build the extractor, run `scripts/create-extractor-pack.sh`

- Swift source is parsed by `swift-syntax-parse`, a small Swift/Rust binary in

`swift-syntax-rs` that wraps Apple's swift-syntax and emits the parse tree as

JSON. There is no grammar in this repository to edit.

- `extractor/src/languages/swift/adapter.rs` converts that JSON into a yeast AST.

- The raw parse tree's shape is described by `extractor/swift_node_types.yml`,

which is maintained by hand.

- The target AST shape is described by `extractor/ast_types.yml`.

- The mapping from the parse tree to the target AST is found in `extractor/src/languages/swift/swift.rs`

- To run tests for the parser and mapping, run `cargo test` in the `extractor`

directory. The tests need the `swift-syntax-parse` binary: point

`CODEQL_EXTRACTOR_UNIFIED_SWIFT_SYNTAX_PARSE` at it, or put it on `PATH`.

Corpus tests skip themselves when it cannot be found, so check for skips

before concluding a change is clean.

- Extractor test cases are located at `extractor/tests/corpus/swift/*/*.swift`.

) + [

"//shared/tree-sitter-extractor",

"//shared/yeast",

],

)

[dependencies]

clap = { version = "4.5", features = ["derive"] }

tracing = "0.1"

tracing-subscriber = { version = "0.3.20", features = ["env-filter"] }

# A statement is anything that can appear in a block.

# This type contains all of 'expr' and has partial overlap with 'member'.

# For example, type_alias_declaration can appear either as a stmt or member.

stmt:

- expr

- variable_declaration

use std::collections::BTreeMap;

// ---- Literals ----

// swift-syntax does not distinguish the lexical integer/string forms

// (hex/binary/octal, single- vs multi-line, raw): each is a single

// `*LiteralExpr` kind, so one rule per literal type suffices.

rule!((integerLiteralExpr) => (int_literal)),

rule!((floatLiteralExpr) => (float_literal)),

rule!((booleanLiteralExpr) => (boolean_literal)),

rule!((declReferenceExpr baseName: @name) => (name_expr identifier: (identifier #{name}))),

// A discard `_` used as an expression — e.g. the target of a discarding

// assignment `_ = x`. swift-syntax models it as a `discardAssignmentExpr`;

// the target AST has no expression-level discard (only `ignore_pattern`,

// which is a pattern), so it becomes a `name_expr` over the `_` token.

rule!((discardAssignmentExpr wildcard: @@w) => (name_expr identifier: (identifier #{w}))),

// ---- Operators ----

// The parser front-end folds operator chains into nested

accessor_kind: (accessor_kind "get")

body: (block stmt: {body}))

),

// A property with an explicit accessor block. swift-syntax makes both

// shapes plain `accessorDecl`s, so they are told apart by the presence

// of an initializer:

//

// * With an initializer (`var x: T = e { willSet {…} didSet {…} }`) it is

// a *stored* property with observers: emit the backing

// payload parameters; an element with a raw value (`case a = 1`) or a

// plain element (`case north`) becomes a `variable_declaration`. All

// carry the shared case modifiers / chained tag from `ctx` (set by the

// `enumCaseDecl` rule below) and are tagged `enum_case`, after any

// `chained_declaration` tag.

rule!(

(enumCaseElement name: @name parameterClause: (enumCaseParameterClause parameters: _* @params))

=>

// Enum cases. A single `case` declaration may carry modifiers

// (e.g. `indirect`) and list several comma-separated elements; each

// becomes its own declaration carrying those shared modifiers, and

// non-first ones are tagged `chained_declaration`. The modifiers are

// published into `ctx`

// for the element rules above, which build the actual declaration.

rule!(

(enumCaseDecl modifiers: _* @mods elements: _* @@cases)

// A function declaration (parameters/return type/body optional). The

// parameters and return type nest under `signature`; the body is a

// `codeBlock`. A bodyless function (a protocol requirement) still emits

// an empty `block`.

rule!(

(functionDecl

name: @name

condition: {and_chain(&mut ctx, cond)}

else: {else_stmts})

),

// Ternary (`c ? a : b`) desugars to an `if_expr`.

rule!(

(ternaryExpr condition: @cond thenExpression: @then_val elseExpression: @else_val)

=>

(pattern_guard_expr pattern: {pat} value: {val})

),

// Optional binding (`if let x = foo`, or shorthand `if let x`) desugars

// to a `pattern_guard_expr` matching `Optional.some(x)`. The initialized

// form is matched first.

rule!(

(optionalBindingCondition

pattern: (identifierPattern identifier: @name)

),

rule!((arrayElement expression: @e) => expr { e }),

// A dictionary literal (`["a": 1]`) is kept as an opaque `map_literal`

// leaf (its source span).

rule!((dictionaryExpr) => (map_literal)),

// A subscript access (`xs[0]`) is modelled as a call. swift-syntax does

// report a distinct `subscriptCallExpr`, so giving

// subscripts their own shape needs only a `subscript_expr` node in

// ast_types.yml and a remap here.

rule!(

(subscriptCallExpr calledExpression: @callee arguments: _* @args)

=>

rule!((isExpr expression: @val type: @ty) => (type_test_expr expr: {val} operator: (infix_operator "is") type: {ty})),

// Await expression → unary_expr with operator "await"

rule!((awaitExpr expression: @val) => (unary_expr operator: (prefix_operator "await") operand: {val})),

// Force-unwrap (`x!`) → postfix unary_expr, via swift-syntax's dedicated

// `forceUnwrapExpr` node.

rule!((forceUnwrapExpr expression: @e) => (unary_expr operator: (postfix_operator "!") operand: {e})),

// ---- Imports ----

// An import declaration. The dotted path (a list of

// A named type (`Int`). `identifierType.name` is the type-name token.

rule!((identifierType name: @@n) => (named_type_expr name: (identifier #{n}))),

// A qualified type (`Outer.Inner`, `NSString.CompareOptions`). swift-syntax

// nests these as `memberType` nodes; we keep the whole dotted path as the

// opaque `named_type_expr` name.

rule!((memberType) @ty => (named_type_expr name: (identifier #{ty}))),

// Sugared types desugar to `generic_type_expr`: `T?` -> Optional<T>,

// `[T]` -> Array<T>, `[K: V]` -> Dictionary<K, V>.

// expansions uniformly as a `macroExpansionExpr`).

rule!((macroExpansionExpr) => (unsupported_node)),

// A nominal type's `inheritanceClause` (`: Base, Proto`) becomes a list

// of `base_type`s, one per inherited type. Each declaration keyword

// gets its own rule; the bodies are identical but for the keyword.

// Class declaration with body containing members

rule!(

// An `extension Foo { … }` is likewise a `class_like_declaration`, named

// by the extended type. The extended type is captured opaquely (as its

// source text) so that qualified names (`extension String.Interpolation`,

// a `memberType`) name the declaration just like simple ones.

rule!(

(extensionDecl

extensionKeyword: @kind

// TODO: `xs[0]` is mapped to a call_expr, even though swift-syntax reports a

// distinct subscriptCallExpr. Giving subscripts their own shape needs only a

// subscript_expr node in ast_types.yml and a remap.

let first = xs[0]

---

// TODO: `xs[0]` is mapped to a call_expr, even though swift-syntax reports a

// distinct subscriptCallExpr. Giving subscripts their own shape needs only a

// subscript_expr node in ast_types.yml and a remap.

let first = xs[0]