lispython 0.3.3__tar.gz → 0.4.0__tar.gz

lispython-0.4.0/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "lispython.lsp.pythonPath": "/home/user/workspace/lispython/.venv/bin/python"
+}

{lispython-0.3.3 → lispython-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lispython
-Version: 0.3.3
+Version: 0.4.0
 Summary: Lisp-like Syntax for Python with Lisp-like Macros
 Project-URL: Homepage, https://jetack.github.io/lispython
 Project-URL: Repository, https://github.com/jetack/lispython
@@ -8,6 +8,7 @@ Author-email: Jetack <jetack23@gmail.com>
 License: MIT
 License-File: LICENSE.md
 Requires-Python: >=3.11
+Requires-Dist: pygls>=1.0.0
 Provides-Extra: dev
 Requires-Dist: pre-commit>=3.6.0; extra == 'dev'
 Requires-Dist: pytest>=8.0.0; extra == 'dev'

{lispython-0.3.3 → lispython-0.4.0}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "lispython"
-version = "0.3.3"
+version = "0.4.0"
 description = "Lisp-like Syntax for Python with Lisp-like Macros"
 authors = [{ name = "Jetack", email = "jetack23@gmail.com" }]
 license = { text = "MIT" }
 readme = "README.md"
 requires-python = ">=3.11"
-dependencies = []
+dependencies = ["pygls>=1.0.0"]
 
 [project.urls]
 Homepage = "https://jetack.github.io/lispython"
@@ -15,6 +15,7 @@ Repository = "https://github.com/jetack/lispython"
 [project.scripts]
 lpy = "lispy:run"
 l2py = "lispy:l2py"
+lpy-lsp = "lispy.lsp:main"
 test = "pytest:main"
 
 [project.optional-dependencies]

lispython-0.4.0/src/lispy/lsp/__init__.py

@@ -0,0 +1,6 @@
+import lispy  # register .lpy import hook
+from lispy.lsp.server import server
+
+
+def main():
+    server.start_io()

lispython-0.4.0/src/lispy/lsp/__main__.py

@@ -0,0 +1,3 @@
+from lispy.lsp import main
+
+main()

lispython-0.4.0/src/lispy/lsp/server.lpy

@@ -0,0 +1,721 @@
+(require lispy.macros *)
+
+(import builtins)
+(import glob)
+(import inspect)
+(import logging)
+(import os)
+(import os.path as osp)
+(import re)
+(import pathlib)
+
+(from lsprotocol [types as lsp])
+(from pygls.lsp.server [LanguageServer])
+
+(from lispy.core.nodes *)
+(from lispy.core.parser [parse])
+
+(= logger (logging.getLogger __name__))
+
+;; ---------------------------------------------------------------------------
+;; Server instance
+;; ---------------------------------------------------------------------------
+
+(= server (LanguageServer "lpy-lsp" "v0.1.0"))
+
+;; ---------------------------------------------------------------------------
+;; Special-form documentation (for hover)
+;; ---------------------------------------------------------------------------
+
+(= SPECIAL-FORM-DOCS
+  {;; Statement forms
+   "def"       "```\n(def name [params] body...)\n```\n\nDefine a function. Parameters are given in a bracket list. An optional docstring can follow the parameter list."
+   "async-def" "```\n(async-def name [params] body...)\n```\n\nDefine an async function (coroutine)."
+   "class"     "```\n(class Name [bases] body...)\n```\n\nDefine a class. Bases are given in a bracket list."
+   "defmacro"  "```\n(defmacro name [params] body...)\n```\n\nDefine a compile-time macro. The macro receives unevaluated S-expressions and must return an S-expression."
+   "if"        "```\n(if condition then-body)\n(if condition then-body else-body)\n```\n\nConditional statement. Compiles to Python `if/else`."
+   "while"     "```\n(while condition body...)\n```\n\nWhile loop."
+   "for"       "```\n(for target iterable body...)\n```\n\nFor loop. `target` is bound to each element of `iterable`."
+   "async-for" "```\n(async-for target iterable body...)\n```\n\nAsync for loop — use inside `async-def`."
+   "do"        "```\n(do body...)\n```\n\nExecute a sequence of statements (block). Used where a single expression is expected but multiple statements are needed."
+   "match"     "```\n(match subject case...)\n```\n\nStructural pattern matching (Python 3.10+)."
+   "try"       "```\n(try body except-clauses... [finally-clause])\n```\n\nTry/except/finally statement."
+   "with"      "```\n(with [ctx-expr as-name] body...)\n```\n\nContext manager statement."
+   "async-with" "```\n(async-with [ctx-expr as-name] body...)\n```\n\nAsync context manager — use inside `async-def`."
+   "import"    "```\n(import module)\n(import module :as alias)\n```\n\nImport a module."
+   "from"      "```\n(from module [names...])\n(from module [name :as alias ...])\n```\n\nImport specific names from a module."
+   "require"   "```\n(require module *)\n(require module [names...])\n```\n\nImport macros from a LisPython macro module at compile time."
+   "="         "```\n(= target value)\n```\n\nAssignment statement."
+   ":="        "```\n(:= target value)\n```\n\nWalrus operator (assignment expression)."
+   "return"    "```\n(return value)\n```\n\nReturn a value from a function."
+   "raise"     "```\n(raise exception)\n```\n\nRaise an exception."
+   "assert"    "```\n(assert condition)\n(assert condition message)\n```\n\nAssert that a condition is true."
+   "del"       "```\n(del target)\n```\n\nDelete a name or item."
+   "pass"      "```\n(pass)\n```\n\nNo-op placeholder statement."
+   "break"     "```\n(break)\n```\n\nBreak out of a loop."
+   "continue"  "```\n(continue)\n```\n\nContinue to the next loop iteration."
+   "global"    "```\n(global name...)\n```\n\nDeclare names as global variables."
+   "nonlocal"  "```\n(nonlocal name...)\n```\n\nDeclare names as nonlocal variables."
+   "yield"     "```\n(yield value)\n```\n\nYield a value from a generator."
+   "yield-from" "```\n(yield-from iterable)\n```\n\nYield all values from a sub-generator."
+   "await"     "```\n(await expr)\n```\n\nAwait a coroutine."
+   "deco"      "```\n(deco decorator (def ...))\n```\n\nApply a decorator to the following function/class definition."
+   "lambda"    "```\n(lambda [params] body)\n```\n\nAnonymous function (lambda expression)."
+   ;; Expression forms
+   "ife"       "```\n(ife condition then-expr else-expr)\n```\n\nTernary conditional expression (`then-expr if condition else else-expr`)."
+   "."         "```\n(. obj attr)\n```\n\nAttribute access (`obj.attr`)."
+   "sub"       "```\n(sub obj index)\n```\n\nSubscript access (`obj[index]`)."
+   ","         "```\n(, a b c)\n```\n\nTuple literal."
+   "fn"        "```\n(fn [params] body)\n```\n\nLambda alias — same as `lambda`."
+   ;; Operators
+   "+"  "Arithmetic addition / unary positive."
+   "-"  "Arithmetic subtraction / unary negative."
+   "*"  "Arithmetic multiplication / iterable unpacking."
+   "/"  "True division."
+   "//" "Floor (integer) division."
+   "%"  "Modulo (remainder)."
+   "**" "Exponentiation."
+   "@"  "Matrix multiplication."
+   "<<" "Bitwise left shift."
+   ">>" "Bitwise right shift."
+   "|"  "Bitwise OR."
+   "^"  "Bitwise XOR."
+   "&"  "Bitwise AND."
+   "~"  "Bitwise NOT / unquote (inside quasiquote)."
+   "and" "Logical AND (short-circuit)."
+   "or"  "Logical OR (short-circuit)."
+   "not" "Logical NOT."
+   "==" "Equality test."
+   "!=" "Inequality test."
+   "<"  "Less than."
+   "<=" "Less than or equal."
+   ">"  "Greater than."
+   ">=" "Greater than or equal."
+   "is"     "Identity test (`x is y`)."
+   "is-not" "Negated identity test (`x is not y`)."
+   "in"     "Membership test (`x in y`)."
+   "not-in" "Negated membership test (`x not in y`)."
+   ;; Macro-related
+   "'"  "Quote — prevent evaluation; return the form as data."
+   "`"  "Quasiquote — like quote but allows unquote (`~`) splicing."
+   "~@" "Unquote-splice — splice a list into a quasiquote."
+   "f-string" "```\nf\"text {expr} more\"\n```\n\nFormatted string literal (f-string)."})
+
+;; ---------------------------------------------------------------------------
+;; Python builtins introspection
+;; ---------------------------------------------------------------------------
+
+(def build-builtin-info []
+  "Build a dict of Python builtin names -> {signature, doc, source_file, lineno}."
+  (= info {})
+  (for name in (dir builtins)
+    (if (.startswith name "_")
+        (continue))
+    (= obj (getattr builtins name))
+    (if (and (not (callable obj)) (not (isinstance obj type)))
+        (continue))
+    (= entry {"name" name})
+    ;; Signature
+    (try
+      (do (= sig (inspect.signature obj))
+          (= (sub entry "signature") f"{name}{sig}"))
+      (except [(, ValueError TypeError)]
+        (= (sub entry "signature") name)))
+    ;; Docstring
+    (= doc (inspect.getdoc obj))
+    (if doc
+        (= (sub entry "doc") (sub (.split doc "\n\n") 0))
+        (= (sub entry "doc") ""))
+    ;; Source file
+    (try
+      (do (= source-file (inspect.getfile obj))
+          (try
+            (do (= (, _ lineno) (inspect.getsourcelines obj))
+                (= (sub entry "lineno") lineno))
+            (except [(, OSError TypeError)]
+              (= (sub entry "lineno") 1)))
+          (= (sub entry "source_file") source-file))
+      (except [(, TypeError OSError)]
+        (= (sub entry "source_file") None)
+        (= (sub entry "lineno") None)))
+    (= (sub info name) entry))
+  (return info))
+
+(= BUILTIN-INFO (build-builtin-info))
+
+;; ---------------------------------------------------------------------------
+;; Workspace index
+;; ---------------------------------------------------------------------------
+
+;; Global index: {symbol_name: [Location, ...]} across all .lpy files
+(= WORKSPACE-INDEX {})
+;; Cache of parsed trees per URI: {uri: tree}
+(= FILE-TREES {})
+
+(def uri-to-path [uri]
+  "Convert a file:// URI to a filesystem path."
+  (if (.startswith uri "file://")
+      (return (sub uri [: 7 None]))
+      (return uri)))
+
+(def path-to-uri [path]
+  "Convert a filesystem path to a file:// URI."
+  (return (.as-uri (pathlib.Path path))))
+
+(def index-file [uri]
+  "Parse a .lpy file and add its definitions to the workspace index.
+   Removes old entries for this URI before re-indexing."
+  ;; Remove old entries for this URI
+  (= to-remove [])
+  (for [name locs] in (.items WORKSPACE-INDEX)
+    (= (sub WORKSPACE-INDEX name)
+       [loc for loc in locs if (!= loc.uri uri)])
+    (if (== (len (sub WORKSPACE-INDEX name)) 0)
+        (.append to-remove name)))
+  (for name in to-remove
+    (del (sub WORKSPACE-INDEX name)))
+
+  ;; Parse and collect definitions
+  (= fpath (uri-to-path uri))
+  (if (not (osp.isfile fpath))
+      (return))
+  (try
+    (with [(open fpath "rb") as f]
+      (= src (.decode (f.read) "utf-8")))
+    (= tree (parse src))
+    (= (sub FILE-TREES uri) tree)
+    (collect-definitions tree uri :defs WORKSPACE-INDEX)
+    (except [Exception as exc]
+      (logger.debug f"Failed to index {fpath}: {exc}"))))
+
+(def index-workspace [workspace-folders]
+  "Scan all .lpy files in workspace folders and index them."
+  (for folder in workspace-folders
+    (= root (uri-to-path folder.uri))
+    (for fpath in (glob.glob (osp.join root "**" "*.lpy") :recursive True)
+      (index-file (path-to-uri fpath))))
+  (logger.info f"Indexed {(len WORKSPACE-INDEX)} symbols from workspace"))
+
+(def resolve-module-to-file [module-name workspace-folders]
+  "Resolve a LisPython module name to a .lpy file path.
+   e.g., 'lispy.tools' -> '/path/to/src/lispy/tools.lpy'"
+  (= parts (.split (.replace module-name "-" "_") "."))
+  (= rel-path (+ (osp.join *parts) ".lpy"))
+  ;; Search in workspace folders and sys.path-like locations
+  (for folder in workspace-folders
+    (= root (uri-to-path folder.uri))
+    ;; Direct match
+    (= candidate (osp.join root rel-path))
+    (if (osp.isfile candidate)
+        (return candidate))
+    ;; Check in src/ subdirectory
+    (= candidate (osp.join root "src" rel-path))
+    (if (osp.isfile candidate)
+        (return candidate)))
+  (return None))
+
+(def find-import-target [node workspace-folders]
+  "Given an import/from/require node, resolve where the imported name is defined."
+  (= form (. node op value))
+  (cond
+    (== form "from")
+    (do ;; (from module [names...])
+        (if (< (len node) 3)
+            (return None))
+        (= module-name (. (sub node 1) value))
+        (= fpath (resolve-module-to-file module-name workspace-folders))
+        (if fpath
+            (return fpath))
+        (return None))
+
+    (== form "import")
+    (do ;; (import module)
+        (if (< (len node) 2)
+            (return None))
+        (= module-name (. (sub node 1) value))
+        (= fpath (resolve-module-to-file module-name workspace-folders))
+        (if fpath
+            (return fpath))
+        (return None))
+
+    (== form "require")
+    (do ;; (require module *)
+        (if (< (len node) 2)
+            (return None))
+        (= module-name (. (sub node 1) value))
+        (= fpath (resolve-module-to-file module-name workspace-folders))
+        (if fpath
+            (return fpath))
+        (return None))
+
+    (return None)))
+
+(def find-import-for-name [tree name]
+  "Find the import/from/require node that imports a given name."
+  (for node in tree
+    (if (not (isinstance node Paren))
+        (continue))
+    (if (== (len node) 0)
+        (continue))
+    (= form (ife (isinstance node.op Symbol) node.op.value ""))
+    (cond
+      (== form "from")
+      (do ;; (from module [names...])
+          (for child in (sub node.list [: 1 None])
+            (if (isinstance child Bracket)
+                (for item in child.list
+                  (if (and (isinstance item Symbol) (== item.value name))
+                      (return node))))))
+      (== form "import")
+      (do ;; (import module) or (import module as alias)
+          (for child in (sub node.list [: 1 None])
+            (if (and (isinstance child Symbol) (== child.value name))
+                (return node))))
+      (== form "require")
+      (do ;; (require module *) - imports all macros
+          (return node))))
+  (return None))
+
+;; ---------------------------------------------------------------------------
+;; Helpers
+;; ---------------------------------------------------------------------------
+
+(def make-position [line char]
+  (return (lsp.Position :line line :character char)))
+
+(def make-range [start-line start-char end-line end-char]
+  (return (lsp.Range
+    :start (make-position start-line start-char)
+    :end (make-position end-line end-char))))
+
+(def node-range [node]
+  "Convert a LisPython AST node's position info to an LSP Range.
+   The parser uses 1-based line numbers; LSP uses 0-based."
+  (return (make-range
+    (- node.lineno 1)
+    node.col_offset
+    (- node.end_lineno 1)
+    node.end_col_offset)))
+
+(def extract-error-position [exc src]
+  "Best-effort extraction of line/col from a parse or compile error."
+  ;; Some Python exceptions carry lineno/offset
+  (= lineno (getattr exc "lineno" None))
+  (if (is-not lineno None)
+      (do (= col (- (or (getattr exc "offset" None) 1) 1))
+          (return (, (- lineno 1) col (- lineno 1) col))))
+  ;; Try to extract from the message
+  (= msg (str exc))
+  (= m (re.search "line\\s+(\\d+)" msg re.IGNORECASE))
+  (if m
+      (do (= line (- (int (.group m 1)) 1))
+          (= col 0)
+          (= mc (re.search "col(?:umn)?\\s+(\\d+)" msg re.IGNORECASE))
+          (if mc
+              (= col (int (.group mc 1))))
+          (return (, line col line col))))
+  (return None))
+
+;; ---------------------------------------------------------------------------
+;; Diagnostics
+;; ---------------------------------------------------------------------------
+
+(def compute-diagnostics [source uri]
+  (= diagnostics [])
+  ;; 1. Parse
+  (try
+    (= tree (parse source))
+    (except [Exception as exc]
+      (= pos (extract-error-position exc source))
+      (if (is pos None)
+          (= pos (, 0 0 0 0)))
+      (.append diagnostics
+        (lsp.Diagnostic
+          :range (make-range *pos)
+          :severity lsp.DiagnosticSeverity.Error
+          :source "lpy-lsp"
+          :message f"Parse error: {exc}"))
+      (return diagnostics)))
+  ;; 2. Compile (best-effort)
+  (try
+    (do (from lispy.core.macro [macroexpand-then-compile])
+        (macroexpand-then-compile tree))
+    (except [Exception as exc]
+      (= pos (extract-error-position exc source))
+      (if (is pos None)
+          (= pos (, 0 0 0 0)))
+      (.append diagnostics
+        (lsp.Diagnostic
+          :range (make-range *pos)
+          :severity lsp.DiagnosticSeverity.Error
+          :source "lpy-lsp"
+          :message f"Compile error: {exc}"))))
+  (return diagnostics))
+
+(def publish-diagnostics [ls uri]
+  (= doc (.get-text-document ls.workspace uri))
+  (= diagnostics (compute-diagnostics doc.source uri))
+  (.text-document-publish-diagnostics ls
+    (lsp.PublishDiagnosticsParams :uri uri :diagnostics diagnostics)))
+
+;; ---------------------------------------------------------------------------
+;; Document symbols
+;; ---------------------------------------------------------------------------
+
+(def symbol-name [node]
+  "Extract a string name from a node."
+  (cond (isinstance node Symbol)
+        (return node.value)
+        (isinstance node Annotation)
+        (return (symbol-name node.value))
+        (isinstance node String)
+        (return (.strip node.value "\"'"))
+        (return (str node))))
+
+(def walk-symbols [nodes]
+  "Walk top-level parsed forms and produce DocumentSymbol entries."
+  (= symbols [])
+  (for node in nodes
+    (if (or (not (isinstance node Paren)) (== (len node) 0))
+        (continue))
+    (= op node.op)
+    (if (not (isinstance op Symbol))
+        (continue))
+    (= form op.value)
+
+    (cond
+      (in form (, "def" "async-def"))
+      (do (if (< (len node) 2) (continue))
+          (= name (symbol-name (sub node 1)))
+          (= rng (node-range node))
+          (= sel (node-range (sub node 1)))
+          (= children (ife (> (len node) 3)
+                           (walk-symbols (sub node.list [: 3 None]))
+                           []))
+          (.append symbols
+            (lsp.DocumentSymbol
+              :name name
+              :kind lsp.SymbolKind.Function
+              :range rng
+              :selection-range sel
+              :children (or children None))))
+
+      (== form "class")
+      (do (if (< (len node) 2) (continue))
+          (= name (symbol-name (sub node 1)))
+          (= rng (node-range node))
+          (= sel (node-range (sub node 1)))
+          (= body-nodes (ife (> (len node) 3)
+                             (sub node.list [: 3 None])
+                             (sub node.list [: 2 None])))
+          (= children (walk-symbols body-nodes))
+          (.append symbols
+            (lsp.DocumentSymbol
+              :name name
+              :kind lsp.SymbolKind.Class
+              :range rng
+              :selection-range sel
+              :children (or children None))))
+
+      (== form "defmacro")
+      (do (if (< (len node) 2) (continue))
+          (.append symbols
+            (lsp.DocumentSymbol
+              :name (symbol-name (sub node 1))
+              :kind lsp.SymbolKind.Function
+              :range (node-range node)
+              :selection-range (node-range (sub node 1))
+              :detail "macro")))
+
+      (== form "=")
+      (do (if (< (len node) 2) (continue))
+          (.append symbols
+            (lsp.DocumentSymbol
+              :name (symbol-name (sub node 1))
+              :kind lsp.SymbolKind.Variable
+              :range (node-range node)
+              :selection-range (node-range (sub node 1)))))
+
+      (in form (, "import" "from"))
+      (do (if (< (len node) 2) (continue))
+          (.append symbols
+            (lsp.DocumentSymbol
+              :name (symbol-name (sub node 1))
+              :kind lsp.SymbolKind.Module
+              :range (node-range node)
+              :selection-range (node-range (sub node 1)))))
+
+      (== form "require")
+      (do (if (< (len node) 2) (continue))
+          (.append symbols
+            (lsp.DocumentSymbol
+              :name (symbol-name (sub node 1))
+              :kind lsp.SymbolKind.Module
+              :range (node-range node)
+              :selection-range (node-range (sub node 1))
+              :detail "macro require")))))
+
+  (return symbols))
+
+;; ---------------------------------------------------------------------------
+;; Hover
+;; ---------------------------------------------------------------------------
+
+(def node-at-position [nodes line-0 col]
+  "Find the most specific node at the given 0-based position."
+  (for node in nodes
+    (= n-start-line (- node.lineno 1))
+    (= n-start-col node.col_offset)
+    (= n-end-line (- node.end_lineno 1))
+    (= n-end-col node.end_col_offset)
+    ;; Check if position is inside this node's range
+    (if (< (, line-0 col) (, n-start-line n-start-col))
+        (continue))
+    (if (> (, line-0 col) (, n-end-line n-end-col))
+        (continue))
+    ;; Position is within this node — try to go deeper
+    (if (isinstance node Expression)
+        (do (= deeper (node-at-position node.list line-0 col))
+            (if (is-not deeper None)
+                (return deeper))))
+    (if (isinstance node (, Wrapper MetaIndicator))
+        (do (= deeper (node-at-position [node.value] line-0 col))
+            (if (is-not deeper None)
+                (return deeper))))
+    (return node))
+  (return None))
+
+;; ---------------------------------------------------------------------------
+;; Definition index
+;; ---------------------------------------------------------------------------
+
+(def collect-definitions [nodes uri :defs None]
+  "Walk AST and collect all definition locations keyed by symbol name."
+  (if (is defs None)
+      (= defs {}))
+
+  (for node in nodes
+    (if (or (not (isinstance node Paren)) (== (len node) 0))
+        (continue))
+    (= op node.op)
+    (if (not (isinstance op Symbol))
+        (continue))
+    (= form op.value)
+
+    (cond
+      (in form (, "def" "async-def" "defmacro"))
+      (do (if (and (>= (len node) 2) (isinstance (sub node 1) Symbol))
+              (do (= name (. (sub node 1) value))
+                  (= loc (lsp.Location :uri uri :range (node-range (sub node 1))))
+                  (.append (.setdefault defs name []) loc)
+                  (if (> (len node) 3)
+                      (collect-definitions (sub node.list [: 3 None]) uri :defs defs)))))
+
+      (== form "class")
+      (do (if (and (>= (len node) 2) (isinstance (sub node 1) Symbol))
+              (do (= name (. (sub node 1) value))
+                  (= loc (lsp.Location :uri uri :range (node-range (sub node 1))))
+                  (.append (.setdefault defs name []) loc)
+                  (= body (ife (> (len node) 3)
+                               (sub node.list [: 3 None])
+                               (sub node.list [: 2 None])))
+                  (collect-definitions body uri :defs defs))))
+
+      (== form "=")
+      (do (if (and (>= (len node) 2) (isinstance (sub node 1) Symbol))
+              (do (= name (. (sub node 1) value))
+                  (= loc (lsp.Location :uri uri :range (node-range (sub node 1))))
+                  (.append (.setdefault defs name []) loc))))
+
+      (in form (, "for" "async-for"))
+      (do (if (and (>= (len node) 2) (isinstance (sub node 1) Symbol))
+              (do (= name (. (sub node 1) value))
+                  (= loc (lsp.Location :uri uri :range (node-range (sub node 1))))
+                  (.append (.setdefault defs name []) loc)))
+          (collect-definitions (sub node.list [: 1 None]) uri :defs defs))
+
+      (in form (, "import" "from"))
+      (do (for child in (sub node.list [: 1 None])
+            (cond
+              (and (isinstance child Symbol) (not-in child.value (, "as" "*")))
+              (do (= loc (lsp.Location :uri uri :range (node-range child)))
+                  (.append (.setdefault defs child.value []) loc))
+              (isinstance child Bracket)
+              (for item in child.list
+                (if (and (isinstance item Symbol) (!= item.value "as"))
+                    (do (= loc (lsp.Location :uri uri :range (node-range item)))
+                        (.append (.setdefault defs item.value []) loc)))))))
+
+      ;; Default: recurse into nested paren forms
+      (do (collect-definitions
+            [c for c in node.list if (isinstance c Paren)]
+            uri :defs defs))))
+
+  (return defs))
+
+;; ---------------------------------------------------------------------------
+;; References
+;; ---------------------------------------------------------------------------
+
+(def collect-references [nodes name uri]
+  "Find all occurrences of a symbol name in the AST."
+  (= refs [])
+  (for node in nodes
+    (if (and (isinstance node Symbol) (== node.value name))
+        (.append refs (lsp.Location :uri uri :range (node-range node))))
+    (if (isinstance node Expression)
+        (.extend refs (collect-references node.list name uri)))
+    (if (and (isinstance node (, Wrapper MetaIndicator))
+             (is-not node.value None))
+        (.extend refs (collect-references [node.value] name uri))))
+  (return refs))
+
+;; ---------------------------------------------------------------------------
+;; LSP event handlers
+;; ---------------------------------------------------------------------------
+
+(deco (server.feature lsp.INITIALIZED)
+(def on-initialized [ls params]
+  (= folders (ife ls.workspace.folders
+                  (list (.values ls.workspace.folders))
+                  []))
+  (if folders
+      (index-workspace folders))))
+
+(deco (server.feature lsp.TEXT_DOCUMENT_DID_OPEN)
+(def did-open [ls params]
+  (= uri params.text_document.uri)
+  (index-file uri)
+  (publish-diagnostics ls uri)))
+
+(deco (server.feature lsp.TEXT_DOCUMENT_DID_CHANGE)
+(def did-change [ls params]
+  (publish-diagnostics ls params.text_document.uri)))
+
+(deco (server.feature lsp.TEXT_DOCUMENT_DID_SAVE)
+(def did-save [ls params]
+  (= uri params.text_document.uri)
+  (index-file uri)
+  (publish-diagnostics ls uri)))
+
+(deco (server.feature lsp.TEXT_DOCUMENT_DOCUMENT_SYMBOL)
+(def document-symbol [ls params]
+  (= doc (.get-text-document ls.workspace params.text_document.uri))
+  (try
+    (= tree (parse doc.source))
+    (except [Exception]
+      (return [])))
+  (return (walk-symbols tree))))
+
+(deco (server.feature lsp.TEXT_DOCUMENT_HOVER)
+(def hover [ls params]
+  (= doc (.get-text-document ls.workspace params.text_document.uri))
+  (try
+    (= tree (parse doc.source))
+    (except [Exception]
+      (return None)))
+  (= pos params.position)
+  (= target (node-at-position tree pos.line pos.character))
+  (if (is target None)
+      (return None))
+  ;; Look up documentation for the symbol
+  (if (isinstance target Symbol)
+      (do
+        (= name target.value)
+        ;; 1. LisPython special forms
+        (= doc-text (.get SPECIAL-FORM-DOCS name))
+        (if doc-text
+            (return (lsp.Hover
+              :contents (lsp.MarkupContent
+                :kind lsp.MarkupKind.Markdown
+                :value doc-text)
+              :range (node-range target))))
+        ;; 2. Python builtins
+        (= builtin-name (.replace name "-" "_"))
+        (= bi (.get BUILTIN-INFO builtin-name))
+        (if bi
+            (do (= sig (sub bi "signature"))
+                (= doc-body (sub bi "doc"))
+                (= hover-md f"```python\n{sig}\n```\n\n*(Python builtin)*")
+                (if doc-body
+                    (+= hover-md f"\n\n{doc-body}"))
+                (return (lsp.Hover
+                  :contents (lsp.MarkupContent
+                    :kind lsp.MarkupKind.Markdown
+                    :value hover-md)
+                  :range (node-range target)))))))
+  (return None)))
+
+(deco (server.feature lsp.TEXT_DOCUMENT_DEFINITION)
+(def definition [ls params]
+  (= doc (.get-text-document ls.workspace params.text_document.uri))
+  (try
+    (= tree (parse doc.source))
+    (except [Exception]
+      (return None)))
+  (= pos params.position)
+  (= target (node-at-position tree pos.line pos.character))
+  (if (or (is target None) (not (isinstance target Symbol)))
+      (return None))
+  (= name target.value)
+  (if (in name SPECIAL-FORM-DOCS)
+      (return None))
+
+  ;; 1. Local definitions in the file
+  (= defs (collect-definitions tree doc.uri))
+  (= local (.get defs name))
+  (if local
+      (return local))
+
+  ;; 2. Resolve via import statements — find which module imports this name
+  (= folders (ife ls.workspace.folders
+                  (list (.values ls.workspace.folders))
+                  []))
+  (= import-node (find-import-for-name tree name))
+  (if import-node
+      (do (= fpath (find-import-target import-node folders))
+          (if fpath
+              (do (= target-uri (path-to-uri fpath))
+                  ;; Make sure the target file is indexed
+                  (if (not-in target-uri FILE-TREES)
+                      (index-file target-uri))
+                  ;; Look up the name in the target file's definitions
+                  (= target-tree (.get FILE-TREES target-uri))
+                  (if target-tree
+                      (do (= target-defs (collect-definitions target-tree target-uri))
+                          (= result (.get target-defs name))
+                          (if result
+                              (return result))))))))
+
+  ;; 3. Workspace-wide index lookup
+  (= ws-result (.get WORKSPACE-INDEX name))
+  (if ws-result
+      ;; Filter out definitions from the current file (already checked)
+      (do (= external [loc for loc in ws-result if (!= loc.uri doc.uri)])
+          (if external
+              (return external))))
+
+  ;; 4. Python builtins with source files
+  (= builtin-name (.replace name "-" "_"))
+  (= bi (.get BUILTIN-INFO builtin-name))
+  (if (and bi (sub bi "source_file"))
+      (do (= source-path (pathlib.Path (sub bi "source_file")))
+          (if (.exists source-path)
+              (do (= lineno (- (or (sub bi "lineno") 1) 1))
+                  (return [(lsp.Location
+                    :uri (.as-uri source-path)
+                    :range (make-range lineno 0 lineno 0))])))))
+  (return None)))
+
+(deco (server.feature lsp.TEXT_DOCUMENT_REFERENCES)
+(def references [ls params]
+  (= doc (.get-text-document ls.workspace params.text_document.uri))
+  (try
+    (= tree (parse doc.source))
+    (except [Exception]
+      (return None)))
+  (= pos params.position)
+  (= target (node-at-position tree pos.line pos.character))
+  (if (or (is target None) (not (isinstance target Symbol)))
+      (return None))
+  (return (collect-references tree target.value doc.uri))))

{lispython-0.3.3 → lispython-0.4.0}/uv.lock

@@ -2,6 +2,15 @@ version = 1
 revision = 3
 requires-python = ">=3.11"
 
+[[package]]
+name = "attrs"
+version = "26.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" },
+]
+
 [[package]]
 name = "babel"
 version = "2.17.0"
