jaclang 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

jaclang/jac/transpiler.py

@@ -6,7 +6,7 @@ from jaclang.jac.parser import JacLexer
 from jaclang.jac.parser import JacParser
 from jaclang.jac.passes import Pass
 from jaclang.jac.passes.blue import BluePygenPass, PyOutPass, pass_schedule
-from jaclang.jac.transform import Transform
+from jaclang.jac.transform import Alert, Transform
 
 
 T = TypeVar("T", bound=Pass)
@@ -22,7 +22,7 @@ def jac_file_to_parse_tree(file_path: str, base_dir: str) -> Transform:
         return prse
 
 
-def transpile_jac_blue(file_path: str, base_dir: str) -> str:
+def transpile_jac_blue(file_path: str, base_dir: str) -> list[Alert]:
     """Transpiler Jac file and return python code as string."""
     code = jac_file_to_pass(
         file_path=file_path,
@@ -31,13 +31,15 @@ def transpile_jac_blue(file_path: str, base_dir: str) -> str:
         schedule=pass_schedule,
     )
     if isinstance(code.ir, ast.Module):
-        PyOutPass(mod_path=file_path, input_ir=code.ir, base_path=base_dir, prior=code)
-        return code.ir.meta["py_code"]
+        print_pass = PyOutPass(
+            mod_path=file_path, input_ir=code.ir, base_path=base_dir, prior=code
+        )
     else:
-        raise code.gen_exception("Transpilation of Jac file failed.")
+        return code.errors_had
+    return print_pass.errors_had
 
 
-def transpile_jac_purple(file_path: str, base_dir: str) -> str:
+def transpile_jac_purple(file_path: str, base_dir: str) -> list[Alert]:
     """Transpiler Jac file and return python code as string."""
     from jaclang.jac.passes.purple import pass_schedule, PurplePygenPass
 
@@ -48,10 +50,12 @@ def transpile_jac_purple(file_path: str, base_dir: str) -> str:
         schedule=pass_schedule,
     )
     if isinstance(code.ir, ast.Module):
-        PyOutPass(mod_path=file_path, input_ir=code.ir, base_path=base_dir, prior=code)
-        return code.ir.meta["py_code"]
+        print_pass = PyOutPass(
+            mod_path=file_path, input_ir=code.ir, base_path=base_dir, prior=code
+        )
     else:
