code-explore-by-sql 0.1.0__py3-none-any.whl

code_source_sql/languages/javascript.py

@@ -0,0 +1,215 @@
+"""JavaScript / TypeScript language configuration."""
+
+from __future__ import annotations
+
+import re
+
+from ..configs import LanguageConfig
+
+_NEVER_MATCH = re.compile(r"(?!x)x")
+
+
+def make_javascript_language() -> LanguageConfig:
+    """JavaScript language configuration."""
+    return LanguageConfig(
+        name="javascript",
+        class_re=re.compile(
+            r"(?:^|\s)(?:export\s+)?(?:default\s+)?(?:abstract\s+)?(class)\s+(\w+)"
+            r"(?:\s+extends\s+(\w+))?"
+        ),
+        enum_re=_NEVER_MATCH,
+        namespace_re=_NEVER_MATCH,
+        func_name_re=re.compile(
+            r"(?:async\s+)?(?:function\s+)?"
+            r"(?:get\s+|set\s+|static\s+|async\s+)*"
+            r"(\w+)\s*\("
+        ),
+        export_macro_re=_NEVER_MATCH,
+        calling_conv_re=_NEVER_MATCH,
+        attribute_re=_NEVER_MATCH,
+        template_re=_NEVER_MATCH,
+        dtor_re=_NEVER_MATCH,
+        control_flow_re=re.compile(
+            r"\b(if|else\s+if|else|while|for|do|switch|catch|try|finally)\b"
+        ),
+        control_flow_names=frozenset({
+            "if", "else", "while", "for", "do", "switch", "catch", "try", "finally",
+            "return", "break", "continue", "throw", "yield", "await", "new",
+            "delete", "typeof", "instanceof",
+        }),
+        trailing_mods_re=_NEVER_MATCH,
+        access_spec_re=_NEVER_MATCH,
+        macro_like_re=_NEVER_MATCH,
+        define_re=_NEVER_MATCH,
+        extern_c_re=_NEVER_MATCH,
+        operator_re=None,
+        uses_braces=True,
+        uses_namespaces=False,
+        uses_colon_inheritance=True,
+        scope_operator=".",
+        base_keyword="super",
+        static_call_re=re.compile(
+            r"\b([A-Z][A-Za-z0-9_]+)\.([A-Za-z_][A-Za-z0-9_]*)\s*\("
+        ),
+        super_call_re=re.compile(
+            r"\bsuper\.([A-Za-z_][A-Za-z0-9_]*)\s*\("
+        ),
+        type_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)\b"),
+        param_type_re=_NEVER_MATCH,
+        basic_skip_types=frozenset({
+            "Object", "Array", "String", "Number", "Boolean", "Symbol", "BigInt",
+            "Promise", "Map", "Set", "WeakMap", "WeakSet", "Date", "RegExp",
+            "Error", "Math", "JSON", "console", "undefined", "null", "NaN",
+            "Infinity",
+        }),
+        block_keyword_re=re.compile(r"\b(?:class|function)\b"),
+        lambda_re=re.compile(r"=>"),
+        namespace_sig_re=None,
+        init_list_re=None,
+        access_spec_names=frozenset(),
+        view_structural_kws=("class ", "function "),
+        view_modifier_kws=("async ", "static ", "get ", "set "),
+        local_var_modifiers="const|let|var",
+        verbatim_string_prefix=None,
+        raw_string_char=None,
+        range_for_re=re.compile(
+            r"for\s*\(\s*(?:const|let|var)?\s*(\w+)\s+of\s+(\w+)"
+        ),
+        # Comment syntax
+        line_comment="//",
+        block_comment_pair=("/*", "*/"),
+        # String syntax
+        string_delimiters=frozenset({'"', "'"}),
+        string_escape_char="\\",
+        triple_quote_strings=(),
+        # Block style
+        uses_indent_blocks=False,
+        # Preprocessor
+        preprocessor_prefix="",
+        has_preprocessor_macros=False,
+        # Statement / block close
+        statement_terminator=";",
+        block_close_suffix="}",
+        summary_comment_prefix="//",
+        # Config-driven control flow
+        control_flow_patterns=(
+            ("for", re.compile(r"^\s*for\s+\((.{1,80})\)\s*\{?\s*$")),
+            ("while", re.compile(r"^\s*while\s+\((.{1,80})\)\s*\{?\s*$")),
+            ("if", re.compile(r"^\s*(?:else\s+)?if\s+\((.{1,80})\)\s*\{?\s*$")),
+            ("switch", re.compile(r"^\s*switch\s+\((.{1,40})\)\s*\{?\s*$")),
+        ),
+        return_re=re.compile(r"^\s*return\s+(.{1,60});"),
+        # Extra syntax hints
+        type_indicator_chars="",
+        define_line_re=None,
+        has_template_strings=True,
+        raw_string_style="cpp",
+    )
+
+
+def make_typescript_language() -> LanguageConfig:
+    """TypeScript language configuration."""
+    return LanguageConfig(
+        name="typescript",
+        class_re=re.compile(
+            r"(?:^|\s)(?:export\s+)?(?:default\s+)?(?:abstract\s+)?(class)\s+(\w+)"
+            r"(?:\s+extends\s+(\w+))?"
+        ),
+        enum_re=re.compile(r"\benum\s+(\w+)"),
+        namespace_re=re.compile(r"\bnamespace\s+(\w+)"),
+        func_name_re=re.compile(
+            r"(?:async\s+)?(?:function\s+)?"
+            r"(?:get\s+|set\s+|static\s+|async\s+|abstract\s+)*"
+            r"(\w+)\s*[(<]"
+        ),
+        export_macro_re=_NEVER_MATCH,
+        calling_conv_re=_NEVER_MATCH,
+        attribute_re=re.compile(r"@\w+(?:\.\w+)*(?:\([^)]*\))?"),
+        template_re=re.compile(r"<[^<>]*>"),
+        dtor_re=_NEVER_MATCH,
+        control_flow_re=re.compile(
+            r"\b(if|else\s+if|else|while|for|do|switch|catch|try|finally)\b"
+        ),
+        control_flow_names=frozenset({
+            "if", "else", "while", "for", "do", "switch", "catch", "try", "finally",
+            "return", "break", "continue", "throw", "yield", "await", "new",
+            "delete", "typeof", "instanceof",
+        }),
+        trailing_mods_re=_NEVER_MATCH,
+        access_spec_re=_NEVER_MATCH,
+        macro_like_re=_NEVER_MATCH,
+        define_re=_NEVER_MATCH,
+        extern_c_re=_NEVER_MATCH,
+        operator_re=None,
+        uses_braces=True,
+        uses_namespaces=False,
+        uses_colon_inheritance=True,
+        scope_operator=".",
+        base_keyword="super",
+        static_call_re=re.compile(
+            r"\b([A-Z][A-Za-z0-9_]+)\.([A-Za-z_][A-Za-z0-9_]*)\s*\("
+        ),
+        super_call_re=re.compile(
+            r"\bsuper\.([A-Za-z_][A-Za-z0-9_]*)\s*\("
+        ),
+        type_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)\b"),
+        param_type_re=re.compile(r"(\w+)\s*:\s*([A-Z][A-Za-z0-9_]+)"),
+        basic_skip_types=frozenset({
+            "Object", "Array", "String", "Number", "Boolean", "Symbol", "BigInt",
+            "Promise", "Map", "Set", "WeakMap", "WeakSet", "Date", "RegExp",
+            "Error", "Math", "JSON", "console", "undefined", "null", "NaN",
+            "Infinity",
+            # TypeScript-specific
+            "string", "number", "boolean", "void", "never", "unknown", "any",
+            "object", "symbol", "bigint",
+            "Record", "Partial", "Required", "Readonly", "Pick", "Omit",
+            "Exclude", "Extract",
+        }),
+        block_keyword_re=re.compile(
+            r"\b(?:class|function|interface|enum|namespace|type)\b"
+        ),
+        lambda_re=re.compile(r"=>"),
+        func_sig_end_re=re.compile(r"\)\s*(?::\s*\w[\w<>\[\]| ]*)?\s*\{?\s*$"),
+        namespace_sig_re=None,
+        init_list_re=None,
+        access_spec_names=frozenset(),
+        view_structural_kws=(
+            "class ", "function ", "interface ", "enum ", "namespace ", "type ",
+        ),
+        view_modifier_kws=("async ", "static ", "get ", "set "),
+        local_var_modifiers="const|let|var",
+        verbatim_string_prefix=None,
+        raw_string_char=None,
+        range_for_re=re.compile(
+            r"for\s*\(\s*(?:const|let|var)?\s*(\w+)\s+of\s+(\w+)"
+        ),
+        # Comment syntax
+        line_comment="//",
+        block_comment_pair=("/*", "*/"),
+        # String syntax
+        string_delimiters=frozenset({'"', "'"}),
+        string_escape_char="\\",
+        triple_quote_strings=(),
+        # Block style
+        uses_indent_blocks=False,
+        # Preprocessor
+        preprocessor_prefix="",
+        has_preprocessor_macros=False,
+        # Statement / block close
+        statement_terminator=";",
+        block_close_suffix="}",
+        summary_comment_prefix="//",
+        # Config-driven control flow
+        control_flow_patterns=(
+            ("for", re.compile(r"^\s*for\s+\((.{1,80})\)\s*\{?\s*$")),
+            ("while", re.compile(r"^\s*while\s+\((.{1,80})\)\s*\{?\s*$")),
+            ("if", re.compile(r"^\s*(?:else\s+)?if\s+\((.{1,80})\)\s*\{?\s*$")),
+            ("switch", re.compile(r"^\s*switch\s+\((.{1,40})\)\s*\{?\s*$")),
+        ),
+        return_re=re.compile(r"^\s*return\s+(.{1,60});"),
+        # Extra syntax hints
+        type_indicator_chars="",
+        define_line_re=None,
+        has_template_strings=True,
+        raw_string_style="cpp",
+    )

code_source_sql/languages/kotlin.py

@@ -0,0 +1,108 @@
+"""Kotlin language configuration."""
+
+from __future__ import annotations
+
+import re
+
+from ..configs import LanguageConfig
+
+_NEVER_MATCH = re.compile(r"(?!x)x")
+
+
+def make_kotlin_language() -> LanguageConfig:
+    """Kotlin language configuration."""
+    return LanguageConfig(
+        name="kotlin",
+        class_re=re.compile(
+            r"(?:(?:public|private|protected|internal|abstract|final|open|sealed|data|inner|companion)\s+)*"
+            r"(class|interface|object)\s+(\w+)"
+            r"(?:\s*:\s*(\w+))?"
+        ),
+        enum_re=re.compile(r"\benum\s+class\s+(\w+)"),
+        namespace_re=re.compile(r"\bpackage\s+([\w.]+)"),
+        func_name_re=re.compile(
+            r"(?:(?:public|private|protected|internal)\s+)?"
+            r"(?:suspend\s+)?"
+            r"fun\s+(?:<[^>]*>\s+)?(?:\w+\.)?(\w+)\s*\("
+        ),
+        export_macro_re=_NEVER_MATCH,
+        calling_conv_re=_NEVER_MATCH,
+        attribute_re=re.compile(r"@\w+(?:\.\w+)*(?:\([^)]*\))?"),
+        template_re=re.compile(r"<[^<>]*>"),
+        dtor_re=_NEVER_MATCH,
+        control_flow_re=re.compile(
+            r"\b(if|else\s+if|else|while|for|do|when|try|catch|finally)\b"
+        ),
+        control_flow_names=frozenset({
+            "if", "else", "while", "for", "do", "when", "try", "catch", "finally",
+            "return", "break", "continue", "throw", "yield", "suspend",
+        }),
+        trailing_mods_re=_NEVER_MATCH,
+        access_spec_re=_NEVER_MATCH,
+        macro_like_re=_NEVER_MATCH,
+        define_re=_NEVER_MATCH,
+        extern_c_re=_NEVER_MATCH,
+        operator_re=None,
+        uses_braces=True,
+        uses_namespaces=False,
+        uses_colon_inheritance=True,
+        scope_operator=".",
+        base_keyword="super",
+        static_call_re=re.compile(
+            r"\b([A-Z][A-Za-z0-9_]+)\.([A-Za-z_][A-Za-z0-9_]*)\s*\("
+        ),
+        super_call_re=re.compile(
+            r"\bsuper\.([A-Za-z_][A-Za-z0-9_]*)\s*\("
+        ),
+        type_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)\b"),
+        param_type_re=re.compile(r"(\w+)\s*:\s*([A-Z][A-Za-z0-9_]+)"),
+        basic_skip_types=frozenset({
+            "Int", "Long", "Short", "Byte", "Float", "Double", "Boolean", "Char",
+            "String", "Unit", "Nothing", "Any", "Array", "List", "Set", "Map",
+            "MutableList", "MutableSet", "MutableMap",
+        }),
+        block_keyword_re=re.compile(r"\b(?:class|interface|object|fun|enum)\b"),
+        lambda_re=re.compile(r"\{"),
+        namespace_sig_re=None,
+        init_list_re=None,
+        access_spec_names=frozenset(),
+        view_structural_kws=(
+            "class ", "interface ", "object ", "fun ", "enum class ",
+        ),
+        view_modifier_kws=(
+            "suspend ", "inline ", "abstract ", "open ", "data ", "sealed ",
+        ),
+        local_var_modifiers="val|var|const|lateinit",
+        verbatim_string_prefix=None,
+        raw_string_char=None,
+        range_for_re=re.compile(r"for\s*\(\s*(\w+)\s+in\s+(\w+)"),
+        # Comment syntax
+        line_comment="//",
+        block_comment_pair=("/*", "*/"),
+        # String syntax
+        string_delimiters=frozenset({'"'}),
+        string_escape_char="\\",
+        triple_quote_strings=(),
+        # Block style
+        uses_indent_blocks=False,
+        # Preprocessor
+        preprocessor_prefix="",
+        has_preprocessor_macros=False,
+        # Statement / block close
+        statement_terminator="",
+        block_close_suffix="}",
+        summary_comment_prefix="//",
+        # Config-driven control flow
+        control_flow_patterns=(
+            ("for", re.compile(r"^\s*for\s+\((.{1,80})\)\s*\{?\s*$")),
+            ("while", re.compile(r"^\s*while\s+\((.{1,80})\)\s*\{?\s*$")),
+            ("if", re.compile(r"^\s*(?:else\s+)?if\s+\((.{1,80})\)\s*\{?\s*$")),
+            ("when", re.compile(r"^\s*when\s+(?:\((.{1,40})\)\s*)?\{?\s*$")),
+        ),
+        return_re=re.compile(r"^\s*return\s+(.{1,60})"),
+        # Extra syntax hints
+        type_indicator_chars="",
+        define_line_re=None,
+        has_template_strings=False,
+        raw_string_style="cpp",
+    )

