codeql-development-mcp-server 2.24.2-rc2 → 2.24.2

package/ql/swift/tools/src/CallGraphFrom/CallGraphFrom.md

@@ -0,0 +1,44 @@
+# CallGraphFrom for Swift
+
+Displays calls made from a specified function, showing the call graph outbound from the source function.
+
+## Overview
+
+This query identifies all function calls made within the body of a named function, producing an outbound call graph. Given a source function name, it reports each call site and the callee, which is useful for understanding function dependencies and call chains.
+
+The query accepts function names via an external predicate (`sourceFunction`).
+
+## Use Cases
+
+This query is primarily used for:
+
+- Mapping outbound dependencies of a specific function
+- Understanding what a function calls and in what order
+- Analyzing call chains for refactoring or security review
+
+## Example
+
+The following Swift code demonstrates outbound calls from `sourceFunc`:
+
+```swift
+func helper1() {}
+func helper2() { helper1() }
+
+func sourceFunc() {               // Source function for analysis
+    helper1()
+    helper2()
+}
+```
+
+Running with `sourceFunction = "sourceFunc"` produces results showing each call site with the message pattern ``Call from `sourceFunc` to `helper1``.
+
+## Output Format
+
+The query is a `@kind problem` query producing rows of:
+
+- ``select call, "Call from `source` to `callee`"``
+
+## References
+
+- [Swift Functions](https://docs.swift.org/swift-book/documentation/the-swift-programming-language/functions/)
+- [CodeQL Call Graph Analysis](https://codeql.github.com/docs/writing-codeql-queries/about-data-flow-analysis/)

package/ql/swift/tools/src/CallGraphTo/CallGraphTo.md

@@ -0,0 +1,41 @@
+# CallGraphTo for Swift
+
+Displays calls made to a specified function, showing the call graph inbound to the target function.
+
+## Overview
+
+This query identifies all call sites that invoke a named function, producing an inbound call graph. Given a target function name, it reports each caller and call location, which is useful for understanding how a function is used across the codebase.
+
+The query accepts function names via an external predicate (`targetFunction`).
+
+## Use Cases
+
+This query is primarily used for:
+
+- Finding all callers of a specific function
+- Impact analysis before modifying a function signature
+- Understanding usage patterns and entry points
+
+## Example
+
+The following Swift code demonstrates inbound calls to `targetFunc`:
+
+```swift
+func targetFunc() {}              // Target function for analysis
+
+func caller1() { targetFunc() }
+func caller2() { targetFunc() }
+```
+
+Running with `targetFunction = "targetFunc"` produces results showing each call site with the message pattern ``Call to `targetFunc` from `caller1``.
+
+## Output Format
+
+The query is a `@kind problem` query producing rows of:
+
+- ``select call, "Call to `target` from `caller`"``
+
+## References
+
+- [Swift Functions](https://docs.swift.org/swift-book/documentation/the-swift-programming-language/functions/)
+- [CodeQL Call Graph Analysis](https://codeql.github.com/docs/writing-codeql-queries/about-data-flow-analysis/)

package/ql/swift/tools/src/PrintAST/PrintAST.md

@@ -0,0 +1,54 @@
+# Print AST for Swift
+
+Outputs a representation of the Abstract Syntax Tree (AST) for specified source files.
+
+## Overview
+
+The Abstract Syntax Tree is a hierarchical representation of source code structure. Each node represents a syntactic construct (declaration, statement, expression, etc.) and edges represent parent-child containment relationships.
+
+This query produces the full AST for specified Swift source files, which is useful for understanding code structure, inspecting how the CodeQL extractor parses types and functions, and debugging query logic that operates on AST nodes.
+
+## Use Cases
+
+This query is primarily used for:
+
+- Inspecting how CodeQL represents Swift structs, classes, and functions
+- Debugging queries that match on AST node types
+- Understanding parent-child relationships between declarations and expressions
+- Verifying extractor behavior for closures, optionals, and protocol conformances
+- IDE integration for syntax tree visualization
+
+## Example
+
+The following Swift code demonstrates AST structure through struct and function declarations:
+
+```swift
+struct Example {
+    let name: String
+
+    func greet() {  // Function declaration in AST
+        print("Hello, \(name)!")
+    }
+}
+
+let e = Example(name: "World")  // Initializer call in AST
+e.greet()
+```
+
+In the resulting AST:
+
+- The struct declaration contains property and function declarations as children
+- Each function body contains a brace statement with expression nodes
+- Call expressions and string interpolations reference their components as child nodes
+
+## Output Format
+
+The query produces a graph via the `PrintAstConfiguration` library:
+
+- `nodes`: Each AST node with its type, label, and properties
+- `edges`: Parent-child relationships forming the syntax tree
+
+## References
+
+- [Swift Language Guide](https://docs.swift.org/swift-book/)
+- [CodeQL Abstract Syntax Trees](https://codeql.github.com/docs/writing-codeql-queries/abstract-syntax-tree/)

package/ql/swift/tools/src/PrintCFG/PrintCFG.md

@@ -0,0 +1,55 @@
+# Print CFG for Swift
+
+Produces a representation of a file's Control Flow Graph (CFG) for specified source files.
+
+## Overview
+
+The Control Flow Graph represents the order in which statements and expressions are executed in a program. Each node in the graph represents a control-flow element (statement or expression), and edges represent possible execution paths between them.
+
+This query outputs all CFG nodes and their successor relationships for Swift code, which is useful for understanding program execution flow, debugging control flow issues, and analyzing code paths.
+
+## Use Cases
+
+This query is primarily used for:
+
+- Visualizing program execution flow
+- Understanding complex branching logic
+- Debugging control flow issues
+- Analysis of code paths and reachability
+- IDE integration for control flow visualization
+
+## Example
+
+The following Swift code demonstrates control flow through conditional statements and loops:
+
+```swift
+func example(x: Int) {
+    if x > 0 {  // Branching creates CFG edges
+        print("Positive")
+    } else {
+        print("Non-positive")
+    }
+
+    for i in 0..<3 {  // Loop creates cyclic CFG
+        print(i)
+    }
+}
+```
+
+In the resulting CFG:
+
+- The `if` condition creates two outgoing edges (true/false branches)
+- The `for-in` loop creates a cycle back to the iterator
+- Each statement connects to its successor in execution order
+
+## Output Format
+
+The query produces two relations:
+
+- `nodes(ControlFlowNode, string, string)`: Each CFG node with its label
+- `edges(ControlFlowNode, ControlFlowNode)`: Successor relationships between nodes
+
+## References
+
+- [Swift Control Flow](https://docs.swift.org/swift-book/documentation/the-swift-programming-language/controlflow/)
+- [CodeQL Control Flow Graph](https://codeql.github.com/docs/writing-codeql-queries/about-control-flow-in-codeql/)

package/ql/swift/tools/src/codeql-pack.yml

@@ -1,5 +1,5 @@
 name: advanced-security/ql-mcp-swift-tools-src
-version: 2.24.2-rc2
+version: 2.24.2
 description: 'Queries for codeql-development-mcp-server tools for swift language'
 library: false
 dependencies: