@liendev/parser 0.46.0 → 0.48.0

package/dist/ast/languages/registry.js

@@ -8,6 +8,8 @@ import { goDefinition } from './go.js';
 import { javaDefinition } from './java.js';
 import { csharpDefinition } from './csharp.js';
 import { rubyDefinition } from './ruby.js';
+import { kotlinDefinition } from './kotlin.js';
+import { swiftDefinition } from './swift.js';
 /**
  * All registered language definitions.
  * To add a new language, create a definition file and add it here.
@@ -22,6 +24,8 @@ const definitions = [
     javaDefinition,
     csharpDefinition,
     rubyDefinition,
+    kotlinDefinition,
+    swiftDefinition,
 ];
 /**
  * Canonical list of supported language IDs.
@@ -38,6 +42,8 @@ export const LANGUAGE_IDS = [
     'java',
     'csharp',
     'ruby',
+    'kotlin',
+    'swift',
 ];
 /**
  * Registry keyed by language id.

package/dist/ast/languages/registry.js.map

@@ -1 +1 @@
-{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/ast/languages/registry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/ast/languages/registry.ts"],"names":[],"mappings":"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"}

package/dist/ast/languages/swift.d.ts

@@ -0,0 +1,98 @@
+import type Parser from 'tree-sitter';
+import type { SymbolInfo } from '../types.js';
+import type { LanguageDefinition } from './types.js';
+import type { LanguageTraverser, DeclarationFunctionInfo } from '../traversers/types.js';
+import type { LanguageExportExtractor, LanguageImportExtractor, LanguageSymbolExtractor } from '../extractors/types.js';
+/**
+ * Swift AST traverser.
+ *
+ * Functions/methods/initializers live inside `class_declaration` (which covers
+ * class / struct / actor / enum / extension) and `protocol_declaration` bodies
+ * (`class_body` / `enum_class_body` / `protocol_body`). Closures can appear as
+ * property initializers (`let handler = { … }`).
+ */
+export declare class SwiftTraverser implements LanguageTraverser {
+    targetNodeTypes: string[];
+    containerTypes: string[];
+    declarationTypes: string[];
+    functionTypes: string[];
+    shouldExtractChildren(node: Parser.SyntaxNode): boolean;
+    isDeclarationWithFunction(node: Parser.SyntaxNode): boolean;
+    getContainerBody(node: Parser.SyntaxNode): Parser.SyntaxNode | null;
+    shouldTraverseChildren(node: Parser.SyntaxNode): boolean;
+    findParentContainerName(node: Parser.SyntaxNode): string | undefined;
+    findFunctionInDeclaration(node: Parser.SyntaxNode): DeclarationFunctionInfo;
+}
+/**
+ * Swift export extractor.
+ *
+ * Swift has no `export` keyword. Top-level declarations and (non-private/
+ * fileprivate) members form the file's API surface. Protocol members are
+ * implicitly part of the protocol's surface.
+ */
+export declare class SwiftExportExtractor implements LanguageExportExtractor {
+    extractExports(rootNode: Parser.SyntaxNode): string[];
+    private extractFromNode;
+    private extractMembers;
+}
+/**
+ * Swift import extractor.
+ *
+ * Handles `import Foundation`, dotted `import Combine.Just`, and import-kind
+ * forms (`import struct Combine.Just` — the `struct`/`class`/… keyword is an
+ * anonymous token and is ignored; the module path is what matters). Only the
+ * `Swift` stdlib module is filtered out.
+ */
+export declare class SwiftImportExtractor implements LanguageImportExtractor {
+    readonly importNodeTypes: string[];
+    extractImportPath(node: Parser.SyntaxNode): string | null;
+    processImportSymbols(node: Parser.SyntaxNode): {
+        importPath: string;
+        symbols: string[];
+    } | null;
+    private getImportPath;
+}
+/**
+ * Swift symbol extractor.
+ *
+ * Handles `function_declaration`, `init`/`deinit`/`subscript` declarations,
+ * `class_declaration` (class / struct / actor / enum / extension — distinguished
+ * by the `declaration_kind` keyword), and `protocol_declaration`. `SymbolInfo.type`
+ * only has `function|method|class|interface`, so struct/actor/enum/extension map
+ * to `class` (keeping the real keyword in the signature) and protocol maps to
+ * `interface`.
+ *
+ * Call sites: `call_expression` — `foo()` (simple_identifier callee) and
+ * `a.b.c()` (the member is the `simple_identifier` in the trailing
+ * `navigation_suffix`).
+ */
+export declare class SwiftSymbolExtractor implements LanguageSymbolExtractor {
+    readonly symbolNodeTypes: string[];
+    extractSymbol(node: Parser.SyntaxNode, content: string, parentClass?: string): SymbolInfo | null;
+    /**
+     * Resolve a call site to the called symbol name. Dependency matching is by
+     * bare name (call.symbol === symbol.name), so the name we record determines
+     * which definition the call links to.
+     *
+     * Constructor calls are worth a note: Swift spells initialization `Foo(...)`
+     * (no `new`), so the callee is the type name and we record `Foo` — linking the
+     * call to the type's `class_declaration` symbol, exactly as JS records
+     * `new Foo()` against the class and Python records `Foo()`. So blast-radius for
+     * "who constructs Foo" is found via the TYPE symbol (a safe over-approximation),
+     * not the `init` method symbol. An explicit `Foo.init()` records `init` and
+     * links the initializer directly. The standalone `init`/`deinit`/`subscript`
+     * symbols are definitions for search/listing (as Java emits constructor
+     * symbols); they intentionally carry no implicit-`Foo()` caller edges.
+     */
+    extractCallSite(node: Parser.SyntaxNode): {
+        symbol: string;
+        line: number;
+        key: string;
+    } | null;
+    private extractFunctionInfo;
+    private extractClassInfo;
+    private extractProtocolInfo;
+    private makeSymbol;
+}
+export declare const swiftDefinition: LanguageDefinition;
+//# sourceMappingURL=swift.d.ts.map