code_source_sql/languages/python.py

@@ -0,0 +1,105 @@
+"""Python language configuration."""
+
+from __future__ import annotations
+
+import re
+
+from ..configs import LanguageConfig
+
+_NEVER_MATCH = re.compile(r"(?!x)x")
+
+
+def make_python_language() -> LanguageConfig:
+    """Python language configuration."""
+    return LanguageConfig(
+        name="python",
+        class_re=re.compile(
+            r"^\s*(class)\s+(\w+)(?:\s*\(\s*(\w+))?[^:]*:"
+        ),
+        enum_re=_NEVER_MATCH,
+        namespace_re=_NEVER_MATCH,
+        func_name_re=re.compile(r"(\w+)\s*\([^)]*\)\s*(?:\s*->.*?)?\s*:\s*$"),
+        export_macro_re=_NEVER_MATCH,
+        calling_conv_re=_NEVER_MATCH,
+        attribute_re=re.compile(r"@\w+(?:\.\w+)*(?:\([^)]*\))?"),
+        template_re=_NEVER_MATCH,
+        dtor_re=_NEVER_MATCH,
+        control_flow_re=re.compile(
+            r"^\s*(?:if|elif|else|while|for|try|except|finally|with|match|case)\b"
+        ),
+        control_flow_names=frozenset({
+            "if", "elif", "else", "while", "for", "try", "except", "finally",
+            "with", "match", "case", "return", "yield", "break", "continue",
+            "raise", "pass", "del", "global", "nonlocal", "assert", "import",
+            "from",
+        }),
+        trailing_mods_re=_NEVER_MATCH,
+        access_spec_re=_NEVER_MATCH,
+        macro_like_re=_NEVER_MATCH,
+        define_re=_NEVER_MATCH,
+        extern_c_re=_NEVER_MATCH,
+        operator_re=None,
+        uses_braces=False,
+        uses_namespaces=False,
+        uses_colon_inheritance=True,
+        scope_operator=".",
+        base_keyword="super()",
+        static_call_re=re.compile(
+            r"\b([A-Z][A-Za-z0-9_]+)\.([A-Za-z_][A-Za-z0-9_]*)\s*\("
+        ),
+        super_call_re=re.compile(
+            r"\bsuper\(\)\.([A-Za-z_][A-Za-z0-9_]*)\s*\("
+        ),
+        type_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)\b"),
+        param_type_re=re.compile(r"(\w+)\s*:\s*([A-Z][A-Za-z0-9_]+)"),
+        basic_skip_types=frozenset({
+            "int", "float", "str", "bool", "list", "dict", "set", "tuple",
+            "bytes", "bytearray", "memoryview", "range", "enumerate", "type",
+            "object", "complex", "frozenset",
+            "None", "Any", "Optional", "Union", "Callable", "Type",
+            "List", "Dict", "Set", "Tuple",
+        }),
+        block_keyword_re=re.compile(r"\b(?:class|def|async\s+def)\b"),
+        lambda_re=re.compile(r"\blambda\b"),
+        func_sig_end_re=re.compile(r"\)\s*(?:->.*?)?\s*:\s*$"),
+        namespace_sig_re=None,
+        init_list_re=None,
+        access_spec_names=frozenset(),
+        view_structural_kws=("class ", "def ", "async def "),
+        view_modifier_kws=(
+            "@staticmethod ", "@classmethod ", "@property ", "@abstractmethod ",
+        ),
+        local_var_modifiers="global|nonlocal",
+        verbatim_string_prefix=None,
+        raw_string_char="r",
+        range_for_re=re.compile(r"^\s*for\s+(\w+)\s+in\s+(\w+)"),
+        # Comment syntax
+        line_comment="#",
+        block_comment_pair=None,
+        # String syntax
+        string_delimiters=frozenset({'"', "'"}),
+        string_escape_char="\\",
+        triple_quote_strings=('"""', "'''"),
+        # Block style
+        uses_indent_blocks=True,
+        # Preprocessor
+        preprocessor_prefix="",
+        has_preprocessor_macros=False,
+        # Statement / block close
+        statement_terminator="",
+        block_close_suffix="",
+        summary_comment_prefix="#",
+        # Config-driven control flow
+        control_flow_patterns=(
+            ("for", re.compile(r"^\s*for\s+(.{1,80})\s*:\s*$")),
+            ("while", re.compile(r"^\s*while\s+(.{1,80})\s*:\s*$")),
+            ("if", re.compile(r"^\s*(?:elif\s+)?if\s+(.{1,80})\s*:\s*$")),
+            ("match", re.compile(r"^\s*match\s+(.{1,40})\s*:\s*$")),
+        ),
+        return_re=re.compile(r"^\s*return\s+(.{1,60})\s*$"),
+        # Extra syntax hints
+        type_indicator_chars="",
+        define_line_re=None,
+        has_template_strings=False,
+        raw_string_style="cpp",
+    )