@@ -25,6 +34,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/02/e3/a4fa1946722c4c7b063cc25043a12d9ce9b4323777f89643be74cef2993c/backrefs-6.1-py39-none-any.whl", hash = "sha256:a9e99b8a4867852cad177a6430e31b0f6e495d65f8c6c134b68c14c3c95bf4b0", size = 381058, upload-time = "2025-11-15T14:52:06.698Z" },
 ]
 
+[[package]]
+name = "cattrs"
+version = "26.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a0/ec/ba18945e7d6e55a58364d9fb2e46049c1c2998b3d805f19b703f14e81057/cattrs-26.1.0.tar.gz", hash = "sha256:fa239e0f0ec0715ba34852ce813986dfed1e12117e209b816ab87401271cdd40", size = 495672, upload-time = "2026-02-18T22:15:19.406Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/80/56/60547f7801b97c67e97491dc3d9ade9fbccbd0325058fd3dfcb2f5d98d90/cattrs-26.1.0-py3-none-any.whl", hash = "sha256:d1e0804c42639494d469d08d4f26d6b9de9b8ab26b446db7b5f8c2e97f7c3096", size = 73054, upload-time = "2026-02-18T22:15:17.958Z" },
+]
+
 [[package]]
 name = "certifi"
 version = "2025.11.12"
