inscript-lang 3.0.0__tar.gz → 3.9.6.23__tar.gz

inscript_lang-3.9.6.23/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: inscript-lang
+Version: 3.9.6.23
+Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
+Home-page: https://github.com/authorss81/inscript
+Author: Shreyasi Sarkar
+License: MIT
+Project-URL: Homepage, https://github.com/authorss81/inscript
+Project-URL: Repository, https://github.com/authorss81/inscript
+Project-URL: Bug Tracker, https://github.com/authorss81/inscript/issues
+Project-URL: Documentation, https://authorss81.github.io/inscript/docs/
+Keywords: game,scripting,language,gamedev,gdscript
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: game
+Requires-Dist: pygame>=2.0; extra == "game"
+Provides-Extra: lsp
+Requires-Dist: pygls>=1.0; extra == "lsp"
+Provides-Extra: all
+Requires-Dist: pygame>=2.0; extra == "all"
+Requires-Dist: pygls>=1.0; extra == "all"
+Dynamic: home-page
+Dynamic: requires-python
+
+# InScript Lexer - Rust Implementation (v3.7.2)
+
+**Real, compilable Rust tokenizer** for InScript language.
+
+## Features
+
+✅ Zero-copy token references (fast, memory efficient)
+✅ State machine lexer (no backtracking)
+✅ 30+ token types (keywords, operators, literals)
+✅ Accurate line/column tracking
+✅ Comprehensive error reporting
+✅ Python FFI via PyO3
+✅ Full test coverage
+
+## Build
+
+```bash
+cargo build --release
+```
+
+## Token Types Supported
+
+### Literals
+- Numbers (integers and floats)
+- Strings (single and double quoted)
+- Identifiers
+
+### Keywords
+- if, else, while, for, fn, return
+- true, false, nil
+- and, or, not
+
+### Operators
+- Arithmetic: +, -, *, /, %
+- Comparison: ==, !=, <, <=, >, >=
+- Assignment: =
+- Logical: and, or, not
+
+### Delimiters
+- Parentheses: ( )
+- Braces: { }
+- Brackets: [ ]
+- Punctuation: , . ; : ->
+
+## Rust Usage
+
+```rust
+use inscript_lexer::Lexer;
+
+fn main() {
+    let code = "let x = 42;";
+    let lexer = Lexer::new(code);
+    
+    for token in lexer {
+        match token {
+            Ok(t) => println!("{:?}: {}", t.token_type, t.value),
+            Err(e) => eprintln!("Error: {}", e),
+        }
+    }
+}
+```
+
+## Python Usage (after compilation)
+
+```python
+from inscript_lexer import PyLexer, tokenize_string
+
+# Method 1: Using PyLexer class
+lexer = PyLexer("let x = 42;")
+tokens = lexer.tokens()
+print(f"Found {lexer.count()} tokens")
+
+# Method 2: Direct tokenization
+tokens = tokenize_string("if true then x else y")
+for token in tokens:
+    print(f"{token.token_type}: {token.value}")
+```
+
+## Performance
+
+### Expected Benchmarks
+- Simple tokens: < 100ns per token
+- Complex code: < 10µs per 100 tokens
+- Memory: O(1) per token
+
+### Optimizations
+- Inline hot paths
+- No allocations in common cases
+- SIMD-friendly string scanning
+- Zero-copy string references
+
+## Testing
+
+```bash
+# Run tests
+cargo test
+
+# Run with output
+cargo test -- --nocapture
+
+# Benchmark
+cargo bench
+```
+
+## Accuracy
+
+✅ Correct line/column tracking
+✅ Handles escape sequences
+✅ Detects unterminated strings
+✅ Error recovery
+
+## License
+
+MIT
+

inscript_lang-3.9.6.23/README.md

@@ -0,0 +1,115 @@
+# InScript Lexer - Rust Implementation (v3.7.2)
+
+**Real, compilable Rust tokenizer** for InScript language.
+
+## Features
+
+✅ Zero-copy token references (fast, memory efficient)
+✅ State machine lexer (no backtracking)
+✅ 30+ token types (keywords, operators, literals)
+✅ Accurate line/column tracking
+✅ Comprehensive error reporting
+✅ Python FFI via PyO3
+✅ Full test coverage
+
+## Build
+
+```bash
+cargo build --release
+```
+
+## Token Types Supported
+
+### Literals
+- Numbers (integers and floats)
+- Strings (single and double quoted)
+- Identifiers
+
+### Keywords
+- if, else, while, for, fn, return
+- true, false, nil
+- and, or, not
+
+### Operators
+- Arithmetic: +, -, *, /, %
+- Comparison: ==, !=, <, <=, >, >=
+- Assignment: =
+- Logical: and, or, not
+
+### Delimiters
+- Parentheses: ( )
+- Braces: { }
+- Brackets: [ ]
+- Punctuation: , . ; : ->
+
+## Rust Usage
+
+```rust
+use inscript_lexer::Lexer;
+
+fn main() {
+    let code = "let x = 42;";
+    let lexer = Lexer::new(code);
+    
+    for token in lexer {
+        match token {
+            Ok(t) => println!("{:?}: {}", t.token_type, t.value),
+            Err(e) => eprintln!("Error: {}", e),
+        }
+    }
+}
+```
+
+## Python Usage (after compilation)
+
+```python
+from inscript_lexer import PyLexer, tokenize_string
+
+# Method 1: Using PyLexer class
+lexer = PyLexer("let x = 42;")
+tokens = lexer.tokens()
+print(f"Found {lexer.count()} tokens")
+
+# Method 2: Direct tokenization
+tokens = tokenize_string("if true then x else y")
+for token in tokens:
+    print(f"{token.token_type}: {token.value}")
+```
+
+## Performance
+
+### Expected Benchmarks
+- Simple tokens: < 100ns per token
+- Complex code: < 10µs per 100 tokens
+- Memory: O(1) per token
+
+### Optimizations
+- Inline hot paths
+- No allocations in common cases
+- SIMD-friendly string scanning
+- Zero-copy string references
+
+## Testing
+
+```bash
+# Run tests
+cargo test
+
+# Run with output
+cargo test -- --nocapture
+
+# Benchmark
+cargo bench
+```
+
+## Accuracy
+
+✅ Correct line/column tracking
+✅ Handles escape sequences
+✅ Detects unterminated strings
+✅ Error recovery
+
+## License
+
+MIT
+

{inscript_lang-3.0.0 → inscript_lang-3.9.6.23}/analyzer.py

@@ -64,6 +64,13 @@ T_TRANSFORM2D = InScriptType("Transform2D")
 T_TRANSFORM3D = InScriptType("Transform3D")
 T_TEXTURE = InScriptType("Texture")
 
+# Physics built-in types
+T_PHYSICS_WORLD = InScriptType("PhysicsWorld")
+T_BODY          = InScriptType("Body")
+T_SHAPE         = InScriptType("Shape")
+T_JOINT         = InScriptType("Joint")
+T_CONTACT       = InScriptType("Contact")
+
 T_NEVER  = InScriptType("never")   # v1.8.3: bottom type — function never returns normally
 T_PROMISE = InScriptType("Promise") # v1.9.7: async fn return type
 