code_source_sql/languages/rust.py

@@ -0,0 +1,91 @@
+"""Rust language configuration."""
+
+from __future__ import annotations
+
+import re
+
+from ..configs import LanguageConfig
+
+
+def make_rust_language() -> LanguageConfig:
+    """Rust language configuration."""
+    return LanguageConfig(
+        name="rust",
+        class_re=re.compile(r"(?:pub\s+)?(struct|enum|trait)\s+(\w+)"),
+        enum_re=re.compile(r"(?:pub\s+)?enum\s+(\w+)"),
+        namespace_re=re.compile(r"\bmod\s+(\w+)"),
+        func_name_re=re.compile(r"(?:pub\s+)?(?:async\s+)?fn\s+(\w+)"),
+        export_macro_re=re.compile(r"(?!x)x"),
+        calling_conv_re=re.compile(r"(?!x)x"),
+        attribute_re=re.compile(r"#!?\[[^\]]*\]"),  # inner/outer attributes
+        template_re=re.compile(r"<[^<>]*>"),  # generics
+        dtor_re=re.compile(r"(?!x)x"),  # Rust uses Drop trait
+        control_flow_re=re.compile(r"\b(if|else\s+if|else|while|for|loop|match|return|break|continue)\b"),
+        control_flow_names=frozenset({
+            "if", "else", "while", "for", "loop", "match",
+            "return", "break", "continue", "yield", "await", "unsafe",
+        }),
+        trailing_mods_re=re.compile(r"(?!x)x"),
+        access_spec_re=re.compile(r"(?!x)x"),  # Rust uses pub
+        macro_like_re=re.compile(r"^[a-z_]+!\s"),  # Rust macros end with !
+        define_re=re.compile(r"(?!x)x"),  # Rust has macro_rules!, not #define
+        extern_c_re=re.compile(r"\bextern\s+"),
+        operator_re=None,
+        uses_braces=True,
+        uses_namespaces=True,
+        uses_colon_inheritance=False,
+        scope_operator="::",
+        base_keyword="",  # Rust has no super; uses Deref or explicit paths
+        static_call_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)::([A-Za-z_][A-Za-z0-9_]*)\s*\("),
+        super_call_re=None,
+        type_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)\b"),
+        param_type_re=re.compile(r":\s*(?:&)?(?:mut\s+)?([A-Z][A-Za-z0-9_]+)"),  # name: Type syntax
+        basic_skip_types=frozenset({
+            "i8", "i16", "i32", "i64", "i128",
+            "u8", "u16", "u32", "u64", "u128",
+            "f32", "f64", "bool", "char", "str", "String",
+            "Vec", "Box", "Rc", "Arc", "Option", "Result",
+            "Cow", "Cell", "RefCell",
+        }),
+        block_keyword_re=re.compile(r"\b(?:struct|enum|trait|impl|mod|fn|type)\b"),
+        lambda_re=re.compile(r"\|[^|]*\|\s*"),  # Rust closures
+        namespace_sig_re=re.compile(r"\bmod\s+(\w+)\s*\{?\s*$"),
+        init_list_re=None,
+        access_spec_names=frozenset(),
+        view_structural_kws=("struct ", "enum ", "trait ", "impl ", "fn "),
+        view_modifier_kws=("pub ", "async ", "unsafe ", "const "),
+        local_var_modifiers="let|mut|const|static|ref",
+        verbatim_string_prefix=None,
+        raw_string_char="r",
+        range_for_re=re.compile(r"for\s+(\w+)\s+in\s+(\w+)"),
+        # Comment syntax
+        line_comment="//",
+        block_comment_pair=("/*", "*/"),
+        # String syntax
+        string_delimiters=frozenset({'"'}),
+        string_escape_char="\\",
+        triple_quote_strings=(),
+        # Block style
+        uses_indent_blocks=False,
+        # Preprocessor
+        preprocessor_prefix="",  # Rust # is for attributes, not preprocessor
+        has_preprocessor_macros=False,
+        # Statement / block close
+        statement_terminator=";",
+        block_close_suffix="}",
+        summary_comment_prefix="//",
+        # Config-driven control flow
+        control_flow_patterns=(
+            ("for", re.compile(r"^\s*for\s+(.{1,80})\s*\{?\s*$")),
+            ("while", re.compile(r"^\s*while\s+(.{1,80})\s*\{?\s*$")),
+            ("if", re.compile(r"^\s*(?:else\s+)?if\s+(.{1,80})\s*\{?\s*$")),
+            ("match", re.compile(r"^\s*match\s+(.{1,40})\s*\{?\s*$")),
+            ("loop", re.compile(r"^\s*loop\s*\{?\s*$")),
+        ),
+        return_re=re.compile(r"^\s*return\s+(.{1,60});"),
+        # Extra syntax hints
+        type_indicator_chars="&",  # Rust references use &
+        define_line_re=None,
+        has_template_strings=False,
+        raw_string_style="rust",  # Rust uses r#"..."# raw strings
+    )