@@ -240,6 +262,9 @@ wheels = [
 name = "lispython"
 version = "0.3.3"
 source = { editable = "." }
+dependencies = [
+    { name = "pygls" },
+]
 
 [package.optional-dependencies]
 dev = [
@@ -260,12 +285,26 @@ requires-dist = [
     { name = "mkdocs-macros-plugin", marker = "extra == 'docs'", specifier = ">=1.3.7" },
     { name = "mkdocs-material", marker = "extra == 'docs'", specifier = ">=9.6.14" },
     { name = "pre-commit", marker = "extra == 'dev'", specifier = ">=3.6.0" },
+    { name = "pygls", specifier = ">=1.0.0" },
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0.0" },
     { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.8.0" },
     { name = "toml", marker = "extra == 'dev'", specifier = ">=0.10.2" },
 ]
 provides-extras = ["dev", "docs"]
 
+[[package]]
+name = "lsprotocol"
+version = "2025.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "cattrs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e9/26/67b84e6ec1402f0e6764ef3d2a0aaf9a79522cc1d37738f4e5bb0b21521a/lsprotocol-2025.0.0.tar.gz", hash = "sha256:e879da2b9301e82cfc3e60d805630487ac2f7ab17492f4f5ba5aaba94fe56c29", size = 74896, upload-time = "2025-06-17T21:30:18.156Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7b/f0/92f2d609d6642b5f30cb50a885d2bf1483301c69d5786286500d15651ef2/lsprotocol-2025.0.0-py3-none-any.whl", hash = "sha256:f9d78f25221f2a60eaa4a96d3b4ffae011b107537facee61d3da3313880995c7", size = 76250, upload-time = "2025-06-17T21:30:19.455Z" },
+]
+
 [[package]]
 name = "markdown"
 version = "3.10"
@@ -537,6 +576,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5d/19/fd3ef348460c80af7bb4669ea7926651d1f95c23ff2df18b9d24bab4f3fa/pre_commit-4.5.1-py2.py3-none-any.whl", hash = "sha256:3b3afd891e97337708c1674210f8eba659b52a38ea5f822ff142d10786221f77", size = 226437, upload-time = "2025-12-16T21:14:32.409Z" },
 ]
 
+[[package]]
+name = "pygls"
+version = "2.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "cattrs" },
+    { name = "lsprotocol" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/da/2e/7bbe061d175c0baddde8fc9edb908a4c31ba5d9165b8c68e3439c3a9f138/pygls-2.1.1.tar.gz", hash = "sha256:1da03ba9053201bb337dcdd8d121df70feb2a91e1a0dcc74de5da79755b1a201", size = 55091, upload-time = "2026-03-25T11:19:10.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fd/1a/208293b6c350f5abea6941d5606080d4a492644052504f5312e5de30a902/pygls-2.1.1-py3-none-any.whl", hash = "sha256:510a6dea2476177230c7d851125e5948efdf3fdb9ebfd8543fc434972f8faed4", size = 68975, upload-time = "2026-03-25T11:19:11.374Z" },
+]
+
 [[package]]
 name = "pygments"
 version = "2.19.2"
@@ -743,6 +796,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588, upload-time = "2020-11-01T01:40:20.672Z" },
 ]
 
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
 [[package]]
 name = "urllib3"
 version = "2.6.2"