package/dist/ast/languages/swift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swift.d.ts","sourceRoot":"","sources":["../../../src/ast/languages/swift.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACzF,OAAO,KAAK,EACV,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,EACxB,MAAM,wBAAwB,CAAC;AA4GhC;;;;;;;GAOG;AACH,qBAAa,cAAe,YAAW,iBAAiB;IACtD,eAAe,WAMb;IAEF,cAAc,WAAiD;IAE/D,gBAAgB,WAA4B;IAE5C,aAAa,WAAsB;IAEnC,qBAAqB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,OAAO;IAIvD,yBAAyB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,OAAO;IAI3D,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,GAAG,IAAI;IAKnE,sBAAsB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,OAAO;IASxD,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,GAAG,SAAS;IAWpE,yBAAyB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,uBAAuB;CAS5E;AAMD;;;;;;GAMG;AACH,qBAAa,oBAAqB,YAAW,uBAAuB;IAClE,cAAc,CAAC,QAAQ,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,EAAE;IAgBrD,OAAO,CAAC,eAAe;IAsBvB,OAAO,CAAC,cAAc;CA4BvB;AAcD;;;;;;;GAOG;AACH,qBAAa,oBAAqB,YAAW,uBAAuB;IAClE,QAAQ,CAAC,eAAe,WAA0B;IAElD,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,GAAG,IAAI;IAMzD,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,IAAI;IAS/F,OAAO,CAAC,aAAa;CAGtB;AAMD;;;;;;;;;;;;;GAaG;AACH,qBAAa,oBAAqB,YAAW,uBAAuB;IAClE,QAAQ,CAAC,eAAe,WAQtB;IAEF,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAiBhG;;;;;;;;;;;;;;OAcG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAqB9F,OAAO,CAAC,mBAAmB;IAqB3B,OAAO,CAAC,gBAAgB;IAOxB,OAAO,CAAC,mBAAmB;IAM3B,OAAO,CAAC,UAAU;CAcnB;AAMD,eAAO,MAAM,eAAe,EAAE,kBA0I7B,CAAC"}

package/dist/ast/languages/swift.js