@@ -82,6 +89,9 @@ BUILTIN_TYPES: Dict[str, InScriptType] = {
     "Color": T_COLOR, "Rect": T_RECT,
     "Transform2D": T_TRANSFORM2D, "Transform3D": T_TRANSFORM3D,
     "Texture": T_TEXTURE,
+    # physics types
+    "PhysicsWorld": T_PHYSICS_WORLD, "Body": T_BODY, "Shape": T_SHAPE,
+    "Joint": T_JOINT, "Contact": T_CONTACT,
     # tuple / array shorthand
     "Tuple": T_ANY, "List": T_ANY, "Dict": T_ANY, "Map": T_ANY,
     # v1.9.1: bare 'array' without element type (deprecated — use [T] in v2.0.0)
@@ -515,6 +525,17 @@ class Analyzer(Visitor):
             Symbol("Vec4",    T_VEC4,  kind="fn"),
             Symbol("Color",   T_COLOR, kind="fn"),
             Symbol("Rect",    T_RECT,  kind="fn"),
+            # physics constructors and constants
+            Symbol("PhysicsWorld", T_PHYSICS_WORLD, kind="fn"),
+            Symbol("PhysicsShape", T_SHAPE, kind="fn"),
+            Symbol("BODY_STATIC",    T_INT, kind="var"),
+            Symbol("BODY_DYNAMIC",   T_INT, kind="var"),
+            Symbol("BODY_KINEMATIC", T_INT, kind="var"),
+            Symbol("JOINT_DISTANCE",  T_INT, kind="var"),
+            Symbol("JOINT_REVOLUTE",  T_INT, kind="var"),
+            Symbol("JOINT_PRISMATIC", T_INT, kind="var"),
+            Symbol("JOINT_WELD",      T_INT, kind="var"),
+            Symbol("JOINT_MOUSE",     T_INT, kind="var"),
             # global objects
             Symbol("input",   T_ANY,   kind="var"),
             Symbol("draw",    T_ANY,   kind="var"),
@@ -1834,6 +1855,10 @@ class Analyzer(Visitor):
         self.visit(node.body)
         return T_VOID
 
+    def visit_TypePattern(self, node: TypePattern) -> InScriptType:
+        self._define(Symbol(node.var_name, T_ANY, kind="var", line=node.line))
+        return T_ANY
+
     def generic_visit(self, node: Node) -> InScriptType:
         # Silently pass through nodes we haven't handled yet
         return T_ANY

{inscript_lang-3.0.0 → inscript_lang-3.9.6.23}/compiler.py

@@ -275,6 +275,62 @@ class Compiler:
         self._eliminate_dead_code(self._proto)
         return self._proto
 
+    def compile_body(self, body_nodes, params=None, hook_name="<hook>"):
+        """Compile a list of AST statement nodes (e.g. hook body) into an FnProto.
+
+        Unlike compile() which takes a Program AST, this takes raw statement nodes.
+        This is used by pygame_backend.py to compile scene hooks to bytecode once,
+        then execute them via vm.VM.run() on every frame.
+
+        Args:
+            body_nodes: list of AST statement nodes, or a BlockStmt (which will be
+                        unwrapped to its .stmts list)
+            params: optional list of parameter names (e.g. ['dt'] for on_update)
+            hook_name: name for the compiled function (for debugging)
+
+        Returns:
+            FnProto ready to be passed to vm.VM.run()
+        """
+        # Unwrap BlockStmt if needed
+        if hasattr(body_nodes, 'body') and not isinstance(body_nodes, (list, tuple)):
+            body_nodes = body_nodes.body
+        saved_proto = self._proto
+        saved_scope = self._scope
+        saved_loop_starts = self._loop_starts
+        saved_break_patches = self._break_patches
+        saved_cont_patches = self._cont_patches
+
+        # Create a fresh function scope whose parent is the outer saved scope,
+        # so that VarDecl/let creates LOCAL registers instead of STORE_GLOBAL.
+        # This mirrors what _fn_decl / _compile_fn do (line 639).
+        self._proto = FnProto(hook_name, source_name=self._src)
+        self._scope = _Scope(self._proto, parent=saved_scope)
+        self._loop_starts = []
+        self._break_patches = []
+        self._cont_patches = []
+
+        # Add parameters as locals
+        if params:
+            for p in params:
+                self._scope.add_local(p)
+
+        # Compile body statements
+        for node in body_nodes:
+            self._stmt(node)
+
+        self._e(Op.RETURN, NIL_REG)
+        self._eliminate_dead_code(self._proto)
+        result = self._proto
+
+        # Restore
+        self._proto = saved_proto
+        self._scope = saved_scope
+        self._loop_starts = saved_loop_starts
+        self._break_patches = saved_break_patches
+        self._cont_patches = saved_cont_patches
+
+        return result
+
     def _eliminate_dead_code(self, proto):
         """v1.3.0: remove unreachable instructions after unconditional JUMP/RETURN."""
         code = proto.code
@@ -1358,3 +1414,14 @@ def compile_source(source, filename="<script>"):
     toks = Lexer(source, filename).tokenize()
     prog = Parser(toks, source).parse()
     return Compiler(filename).compile(prog)
+
+
+def compile_body(body_nodes, params=None, hook_name="<hook>", source_name="<script>"):
+    """Convenience: compile a list of AST statement nodes to FnProto.
+
+    Usage:
+        from compiler import compile_body
+        proto = compile_body(hook.body, params=['dt'], hook_name='on_update')
+        vm.run(proto)
+    """
+    return Compiler(source_name).compile_body(body_nodes, params, hook_name)

{inscript_lang-3.0.0 → inscript_lang-3.9.6.23}/inscript.py

@@ -24,7 +24,7 @@ from errors   import (InScriptError, LexerError, ParseError,
                        SemanticError, InScriptRuntimeError,
                        MultiError, InScriptWarning)
 
-VERSION = "3.0.0"
+VERSION = "3.9.6.23"
 
 MANIFEST_FILENAME = "inscript.toml"
 LOCK_FILENAME     = "inscript.lock"
@@ -2386,7 +2386,8 @@ def run_source(source: str, filename: str = "<stdin>",
                warn_as_error: bool = False,
                strict: bool = False,
                profile: bool = False,
-               json_errors: bool = False) -> int:
+               json_errors: bool = False,
+               debug: bool = False) -> int:
     """Lex, parse, analyze, and interpret InScript source code."""
 
     def _emit_error(e):