-        raise code.gen_exception("Transpilation of Jac file failed.")
+        return code.errors_had
+    return print_pass.errors_had
 
 
 def jac_file_to_pass(

jaclang/utils/fstring_parser.py

@@ -1,7 +1,7 @@
 # type: ignore
 """Python Like F-String Parser."""
-from jaclang.utils.sly.lex import Lexer
-from jaclang.utils.sly.yacc import Parser, YaccProduction
+from jaclang.vendor.sly.lex import Lexer
+from jaclang.vendor.sly.yacc import Parser, YaccProduction
 
 _ = None  # For flake8 linting and sly compatibility
 

jaclang/utils/helpers.py

@@ -1,7 +1,9 @@
 """Utility functions and classes for Jac compilation toolchain."""
 import re
+import traceback
 
 import jaclang.jac.absyntree as ast
+from jaclang.jac.constant import Constants as Con, Values as Val
 
 
 def pascal_to_snake(pascal_string: str) -> str:
@@ -31,6 +33,45 @@ def clip_code_section(s: str, target_line: int, line_range: int) -> str:
     return "\n".join(result)
 
 
+def dedent_code_block(code: str) -> str:
+    """Dedent a code block."""
+    lines = code.splitlines()
+    min_indent = min(len(line) - len(line.lstrip()) for line in lines if line.strip())
+    dedented_lines = [line[min_indent:] for line in lines]
+    dedented_code = "\n".join(dedented_lines)
+    return dedented_code
+
+
+def handle_jac_error(code_string: str, e: Exception, tb: traceback.StackSummary) -> str:
+    """Handle Jac Error."""
+    except_line = e.end_lineno if isinstance(e, SyntaxError) else list(tb)[-1].lineno
+    if not isinstance(except_line, int) or except_line == 0:
+        return ""
+    py_error_region = clip_code_section(
+        add_line_numbers(code_string), except_line, Val.JAC_ERROR_LINE_RANGE
+    )
+    try:
+        jac_err_line = int(code_string.splitlines()[except_line - 1].split()[-1])
+        mod_index = int(code_string.splitlines()[except_line - 1].split()[-2])
+        mod_paths = code_string.split(Con.JAC_DEBUG_SPLITTER)[1].strip().splitlines()
+        target_mod = mod_paths[mod_index]
+        with open(target_mod, "r") as file:
+            jac_code_string = file.read()
+        jac_error_region = clip_code_section(
+            add_line_numbers(jac_code_string), jac_err_line, Val.JAC_ERROR_LINE_RANGE
+        )
+    except Exception as e:
+        jac_error_region = str(e)
+        target_mod = ""
+    snippet = (
+        f"{Con.JAC_ERROR_PREAMBLE}\n"
+        f"{target_mod}\n"
+        f"JacCode Snippet:\n{jac_error_region}\n"
+        f"PyCode Snippet:\n{py_error_region}\n"
+    )
+    return snippet
+
+
 def get_ast_nodes_as_snake_case() -> list[str]:
     """Get all AST nodes as snake case."""
     import inspect

jaclang/utils/test.py

@@ -5,6 +5,8 @@ import os
 from abc import ABC, abstractmethod
 from unittest import TestCase as _TestCase
 
+from jaclang.utils.helpers import get_ast_nodes_as_snake_case as ast_snakes
+
 
 class TestCase(_TestCase):
     """Base test case for Jaseci."""
@@ -101,3 +103,31 @@ class TestCaseMicroSuite(ABC, TestCase):
     def micro_suite_test(self, filename: str) -> None:
         """Test micro jac file."""
         pass
+
+
+class AstSyncTestMixin:
+    """Mixin for testing AST sync."""
+
+    TargetPass = None
+
+    def test_pass_ast_complete(self) -> None:
+        """Test for enter/exit name diffs with parser."""
+        ast_func_names = [
+            x
+            for x in ast_snakes()
+            if x not in ["ast_node", "o_o_p_access_node", "walker_stmt_only_node"]
+        ]
+        pygen_func_names = []
+        for name, value in inspect.getmembers(self.TargetPass):
+            if (
+                (name.startswith("enter_") or name.startswith("exit_"))
+                and inspect.isfunction(value)
+                and not getattr(self.TargetPass.__base__, value.__name__, False)  # type: ignore
+                and value.__qualname__.split(".")[0]
+                == self.TargetPass.__name__.replace("enter_", "").replace("exit_", "")  # type: ignore
+            ):
+                pygen_func_names.append(name.replace("enter_", "").replace("exit_", ""))
+        for name in pygen_func_names:
+            self.assertIn(name, ast_func_names)  # type: ignore
+        for name in ast_func_names:
+            self.assertIn(name, pygen_func_names)  # type: ignore

jaclang/vendor/__init__.py

@@ -0,0 +1 @@
+"""Vendor packages for JACLang."""

jaclang/vendor/pygls/__init__.py

@@ -0,0 +1,25 @@
+############################################################################
+# Original work Copyright 2018 Palantir Technologies, Inc.                 #
+# Original work licensed under the MIT License.                            #
+# See ThirdPartyNotices.txt in the project root for license information.   #
+# All modifications Copyright (c) Open Law Library. All rights reserved.   #
+#                                                                          #
+# Licensed under the Apache License, Version 2.0 (the "License")           #
+# you may not use this file except in compliance with the License.         #
+# You may obtain a copy of the License at                                  #
+#                                                                          #
+#     http: // www.apache.org/licenses/LICENSE-2.0                         #
+#                                                                          #
+# Unless required by applicable law or agreed to in writing, software      #
+# distributed under the License is distributed on an "AS IS" BASIS,        #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and      #
+# limitations under the License.                                           #
+############################################################################
+import os
+import sys
+
+IS_WIN = os.name == "nt"
+IS_PYODIDE = "pyodide" in sys.modules
+
+pygls = "pygls"

jaclang/vendor/pygls/capabilities.py

@@ -0,0 +1,502 @@
+############################################################################
+# Copyright(c) Open Law Library. All rights reserved.                      #
+# See ThirdPartyNotices.txt in the project root for additional notices.    #
+#                                                                          #
+# Licensed under the Apache License, Version 2.0 (the "License")           #
+# you may not use this file except in compliance with the License.         #
+# You may obtain a copy of the License at                                  #
+#                                                                          #
+#     http: // www.apache.org/licenses/LICENSE-2.0                         #
+#                                                                          #
+# Unless required by applicable law or agreed to in writing, software      #
+# distributed under the License is distributed on an "AS IS" BASIS,        #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and      #
+# limitations under the License.                                           #
+############################################################################
+from functools import reduce
+from typing import Any, Dict, List, Optional, Set, Union
+import logging
+
+from jaclang.vendor.pygls.lsprotocol.types import (
+    INLAY_HINT_RESOLVE,
+    TEXT_DOCUMENT_CODE_ACTION,
+    TEXT_DOCUMENT_CODE_LENS,
+    TEXT_DOCUMENT_COMPLETION,
+    TEXT_DOCUMENT_DECLARATION,
+    TEXT_DOCUMENT_DEFINITION,
+    TEXT_DOCUMENT_DIAGNOSTIC,
+    TEXT_DOCUMENT_DOCUMENT_COLOR,
+    TEXT_DOCUMENT_DOCUMENT_HIGHLIGHT,
+    TEXT_DOCUMENT_DOCUMENT_LINK,
+    TEXT_DOCUMENT_DOCUMENT_SYMBOL,
+    TEXT_DOCUMENT_FOLDING_RANGE,
+    TEXT_DOCUMENT_FORMATTING,
+    TEXT_DOCUMENT_HOVER,
+    TEXT_DOCUMENT_IMPLEMENTATION,
+    TEXT_DOCUMENT_INLAY_HINT,
+    TEXT_DOCUMENT_INLINE_VALUE,
+    TEXT_DOCUMENT_ON_TYPE_FORMATTING,
+    TEXT_DOCUMENT_RANGE_FORMATTING,
+    TEXT_DOCUMENT_REFERENCES,
+    TEXT_DOCUMENT_RENAME,
+    TEXT_DOCUMENT_SELECTION_RANGE,
+    TEXT_DOCUMENT_SIGNATURE_HELP,
+    TEXT_DOCUMENT_PREPARE_CALL_HIERARCHY,
+    TEXT_DOCUMENT_PREPARE_TYPE_HIERARCHY,
+    TEXT_DOCUMENT_DID_CLOSE,
+    TEXT_DOCUMENT_DID_OPEN,
+    TEXT_DOCUMENT_DID_SAVE,
+    TEXT_DOCUMENT_LINKED_EDITING_RANGE,
+    TEXT_DOCUMENT_MONIKER,
+    TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL,
+    TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL_DELTA,
+    TEXT_DOCUMENT_SEMANTIC_TOKENS_RANGE,
+    TEXT_DOCUMENT_WILL_SAVE,
+    TEXT_DOCUMENT_WILL_SAVE_WAIT_UNTIL,
+    TEXT_DOCUMENT_TYPE_DEFINITION,
+    WORKSPACE_DIAGNOSTIC,
+    WORKSPACE_DID_CREATE_FILES,
+    WORKSPACE_DID_DELETE_FILES,
+    WORKSPACE_DID_RENAME_FILES,
+    WORKSPACE_SYMBOL,
+    WORKSPACE_SYMBOL_RESOLVE,
+    WORKSPACE_WILL_CREATE_FILES,
+    WORKSPACE_WILL_DELETE_FILES,
+    WORKSPACE_WILL_RENAME_FILES,
+    InlayHintOptions,
+    PositionEncodingKind,
+)
+from jaclang.vendor.pygls.lsprotocol.types import (
+    ClientCapabilities,
+    CodeLensOptions,
+    CompletionOptions,
+    DocumentLinkOptions,
+    ExecuteCommandOptions,
+    ImplementationOptions,
+    NotebookDocumentSyncOptions,
+    SemanticTokensOptions,
+    SemanticTokensRegistrationOptions,
+    SemanticTokensOptionsFullType1,
+    ServerCapabilities,
+    ServerCapabilitiesWorkspaceType,
+    SignatureHelpOptions,
+    TextDocumentSyncKind,
+    TextDocumentSyncOptions,
+    TypeDefinitionOptions,
+    FileOperationOptions,
+    WorkspaceFoldersServerCapabilities,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def get_capability(
+    client_capabilities: ClientCapabilities, field: str, default: Any = None
+) -> Any:
+    """Check if ClientCapabilities has some nested value without raising
+    AttributeError.
+    e.g. get_capability('text_document.synchronization.will_save')
+    """
+    try:
+        value = reduce(getattr, field.split("."), client_capabilities)
+    except AttributeError:
+        return default
+
+    # If we reach the desired leaf value but it's None, return the default.
+    return default if value is None else value
+
+
+class ServerCapabilitiesBuilder:
+    """Create `ServerCapabilities` instance depending on builtin and user registered
+    features.
+    """
+
+    def __init__(
+        self,
+        client_capabilities: ClientCapabilities,
+        features: Set[str],
+        feature_options: Dict[str, Any],
+        commands: List[str],
+        text_document_sync_kind: TextDocumentSyncKind,
+        notebook_document_sync: Optional[NotebookDocumentSyncOptions] = None,
+    ):
+        self.client_capabilities = client_capabilities
+        self.features = features
+        self.feature_options = feature_options
+        self.commands = commands
+        self.text_document_sync_kind = text_document_sync_kind
+        self.notebook_document_sync = notebook_document_sync
+
+        self.server_cap = ServerCapabilities()
+
+    def _provider_options(self, feature, default=True):
+        if feature in self.features:
+            return self.feature_options.get(feature, default)
+        return None
+
+    def _with_text_document_sync(self):
+        open_close = (
+            TEXT_DOCUMENT_DID_OPEN in self.features
+            or TEXT_DOCUMENT_DID_CLOSE in self.features
+        )
+        will_save = (
+            get_capability(
+                self.client_capabilities, "text_document.synchronization.will_save"
+            )
+            and TEXT_DOCUMENT_WILL_SAVE in self.features
+        )
+        will_save_wait_until = (
+            get_capability(
+                self.client_capabilities,
+                "text_document.synchronization.will_save_wait_until",
+            )
+            and TEXT_DOCUMENT_WILL_SAVE_WAIT_UNTIL in self.features
+        )
+        if TEXT_DOCUMENT_DID_SAVE in self.features:
+            save = self.feature_options.get(TEXT_DOCUMENT_DID_SAVE, True)
+        else:
+            save = False
+
+        self.server_cap.text_document_sync = TextDocumentSyncOptions(
+            open_close=open_close,
+            change=self.text_document_sync_kind,
+            will_save=will_save,
+            will_save_wait_until=will_save_wait_until,
+            save=save,
+        )
+
+        return self
+
+    def _with_notebook_document_sync(self):
+        if self.client_capabilities.notebook_document is None:
+            return self
+
+        self.server_cap.notebook_document_sync = self.notebook_document_sync
+        return self
+
+    def _with_completion(self):
+        value = self._provider_options(
+            TEXT_DOCUMENT_COMPLETION, default=CompletionOptions()
+        )
+        if value is not None:
+            self.server_cap.completion_provider = value
+        return self
+
+    def _with_hover(self):
+        value = self._provider_options(TEXT_DOCUMENT_HOVER)
+        if value is not None:
+            self.server_cap.hover_provider = value
+        return self
+
+    def _with_signature_help(self):
+        value = self._provider_options(
+            TEXT_DOCUMENT_SIGNATURE_HELP, default=SignatureHelpOptions()
+        )
+        if value is not None:
+            self.server_cap.signature_help_provider = value
+        return self
+
+    def _with_declaration(self):
+        value = self._provider_options(TEXT_DOCUMENT_DECLARATION)
+        if value is not None:
+            self.server_cap.declaration_provider = value
+        return self
+
+    def _with_definition(self):
+        value = self._provider_options(TEXT_DOCUMENT_DEFINITION)
+        if value is not None:
+            self.server_cap.definition_provider = value
+        return self
+
+    def _with_type_definition(self):
+        value = self._provider_options(
+            TEXT_DOCUMENT_TYPE_DEFINITION, default=TypeDefinitionOptions()
+        )
+        if value is not None:
+            self.server_cap.type_definition_provider = value
+        return self
+
+    def _with_inlay_hints(self):
+        value = self._provider_options(
+            TEXT_DOCUMENT_INLAY_HINT, default=InlayHintOptions()
+        )
+        if value is not None:
+            value.resolve_provider = INLAY_HINT_RESOLVE in self.features
+            self.server_cap.inlay_hint_provider = value
+        return self
+
+    def _with_implementation(self):
+        value = self._provider_options(
+            TEXT_DOCUMENT_IMPLEMENTATION, default=ImplementationOptions()
+        )
+        if value is not None:
+            self.server_cap.implementation_provider = value
+        return self
+
+    def _with_references(self):
+        value = self._provider_options(TEXT_DOCUMENT_REFERENCES)
+        if value is not None:
+            self.server_cap.references_provider = value
+        return self
+
+    def _with_document_highlight(self):
+        value = self._provider_options(TEXT_DOCUMENT_DOCUMENT_HIGHLIGHT)
+        if value is not None:
+            self.server_cap.document_highlight_provider = value
+        return self
+
+    def _with_document_symbol(self):
+        value = self._provider_options(TEXT_DOCUMENT_DOCUMENT_SYMBOL)
+        if value is not None:
+            self.server_cap.document_symbol_provider = value
+        return self
+
+    def _with_code_action(self):
+        value = self._provider_options(TEXT_DOCUMENT_CODE_ACTION)
+        if value is not None:
+            self.server_cap.code_action_provider = value
+        return self
+
+    def _with_code_lens(self):
+        value = self._provider_options(
+            TEXT_DOCUMENT_CODE_LENS, default=CodeLensOptions()
+        )
+        if value is not None:
+            self.server_cap.code_lens_provider = value
+        return self
+
+    def _with_document_link(self):
+        value = self._provider_options(
+            TEXT_DOCUMENT_DOCUMENT_LINK, default=DocumentLinkOptions()
+        )
+        if value is not None:
+            self.server_cap.document_link_provider = value
+        return self
+
+    def _with_color(self):
+        value = self._provider_options(TEXT_DOCUMENT_DOCUMENT_COLOR)
+        if value is not None:
+            self.server_cap.color_provider = value
+        return self
+
+    def _with_document_formatting(self):
+        value = self._provider_options(TEXT_DOCUMENT_FORMATTING)
+        if value is not None:
+            self.server_cap.document_formatting_provider = value
+        return self
+
+    def _with_document_range_formatting(self):
+        value = self._provider_options(TEXT_DOCUMENT_RANGE_FORMATTING)
+        if value is not None:
+            self.server_cap.document_range_formatting_provider = value
+        return self
+
+    def _with_document_on_type_formatting(self):
+        value = self._provider_options(TEXT_DOCUMENT_ON_TYPE_FORMATTING)
+        if value is not None:
+            self.server_cap.document_on_type_formatting_provider = value
+        return self
+
+    def _with_rename(self):
+        value = self._provider_options(TEXT_DOCUMENT_RENAME)
+        if value is not None:
+            self.server_cap.rename_provider = value
+        return self
+
+    def _with_folding_range(self):
+        value = self._provider_options(TEXT_DOCUMENT_FOLDING_RANGE)
+        if value is not None:
+            self.server_cap.folding_range_provider = value
+        return self
+
+    def _with_execute_command(self):
+        self.server_cap.execute_command_provider = ExecuteCommandOptions(
+            commands=self.commands
+        )
+        return self
+
+    def _with_selection_range(self):
+        value = self._provider_options(TEXT_DOCUMENT_SELECTION_RANGE)
+        if value is not None:
+            self.server_cap.selection_range_provider = value
+        return self
+
+    def _with_call_hierarchy(self):
+        value = self._provider_options(TEXT_DOCUMENT_PREPARE_CALL_HIERARCHY)
+        if value is not None:
+            self.server_cap.call_hierarchy_provider = value
+        return self
+
+    def _with_type_hierarchy(self):
+        value = self._provider_options(TEXT_DOCUMENT_PREPARE_TYPE_HIERARCHY)
+        if value is not None:
+            self.server_cap.type_hierarchy_provider = value
+        return self
+
+    def _with_semantic_tokens(self):
+        providers = [
+            TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL,
+            TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL_DELTA,
+            TEXT_DOCUMENT_SEMANTIC_TOKENS_RANGE,
+        ]
+
+        for provider in providers:
+            value = self._provider_options(provider, None)
+            if value:
+                break
+
+        if value is None:
+            return self
+
+        if isinstance(value, SemanticTokensRegistrationOptions):
+            self.server_cap.semantic_tokens_provider = value
+            return self
+
+        full_support: Union[bool, SemanticTokensOptionsFullType1] = (
+            TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL in self.features
+        )
+
+        if TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL_DELTA in self.features:
+            full_support = SemanticTokensOptionsFullType1(delta=True)
+
+        options = SemanticTokensOptions(
+            legend=value,
+            full=full_support or None,
+            range=TEXT_DOCUMENT_SEMANTIC_TOKENS_RANGE in self.features or None,
+        )
+
+        if options.full or options.range:
+            self.server_cap.semantic_tokens_provider = options
+
+        return self
+
+    def _with_linked_editing_range(self):
+        value = self._provider_options(TEXT_DOCUMENT_LINKED_EDITING_RANGE)
+        if value is not None:
+            self.server_cap.linked_editing_range_provider = value
+        return self
+
+    def _with_moniker(self):
+        value = self._provider_options(TEXT_DOCUMENT_MONIKER)
+        if value is not None:
+            self.server_cap.moniker_provider = value
+        return self
+
+    def _with_workspace_symbol(self):
+        value = self._provider_options(WORKSPACE_SYMBOL)
+        if value is not None:
+            value.resolve_provider = self._provider_options(WORKSPACE_SYMBOL_RESOLVE)
+            self.server_cap.workspace_symbol_provider = value
+        return self
+
+    def _with_workspace_capabilities(self):
+        # File operations
+        file_operations = FileOperationOptions()
+        operations = [
+            (WORKSPACE_WILL_CREATE_FILES, "will_create"),
+            (WORKSPACE_DID_CREATE_FILES, "did_create"),
+            (WORKSPACE_WILL_DELETE_FILES, "will_delete"),
+            (WORKSPACE_DID_DELETE_FILES, "did_delete"),
+            (WORKSPACE_WILL_RENAME_FILES, "will_rename"),
+            (WORKSPACE_DID_RENAME_FILES, "did_rename"),
+        ]
+
+        for method_name, capability_name in operations:
+            client_supports_method = get_capability(
+                self.client_capabilities, f"workspace.file_operations.{capability_name}"
+            )
+
+            if client_supports_method:
+                value = self._provider_options(method_name, None)
+                setattr(file_operations, capability_name, value)
+
+        self.server_cap.workspace = ServerCapabilitiesWorkspaceType(
+            workspace_folders=WorkspaceFoldersServerCapabilities(
+                supported=True,
+                change_notifications=True,
+            ),
+            file_operations=file_operations,
+        )
+        return self
+
+    def _with_diagnostic_provider(self):
+        value = self._provider_options(TEXT_DOCUMENT_DIAGNOSTIC)
+        if value is not None:
+            value.workspace_diagnostics = self._provider_options(WORKSPACE_DIAGNOSTIC)
+            self.server_cap.diagnostic_provider = value
+        return self
+
+    def _with_inline_value_provider(self):
+        value = self._provider_options(TEXT_DOCUMENT_INLINE_VALUE)
+        if value is not None:
+            self.server_cap.inline_value_provider = value
+        return self
+
+    def _with_position_encodings(self):
+        self.server_cap.position_encoding = PositionEncodingKind.Utf16
+
+        general = self.client_capabilities.general
+        if general is None:
+            return self
+
+        encodings = general.position_encodings
+        if encodings is None:
+            return self
+
+        if PositionEncodingKind.Utf16 in encodings:
+            return self
+
+        if PositionEncodingKind.Utf32 in encodings:
+            self.server_cap.position_encoding = PositionEncodingKind.Utf32
+            return self
+
+        if PositionEncodingKind.Utf8 in encodings:
+            self.server_cap.position_encoding = PositionEncodingKind.Utf8
+            return self
+
+        logger.warning(f"Unknown `PositionEncoding`s: {encodings}")
+
+        return self
+
+    def _build(self):
+        return self.server_cap
+
+    def build(self):
+        return (
+            self._with_text_document_sync()
+            ._with_notebook_document_sync()
+            ._with_completion()
+            ._with_hover()
+            ._with_signature_help()
+            ._with_declaration()
+            ._with_definition()
+            ._with_type_definition()
+            ._with_inlay_hints()
+            ._with_implementation()
+            ._with_references()
+            ._with_document_highlight()
+            ._with_document_symbol()
+            ._with_code_action()
+            ._with_code_lens()
+            ._with_document_link()
+            ._with_color()
+            ._with_document_formatting()
+            ._with_document_range_formatting()
+            ._with_document_on_type_formatting()
+            ._with_rename()
+            ._with_folding_range()
+            ._with_execute_command()
+            ._with_selection_range()
+            ._with_call_hierarchy()
+            ._with_type_hierarchy()
+            ._with_semantic_tokens()
+            ._with_linked_editing_range()
+            ._with_moniker()
+            ._with_workspace_symbol()
+            ._with_workspace_capabilities()
+            ._with_diagnostic_provider()
+            ._with_inline_value_provider()
+            ._with_position_encodings()
+            ._build()
+        )