@@ -0,0 +1,529 @@
+import Swift from 'tree-sitter-swift';
+import { extractSignature, extractReturnType } from '../extractors/symbol-helpers.js';
+import { calculateComplexity } from '../complexity/index.js';
+// =============================================================================
+// HELPERS
+//
+// The tree-sitter-swift grammar (alex-pinkus) DOES expose field names
+// (`name`, `body`, `return_type`, `declaration_kind`, …), so — unlike Kotlin —
+// we use `childForFieldName` like the Java definition. The Swift-specific
+// wrinkles are: class/struct/actor/enum/extension all share the
+// `class_declaration` node (distinguished by the `declaration_kind` keyword),
+// parameters are bare `parameter` children (no `parameters` wrapper field), and
+// visibility lives under a `modifiers` child.
+// =============================================================================
+/** First named child of a given type. */
+function childByType(node, type) {
+    return node.namedChildren.find(child => child.type === type) ?? null;
+}
+/** First descendant of a given type (depth-first), or null. */
+function findFirst(node, type) {
+    for (const child of node.namedChildren) {
+        if (child.type === type)
+            return child;
+        const found = findFirst(child, type);
+        if (found)
+            return found;
+    }
+    return null;
+}
+/**
+ * The `class_declaration` keyword (`class` / `struct` / `actor` / `enum` /
+ * `extension`), read from the `declaration_kind` field. Defaults to `class`.
+ */
+function declarationKeyword(node) {
+    return node.childForFieldName('declaration_kind')?.text ?? 'class';
+}
+/** The declared name of a class/protocol declaration (handles `extension`'s `user_type`). */
+function declarationName(node) {
+    return node.childForFieldName('name')?.text;
+}
+/**
+ * The name of a function-like node. Swift's `init`/`deinit`/`subscript`
+ * declarations have no `name` field — fall back to the keyword.
+ */
+function functionLikeName(node) {
+    const name = node.childForFieldName('name')?.text;
+    if (name)
+        return name;
+    switch (node.type) {
+        case 'init_declaration':
+            return 'init';
+        case 'deinit_declaration':
+            return 'deinit';
+        case 'subscript_declaration':
+            return 'subscript';
+        default:
+            return undefined;
+    }
+}
+/** Parameter texts. Swift function params are bare `parameter` children (no field). */
+function swiftParameters(node) {
+    return node.namedChildren.filter(c => c.type === 'parameter' && c.text.trim()).map(c => c.text);
+}
+/**
+ * The function-valued initializer of a property, if the property's value is
+ * *directly* a closure (`let handler = { … }`). Checks the `value` field rather
+ * than any descendant, so a closure passed as a call argument
+ * (`let n = xs.map { … }`) is NOT treated as a function-valued property.
+ */
+function propertyInitializerFunction(node) {
+    const value = node.childForFieldName('value');
+    return value?.type === 'lambda_literal' ? value : null;
+}
+/** Visibility modifier text (`public` / `private` / `fileprivate` / `internal` / `open`), if any. */
+function visibilityModifier(node) {
+    const modifiers = childByType(node, 'modifiers');
+    if (!modifiers)
+        return null;
+    return modifiers.namedChildren.find(c => c.type === 'visibility_modifier')?.text ?? null;
+}
+/**
+ * Swift declarations are `internal` (module-visible) by default. We treat a
+ * declaration as "exported" (part of the file's API surface) unless it is
+ * explicitly `private` or `fileprivate` — so default/`internal`/`public`/`open`
+ * are surfaced. (Analogous to Kotlin's "public unless private/internal".)
+ */
+function isExported(node) {
+    const visibility = visibilityModifier(node);
+    return visibility !== 'private' && visibility !== 'fileprivate';
+}
+/** The property's bound identifier (`let foo = …` → `foo`). */
+function propertyName(node) {
+    const pattern = node.childForFieldName('name');
+    if (!pattern)
+        return undefined;
+    return findFirst(pattern, 'simple_identifier')?.text ?? pattern.text;
+}
+// =============================================================================
+// TRAVERSER
+// =============================================================================
+/**
+ * Swift AST traverser.
+ *
+ * Functions/methods/initializers live inside `class_declaration` (which covers
+ * class / struct / actor / enum / extension) and `protocol_declaration` bodies
+ * (`class_body` / `enum_class_body` / `protocol_body`). Closures can appear as
+ * property initializers (`let handler = { … }`).
+ */
+export class SwiftTraverser {
+    targetNodeTypes = [
+        'function_declaration',
+        'protocol_function_declaration', // abstract method requirements inside a protocol
+        'init_declaration',
+        'deinit_declaration',
+        'subscript_declaration',
+    ];
+    containerTypes = ['class_declaration', 'protocol_declaration'];
+    declarationTypes = ['property_declaration'];
+    functionTypes = ['lambda_literal'];
+    shouldExtractChildren(node) {
+        return this.containerTypes.includes(node.type);
+    }
+    isDeclarationWithFunction(node) {
+        return node.type === 'property_declaration' && propertyInitializerFunction(node) !== null;
+    }
+    getContainerBody(node) {
+        if (!this.containerTypes.includes(node.type))
+            return null;
+        return node.childForFieldName('body');
+    }
+    shouldTraverseChildren(node) {
+        return (node.type === 'source_file' ||
+            node.type === 'class_body' ||
+            node.type === 'enum_class_body' ||
+            node.type === 'protocol_body');
+    }
+    findParentContainerName(node) {
+        let current = node.parent;
+        while (current) {
+            if (current.type === 'class_declaration' || current.type === 'protocol_declaration') {
+                return declarationName(current);
+            }
+            current = current.parent;
+        }
+        return undefined;
+    }
+    findFunctionInDeclaration(node) {
+        if (node.type !== 'property_declaration') {
+            return { hasFunction: false, functionNode: null };
+        }
+        const fn = propertyInitializerFunction(node);
+        return fn
+            ? { hasFunction: true, functionNode: fn }
+            : { hasFunction: false, functionNode: null };
+    }
+}
+// =============================================================================
+// EXPORT EXTRACTOR
+// =============================================================================
+/**
+ * Swift export extractor.
+ *
+ * Swift has no `export` keyword. Top-level declarations and (non-private/
+ * fileprivate) members form the file's API surface. Protocol members are
+ * implicitly part of the protocol's surface.
+ */
+export class SwiftExportExtractor {
+    extractExports(rootNode) {
+        const exports = [];
+        const seen = new Set();
+        const addExport = (name) => {
+            if (name && !seen.has(name)) {
+                seen.add(name);
+                exports.push(name);
+            }
+        };
+        rootNode.namedChildren.forEach(child => this.extractFromNode(child, addExport));
+        return exports;
+    }
+    extractFromNode(node, addExport) {
+        switch (node.type) {
+            case 'function_declaration':
+            case 'init_declaration':
+            case 'deinit_declaration':
+            case 'subscript_declaration':
+                if (isExported(node))
+                    addExport(functionLikeName(node));
+                break;
+            case 'property_declaration':
+                if (isExported(node))
+                    addExport(propertyName(node));
+                break;
+            case 'class_declaration':
+            case 'protocol_declaration':
+                // A private/fileprivate container exposes nothing — skip it and its members.
+                if (isExported(node)) {
+                    addExport(declarationName(node));
+                    this.extractMembers(node, addExport);
+                }
+                break;
+        }
+    }
+    extractMembers(container, addExport) {
+        const body = container.childForFieldName('body');
+        if (!body)
+            return;
+        // Protocol members are implicitly part of the protocol's surface.
+        const isProtocol = container.type === 'protocol_declaration';
+        body.namedChildren.forEach(member => {
+            switch (member.type) {
+                case 'function_declaration':
+                case 'protocol_function_declaration':
+                case 'init_declaration':
+                case 'deinit_declaration':
+                case 'subscript_declaration':
+                    if (isProtocol || isExported(member))
+                        addExport(functionLikeName(member));
+                    break;
+                case 'property_declaration':
+                case 'protocol_property_declaration':
+                    if (isProtocol || isExported(member))
+                        addExport(propertyName(member));
+                    break;
+                case 'class_declaration':
+                case 'protocol_declaration':
+                    // Nested types — recurse so their names/members are surfaced too.
+                    this.extractFromNode(member, addExport);
+                    break;
+            }
+        });
+    }
+}
+// =============================================================================
+// IMPORT EXTRACTOR
+// =============================================================================
+/**
+ * The Swift standard library module. `Foundation`, `UIKit`, `SwiftUI`,
+ * `Combine`, etc. are real external frameworks and are kept as import edges.
+ */
+function isSwiftStdLib(importPath) {
+    return importPath === 'Swift' || importPath.startsWith('Swift.');
+}
+/**
+ * Swift import extractor.
+ *
+ * Handles `import Foundation`, dotted `import Combine.Just`, and import-kind
+ * forms (`import struct Combine.Just` — the `struct`/`class`/… keyword is an
+ * anonymous token and is ignored; the module path is what matters). Only the
+ * `Swift` stdlib module is filtered out.
+ */
+export class SwiftImportExtractor {
+    importNodeTypes = ['import_declaration'];
+    extractImportPath(node) {
+        const path = this.getImportPath(node);
+        if (!path || isSwiftStdLib(path))
+            return null;
+        return path;
+    }
+    processImportSymbols(node) {
+        const path = this.getImportPath(node);
+        if (!path || isSwiftStdLib(path))
+            return null;
+        const parts = path.split('.');
+        const lastPart = parts[parts.length - 1];
+        return { importPath: path, symbols: [lastPart] };
+    }
+    getImportPath(node) {
+        return childByType(node, 'identifier')?.text ?? null;
+    }
+}
+// =============================================================================
+// SYMBOL EXTRACTOR
+// =============================================================================
+/**
+ * Swift symbol extractor.
+ *
+ * Handles `function_declaration`, `init`/`deinit`/`subscript` declarations,
+ * `class_declaration` (class / struct / actor / enum / extension — distinguished
+ * by the `declaration_kind` keyword), and `protocol_declaration`. `SymbolInfo.type`
+ * only has `function|method|class|interface`, so struct/actor/enum/extension map
+ * to `class` (keeping the real keyword in the signature) and protocol maps to
+ * `interface`.
+ *
+ * Call sites: `call_expression` — `foo()` (simple_identifier callee) and
+ * `a.b.c()` (the member is the `simple_identifier` in the trailing
+ * `navigation_suffix`).
+ */
+export class SwiftSymbolExtractor {
+    symbolNodeTypes = [
+        'function_declaration',
+        'protocol_function_declaration',
+        'init_declaration',
+        'deinit_declaration',
+        'subscript_declaration',
+        'class_declaration',
+        'protocol_declaration',
+    ];
+    extractSymbol(node, content, parentClass) {
+        switch (node.type) {
+            case 'function_declaration':
+            case 'protocol_function_declaration':
+            case 'init_declaration':
+            case 'deinit_declaration':
+            case 'subscript_declaration':
+                return this.extractFunctionInfo(node, content, parentClass);
+            case 'class_declaration':
+                return this.extractClassInfo(node);
+            case 'protocol_declaration':
+                return this.extractProtocolInfo(node);
+            default:
+                return null;
+        }
+    }
+    /**
+     * Resolve a call site to the called symbol name. Dependency matching is by
+     * bare name (call.symbol === symbol.name), so the name we record determines
+     * which definition the call links to.
+     *
+     * Constructor calls are worth a note: Swift spells initialization `Foo(...)`
+     * (no `new`), so the callee is the type name and we record `Foo` — linking the
+     * call to the type's `class_declaration` symbol, exactly as JS records
+     * `new Foo()` against the class and Python records `Foo()`. So blast-radius for
+     * "who constructs Foo" is found via the TYPE symbol (a safe over-approximation),
+     * not the `init` method symbol. An explicit `Foo.init()` records `init` and
+     * links the initializer directly. The standalone `init`/`deinit`/`subscript`
+     * symbols are definitions for search/listing (as Java emits constructor
+     * symbols); they intentionally carry no implicit-`Foo()` caller edges.
+     */
+    extractCallSite(node) {
+        if (node.type !== 'call_expression')
+            return null;
+        const line = node.startPosition.row + 1;
+        const callee = node.namedChild(0);
+        if (!callee)
+            return null;
+        let name;
+        if (callee.type === 'simple_identifier') {
+            name = callee.text; // foo() / Foo() constructor — links to the fn or type symbol
+        }
+        else if (callee.type === 'navigation_expression') {
+            // a.b.c() / Mod.Type() / Type.init() — the called member is the
+            // simple_identifier in the last navigation_suffix
+            const suffix = callee.namedChildren.filter(c => c.type === 'navigation_suffix').at(-1);
+            name = suffix ? (findFirst(suffix, 'simple_identifier')?.text ?? undefined) : undefined;
+        }
+        if (!name)
+            return null;
+        return { symbol: name, line, key: `${name}:${line}` };
+    }
+    extractFunctionInfo(node, content, parentClass) {
+        const name = functionLikeName(node);
+        if (!name)
+            return null;
+        return {
+            name,
+            type: parentClass ? 'method' : 'function',
+            startLine: node.startPosition.row + 1,
+            endLine: node.endPosition.row + 1,
+            parentClass,
+            signature: extractSignature(node, content),
+            parameters: swiftParameters(node),
+            returnType: extractReturnType(node, content),
+            complexity: calculateComplexity(node),
+        };
+    }
+    extractClassInfo(node) {
+        const name = declarationName(node);
+        if (!name)
+            return null;
+        const keyword = declarationKeyword(node);
+        return this.makeSymbol(node, name, 'class', `${keyword} ${name}`);
+    }
+    extractProtocolInfo(node) {
+        const name = declarationName(node);
+        if (!name)
+            return null;
+        return this.makeSymbol(node, name, 'interface', `protocol ${name}`);
+    }
+    makeSymbol(node, name, type, signature) {
+        return {
+            name,
+            type,
+            startLine: node.startPosition.row + 1,
+            endLine: node.endPosition.row + 1,
+            signature,
+        };
+    }
+}
+// =============================================================================
+// LANGUAGE DEFINITION
+// =============================================================================
+export const swiftDefinition = {
+    id: 'swift',
+    extensions: ['swift'],
+    grammar: Swift,
+    traverser: new SwiftTraverser(),
+    exportExtractor: new SwiftExportExtractor(),
+    importExtractor: new SwiftImportExtractor(),
+    symbolExtractor: new SwiftSymbolExtractor(),
+    complexity: {
+        decisionPoints: [
+            'if_statement',
+            'guard_statement',
+            'switch_entry', // each `case` / `default` branch
+            'for_statement',
+            'while_statement',
+            'repeat_while_statement',
+            'catch_block',
+            'conjunction_expression', // &&
+            'disjunction_expression', // ||
+            'nil_coalescing_expression', // ??
+            'ternary_expression',
+        ],
+        nestingTypes: [
+            'if_statement',
+            'guard_statement',
+            'switch_statement',
+            'for_statement',
+            'while_statement',
+            'repeat_while_statement',
+            'do_statement',
+            'catch_block',
+            'lambda_literal',
+        ],
+        nonNestingTypes: [
+            'switch_entry',
+            'conjunction_expression',
+            'disjunction_expression',
+            'nil_coalescing_expression',
+            'ternary_expression',
+        ],
+        lambdaTypes: ['lambda_literal'],
+        operatorSymbols: new Set([
+            '+',
+            '-',
+            '*',
+            '/',
+            '%',
+            '==',
+            '!=',
+            '===',
+            '!==',
+            '<',
+            '>',
+            '<=',
+            '>=',
+            '=',
+            '+=',
+            '-=',
+            '*=',
+            '/=',
+            '%=',
+            '&&',
+            '||',
+            '!',
+            '??',
+            '?.',
+            '.',
+            '->',
+            '..<',
+            '...',
+            '(',
+            ')',
+            '[',
+            ']',
+            '{',
+            '}',
+        ]),
+        operatorKeywords: new Set([
+            'if',
+            'else',
+            'guard',
+            'switch',
+            'case',
+            'default',
+            'for',
+            'while',
+            'repeat',
+            'do',
+            'return',
+            'break',
+            'continue',
+            'fallthrough',
+            'throw',
+            'throws',
+            'try',
+            'catch',
+            'defer',
+            'func',
+            'class',
+            'struct',
+            'actor',
+            'enum',
+            'protocol',
+            'extension',
+            'init',
+            'deinit',
+            'subscript',
+            'var',
+            'let',
+            'is',
+            'as',
+            'in',
+            'where',
+            'some',
+            'any',
+            'async',
+            'await',
+            'import',
+            'static',
+            'final',
+            'lazy',
+            'weak',
+            'override',
+            'private',
+            'fileprivate',
+            'internal',
+            'public',
+            'open',
+            'self',
+            'super',
+            'nil',
+        ]),
+    },
+    symbols: {
+        callExpressionTypes: ['call_expression'],
+    },
+};
+//# sourceMappingURL=swift.js.map