@@ -2443,7 +2444,7 @@ def run_source(source: str, filename: str = "<stdin>",
 
     # ── 4. Interpret — Phase 3: Python-leak guard ─────────────────────────
     try:
-        interp = Interpreter(source.splitlines(), filename=filename)
+        interp = Interpreter(source.splitlines(), filename=filename, debug=debug)
         if profile:
             import cProfile, pstats, io as _io
             pr = cProfile.Profile()
@@ -2660,7 +2661,11 @@ Examples:
     parser.add_argument("--doc-out", metavar="DIR", default=None,
                         help="v1.9.3: Output directory for --doc (default: stdout / docs/api/)")
     parser.add_argument("--errors", metavar="PREFIX", nargs="?", const="",
-                        help="v1.9.4: Print error code catalogue (optional prefix filter, e.g. E003)")
+                         help="v1.9.4: Print error code catalogue (optional prefix filter, e.g. E003)")
+    parser.add_argument("--rust", action="store_true",
+                         help="[DEPRECATED] Rust is now the default — use --python to opt out")
+    parser.add_argument("--python", action="store_true",
+                         help="Use the Python tree-walk interpreter instead of the Rust VM")
     parser.add_argument("--changelog", metavar="RANGE",
                         help="v1.9.4: Print changelog for version range e.g. v1.6.0..v1.9.4")
     parser.add_argument("--benchmark", metavar="NAME", nargs="?", const="",
@@ -2684,7 +2689,11 @@ Examples:
     parser.add_argument("--warn-as-error", action="store_true",
                         help="Treat any warning as an error (CI strictness)")
     parser.add_argument("--profile", action="store_true",
-                        help="Print per-function call count and timing after execution")
+                         help="Print per-function call count and timing after execution")
+    parser.add_argument("--debug", action="store_true",
+                         help="v3.9.6.10: Run in debug mode with breakpoint support")
+    parser.add_argument("--dap", action="store_true",
+                         help="v3.9.6.13: Start DAP server for VS Code debugging (uses --debug)")
     parser.add_argument("--fmt",     action="store_true",
                         help="Format .ins files: inscript --fmt file.ins")
     parser.add_argument("--fmt-all", metavar="DIR",
@@ -2773,6 +2782,12 @@ Examples:
                         help="Window height for --game mode (default: 600)")
     parser.add_argument("--fps",    type=int, default=60,
                         help="Target FPS for --game mode   (default: 60)")