code_source_sql/languages/swift.py

@@ -0,0 +1,116 @@
+"""Swift language configuration."""
+
+from __future__ import annotations
+
+import re
+
+from ..configs import LanguageConfig
+
+_NEVER_MATCH = re.compile(r"(?!x)x")
+
+
+def make_swift_language() -> LanguageConfig:
+    """Swift language configuration."""
+    return LanguageConfig(
+        name="swift",
+        class_re=re.compile(
+            r"(?:(?:public|private|internal|open|fileprivate|final|static|override)\s+)*"
+            r"(class|struct|protocol|enum|actor)\s+(\w+)"
+            r"(?:\s*<[^>]*>)?"
+            r"(?:\s*:\s*(\w+))?"
+        ),
+        enum_re=re.compile(r"(?:indirect\s+)?enum\s+(\w+)"),
+        namespace_re=_NEVER_MATCH,
+        func_name_re=re.compile(
+            r"(?:(?:public|private|internal|open|fileprivate|static|override|mutating|nonmutating)\s+)*"
+            r"(?:async\s+)?(?:throws\s+)?"
+            r"func\s+(\w+)\s*\("
+        ),
+        export_macro_re=_NEVER_MATCH,
+        calling_conv_re=_NEVER_MATCH,
+        attribute_re=re.compile(r"@\w+(?:\([^)]*\))?"),
+        template_re=re.compile(r"<[^<>]*>"),
+        dtor_re=re.compile(r"deinit"),
+        control_flow_re=re.compile(
+            r"\b(if|else\s+if|else|while|for|switch|catch|try|guard|repeat)\b"
+        ),
+        control_flow_names=frozenset({
+            "if", "else", "while", "for", "switch", "catch", "try",
+            "return", "break", "continue", "throw", "guard", "repeat",
+            "defer", "yield", "await",
+        }),
+        trailing_mods_re=_NEVER_MATCH,
+        access_spec_re=_NEVER_MATCH,
+        macro_like_re=_NEVER_MATCH,
+        define_re=_NEVER_MATCH,
+        extern_c_re=_NEVER_MATCH,
+        operator_re=None,
+        uses_braces=True,
+        uses_namespaces=False,
+        uses_colon_inheritance=True,
+        scope_operator=".",
+        base_keyword="super",
+        static_call_re=re.compile(
+            r"\b([A-Z][A-Za-z0-9_]+)\.([A-Za-z_][A-Za-z0-9_]*)\s*\("
+        ),
+        super_call_re=re.compile(
+            r"\bsuper\.([A-Za-z_][A-Za-z0-9_]*)\s*\("
+        ),
+        type_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)\b"),
+        param_type_re=re.compile(r"(\w+)\s*:\s*([A-Z][A-Za-z0-9_]+)"),
+        basic_skip_types=frozenset({
+            "Int", "Int8", "Int16", "Int32", "Int64",
+            "UInt", "UInt8", "UInt16", "UInt32", "UInt64",
+            "Float", "Double", "Bool", "String", "Character",
+            "Void", "Any", "AnyObject", "Optional", "Array",
+            "Dictionary", "Set", "Result", "URL", "Data", "Date",
+        }),
+        block_keyword_re=re.compile(
+            r"\b(?:class|struct|protocol|enum|actor|func|extension|typealias)\b"
+        ),
+        lambda_re=re.compile(r"\{"),
+        namespace_sig_re=None,
+        init_list_re=None,
+        access_spec_names=frozenset(),
+        view_structural_kws=(
+            "class ", "struct ", "protocol ", "enum ", "actor ",
+            "func ", "extension ",
+        ),
+        view_modifier_kws=(
+            "public ", "private ", "internal ", "open ", "static ",
+            "override ", "mutating ", "async ",
+        ),
+        local_var_modifiers="let|var|guard",
+        verbatim_string_prefix=None,
+        raw_string_char=None,
+        range_for_re=re.compile(r"for\s+(\w+)\s+in\s+(\w+)"),
+        # Comment syntax
+        line_comment="//",
+        block_comment_pair=("/*", "*/"),
+        # String syntax
+        string_delimiters=frozenset({'"'}),
+        string_escape_char="\\",
+        triple_quote_strings=(),
+        # Block style
+        uses_indent_blocks=False,
+        # Preprocessor
+        preprocessor_prefix="",
+        has_preprocessor_macros=False,
+        # Statement / block close
+        statement_terminator=";",
+        block_close_suffix="}",
+        summary_comment_prefix="//",
+        # Config-driven control flow
+        control_flow_patterns=(
+            ("for", re.compile(r"^\s*for\s+(.{1,80})\s*\{?\s*$")),
+            ("while", re.compile(r"^\s*while\s+(.{1,80})\s*\{?\s*$")),
+            ("if", re.compile(r"^\s*(?:else\s+)?if\s+(.{1,80})\s*\{?\s*$")),
+            ("switch", re.compile(r"^\s*switch\s+(.{1,40})\s*\{?\s*$")),
+        ),
+        return_re=re.compile(r"^\s*return\s+(.{1,60})"),
+        # Extra syntax hints
+        type_indicator_chars="",
+        define_line_re=None,
+        has_template_strings=False,
+        raw_string_style="cpp",
+    )