+    parser.add_argument("--batch-draw", action="store_true",
+                        help="Batch draw ops (--game mode only)")
+    parser.add_argument("--frame-break", type=int, default=-1,
+                        help="v3.9.6.14: Break at specific frame (--game mode only)")
+    parser.add_argument("--frame-advance", action="store_true",
+                        help="v3.9.6.14: Step one frame at a time (--game mode only)")
     # ── v2.4.0: compilation flags ────────────────────────────────────────────
     parser.add_argument("--compile", metavar="FILE",
                         help="v2.4.0: AOT-compile FILE.ins → FILE.ibc bytecode")
@@ -2787,6 +2802,10 @@ Examples:
                         help="v2.4.0: Skip recompile if .ibc is newer than source")
     args = parser.parse_args()
 
+    # Backward compat: --rust is now the default, warn and ignore
+    if getattr(args, 'rust', False):
+        print("[InScript] Warning: --rust is now the default (no flag needed). Use --python to use the Python interpreter.", file=sys.stderr)
+
     if args.version:
         print(f"InScript {VERSION}")
         return
@@ -2936,7 +2955,12 @@ Examples:
             from pygame_backend import run_scene
             run_scene(args.file,
                       width=args.width, height=args.height, fps=args.fps,
-                      title=os.path.basename(args.file))
+                      title=os.path.basename(args.file),
+                      profile=getattr(args, 'profile', False),
+                      batch_draw=getattr(args, 'batch_draw', False),
+                      debug=getattr(args, 'debug', False),
+                      frame_break=getattr(args, 'frame_break', -1),
+                      frame_advance=getattr(args, 'frame_advance', False))
             return 0
         except ImportError:
             print("[InScript] pygame_backend not found next to inscript.py", file=sys.stderr)
@@ -3200,6 +3224,20 @@ Examples:
             print(e, file=sys.stderr); return 1
         return 0
 
+    # Rust compiler/VM fast path (default). Use --python to use the Python interpreter.
+    if not getattr(args, 'python', False):
+        try:
+            sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "target", "release"))
+            from inscript_parser import compile_and_run
+            result = compile_and_run(source)
+            print(result)
+            return 0
+        except ImportError:
+            print("[InScript] Rust VM not available — falling back to Python interpreter", file=sys.stderr)
+        except Exception as e:
+            print(f"[Rust VM] Error: {e}", file=sys.stderr)
+            return 1
+
     # Normal run
     type_check    = not getattr(args, 'no_typecheck', False) and \
                     not getattr(args, 'unsafe_no_check', False)
@@ -3208,13 +3246,27 @@ Examples:
     strict        = getattr(args, "strict", False)
     warn_as_error = getattr(args, "warn_as_error", False) or strict
     profile       = getattr(args, "profile", False)
+    debug_mode    = getattr(args, "debug", False)
+    dap_mode      = getattr(args, "dap", False)
+
+    if dap_mode:
+        _here = os.path.dirname(os.path.abspath(__file__))
+        sys.path.insert(0, _here)
+        from interpreter import Interpreter
+        from debugger import Debugger
+        from dap_server import DAPServer
+        interp = Interpreter(source_lines=[], debug=True)
+        dbger = Debugger(interp, filename=args.file)
+        dap = DAPServer(interp, dbger, args.file)
+        dap.run()
+        return 0
 
     with open(args.file, "r", encoding="utf-8") as _f:
         _source = _f.read()
     return run_source(_source, filename=args.file, type_check=type_check,
                       no_warn=no_warn, no_warn_unused=no_warn_unused,
                       warn_as_error=warn_as_error, strict=strict,
-                      profile=profile,
+                      profile=profile, debug=debug_mode,
                       json_errors=getattr(args, 'json_errors', False))
 
 

inscript_lang-3.9.6.23/inscript_lang.egg-info/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: inscript-lang
+Version: 3.9.6.23
+Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
+Home-page: https://github.com/authorss81/inscript
+Author: Shreyasi Sarkar
+License: MIT
+Project-URL: Homepage, https://github.com/authorss81/inscript
+Project-URL: Repository, https://github.com/authorss81/inscript
+Project-URL: Bug Tracker, https://github.com/authorss81/inscript/issues
+Project-URL: Documentation, https://authorss81.github.io/inscript/docs/
+Keywords: game,scripting,language,gamedev,gdscript
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: game
+Requires-Dist: pygame>=2.0; extra == "game"
+Provides-Extra: lsp
+Requires-Dist: pygls>=1.0; extra == "lsp"
+Provides-Extra: all
+Requires-Dist: pygame>=2.0; extra == "all"
+Requires-Dist: pygls>=1.0; extra == "all"
+Dynamic: home-page
+Dynamic: requires-python
+
+# InScript Lexer - Rust Implementation (v3.7.2)
+
+**Real, compilable Rust tokenizer** for InScript language.
+
+## Features
+
+✅ Zero-copy token references (fast, memory efficient)
+✅ State machine lexer (no backtracking)
+✅ 30+ token types (keywords, operators, literals)
+✅ Accurate line/column tracking
+✅ Comprehensive error reporting
+✅ Python FFI via PyO3
+✅ Full test coverage
+
+## Build
+
+```bash
+cargo build --release
+```
+
+## Token Types Supported
+
+### Literals
+- Numbers (integers and floats)
+- Strings (single and double quoted)
+- Identifiers
+
+### Keywords
+- if, else, while, for, fn, return
+- true, false, nil
+- and, or, not
+
+### Operators
+- Arithmetic: +, -, *, /, %
+- Comparison: ==, !=, <, <=, >, >=
+- Assignment: =
+- Logical: and, or, not
+
+### Delimiters
+- Parentheses: ( )
+- Braces: { }
+- Brackets: [ ]
+- Punctuation: , . ; : ->
+
+## Rust Usage
+
+```rust
+use inscript_lexer::Lexer;
+
+fn main() {
+    let code = "let x = 42;";
+    let lexer = Lexer::new(code);
+    
+    for token in lexer {
+        match token {
+            Ok(t) => println!("{:?}: {}", t.token_type, t.value),
+            Err(e) => eprintln!("Error: {}", e),
+        }
+    }
+}
+```
+
+## Python Usage (after compilation)
+
+```python
+from inscript_lexer import PyLexer, tokenize_string
+
+# Method 1: Using PyLexer class
+lexer = PyLexer("let x = 42;")
+tokens = lexer.tokens()
+print(f"Found {lexer.count()} tokens")
+
+# Method 2: Direct tokenization
+tokens = tokenize_string("if true then x else y")
+for token in tokens:
+    print(f"{token.token_type}: {token.value}")
+```
+
+## Performance
+
+### Expected Benchmarks
+- Simple tokens: < 100ns per token
+- Complex code: < 10µs per 100 tokens
+- Memory: O(1) per token
+
+### Optimizations
+- Inline hot paths
+- No allocations in common cases
+- SIMD-friendly string scanning
+- Zero-copy string references
+
+## Testing
+
+```bash
+# Run tests
+cargo test
+
+# Run with output
+cargo test -- --nocapture
+
+# Benchmark
+cargo bench
+```
+
+## Accuracy
+
+✅ Correct line/column tracking
+✅ Handles escape sequences
+✅ Detects unterminated strings
+✅ Error recovery
+
+## License
+
+MIT
+

{inscript_lang-3.0.0 → inscript_lang-3.9.6.23}/inscript_lang.egg-info/SOURCES.txt

@@ -32,5 +32,17 @@ inscript_lang.egg-info/PKG-INFO
 inscript_lang.egg-info/SOURCES.txt
 inscript_lang.egg-info/dependency_links.txt
 inscript_lang.egg-info/entry_points.txt
+inscript_lang.egg-info/not-zip-safe
 inscript_lang.egg-info/requires.txt
-inscript_lang.egg-info/top_level.txt
+inscript_lang.egg-info/top_level.txt
+inscript_rust_parser/Cargo.toml
+lsp/__init__.py
+lsp/code_actions.py
+lsp/completions.py
+lsp/definition.py
+lsp/diagnostics.py
+lsp/hover.py
+lsp/semantic_tokens.py
+lsp/server.py
+tools/__init__.py
+tools/sync_versions.py