zexus 1.6.8 → 1.7.2

package/src/zexus/lsp/__init__.py

@@ -4,6 +4,6 @@
 try:
     from .server import ZexusLanguageServer
     __all__ = ['ZexusLanguageServer']
-except ImportError:
+except (ImportError, NameError, RuntimeError):
     # pygls not available, LSP features won't work
     __all__ = []

package/src/zexus/lsp/definition_provider.py

@@ -1,22 +1,176 @@
-"""Definition provider for Zexus LSP."""
+"""Definition provider for Zexus LSP — go-to-definition support."""
 
 from typing import List, Dict, Any, Optional
+
 try:
-    from pygls.lsp.types import Position
+    from pygls.lsp.types import Position, Location, Range
     PYGLS_AVAILABLE = True
 except ImportError:
     PYGLS_AVAILABLE = False
 
 
+# AST node types that introduce named definitions
+_DEFINITION_NODE_TYPES = (
+    'ActionStatement', 'FunctionStatement', 'PureFunctionStatement',
+    'LetStatement', 'ConstStatement',
+    'EntityStatement', 'ContractStatement', 'DataStatement',
+    'EnumStatement', 'InterfaceStatement', 'ProtocolStatement',
+    'TypeAliasStatement', 'ModuleStatement', 'PackageStatement',
+    'ScreenStatement', 'ComponentStatement', 'MiddlewareStatement',
+    'PatternStatement', 'StreamStatement', 'ModifierDeclaration',
+)
+
+
+def _get_name(node) -> Optional[str]:
+    """Extract the string name from an AST definition node."""
+    name = getattr(node, 'name', None)
+    if name is None:
+        return None
+    if hasattr(name, 'value'):
+        return str(name.value)
+    return str(name)
+
+
+def _collect_definitions(node, defs: Dict[str, list]):
+    """Walk the AST recursively and collect all named definitions.
+
+    ``defs`` maps name → list of AST nodes (same name may be defined
+    more than once, e.g. multiple ``let`` re-assignments).
+    """
+    if node is None:
+        return
+    node_type = type(node).__name__
+
+    if node_type in _DEFINITION_NODE_TYPES:
+        name = _get_name(node)
+        if name:
+            defs.setdefault(name, []).append(node)
+
+    # Recurse into child nodes that may contain more definitions
+    for attr in ('statements', 'body', 'consequence', 'alternative',
+                 'methods', 'properties', 'cases', 'block', 'try_block',
+                 'catch_block', 'finally_block', 'members'):
+        child = getattr(node, attr, None)
+        if child is None:
+            continue
+        if isinstance(child, list):
+            for c in child:
+                _collect_definitions(c, defs)
+        else:
+            # BlockStatement, Program, etc.
+            stmts = getattr(child, 'statements', None)
+            if isinstance(stmts, list):
+                for c in stmts:
+                    _collect_definitions(c, defs)
+            else:
+                _collect_definitions(child, defs)
+
+
+def _find_token_position(tokens, name: str, definition_keywords=None):
+    """Scan the token list for the *first* definition of ``name``.
+
+    We look for a keyword token (``action``, ``let``, ``const``, ``entity``,
+    ``contract``, ``data``, ``enum``, ``interface``, ``protocol``, ``type``,
+    ``module``, ``package``, ``screen``, ``component``, ``middleware``,
+    ``pattern``, ``stream``, ``pure``) followed (possibly after a type
+    annotation) by an ``IDENT`` token whose ``literal`` matches ``name``.
+    Returns ``(line, column)`` (0-based) or ``None``.
+    """
+    if definition_keywords is None:
+        definition_keywords = {
+            'action', 'let', 'const', 'entity', 'contract', 'data',
+            'enum', 'interface', 'protocol', 'type', 'module', 'package',
+            'screen', 'component', 'middleware', 'pattern', 'stream',
+            'pure', 'fn', 'function', 'def', 'class', 'struct', 'modifier',
+        }
+
+    want_ident = False
+    for tok in tokens:
+        lit = getattr(tok, 'literal', '')
+        ttype = getattr(tok, 'type', '')
+
+        if lit in definition_keywords:
+            want_ident = True
+            continue
+
+        if want_ident and ttype == 'IDENT' and lit == name:
+            line = getattr(tok, 'line', 0)
+            col = getattr(tok, 'column', 0)
+            # Token lines are 1-based; LSP uses 0-based
+            return (max(0, line - 1), max(0, col))
+
+        if want_ident and ttype not in ('IDENT', 'COLON', ':', 'LBRACKET', 'RBRACKET',
+                                          'LT', 'GT', 'COMMA', 'STRING'):
+            # Not part of a type annotation — reset
+            want_ident = False
+
+    return None
+
+
+def _word_at_position(text: str, line: int, character: int) -> Optional[str]:
+    """Extract the identifier under the cursor."""
+    lines = text.split('\n')
+    if line >= len(lines):
+        return None
+    row = lines[line]
+    if character >= len(row):
+        return None
+
+    # Walk left
+    start = character
+    while start > 0 and (row[start - 1].isalnum() or row[start - 1] == '_'):
+        start -= 1
+    # Walk right
+    end = character
+    while end < len(row) and (row[end].isalnum() or row[end] == '_'):
+        end += 1
+
+    word = row[start:end]
+    return word if word else None
+
+
 class DefinitionProvider:
     """Provides go-to-definition for Zexus code."""
 
-    def get_definition(self, uri: str, position: Position, doc_info: Dict[str, Any]) -> Optional[List]:
-        """Get definition location for symbol at position."""
+    def get_definition(self, uri: str, position, doc_info: Dict[str, Any]) -> Optional[List]:
+        """Return a list of ``Location`` objects for the definition of the
+        symbol under the cursor, or ``None`` if not found.
+        """
         if not PYGLS_AVAILABLE:
             return None
-        
-        # TODO: Implement go-to-definition by analyzing AST
-        # For now, return None
-        
-        return None
+
+        text = doc_info.get('text', '')
+        ast = doc_info.get('ast')
+        tokens = doc_info.get('tokens', [])
+
+        if not text:
+            return None
+
+        line = position.line
+        character = position.character
+        word = _word_at_position(text, line, character)
+        if not word:
+            return None
+
+        # 1. Collect all definitions from the AST
+        defs: Dict[str, list] = {}
+        if ast:
+            _collect_definitions(ast, defs)
+
+        if word not in defs:
+            return None
+
+        # 2. Find the first definition position in the token stream
+        pos = _find_token_position(tokens, word)
+        if pos is None:
+            return None
+
+        def_line, def_col = pos
+        location = Location(
+            uri=uri,
+            range=Range(
+                start=Position(line=def_line, character=def_col),
+                end=Position(line=def_line, character=def_col + len(word)),
+            ),
+        )
+        return [location]

package/src/zexus/lsp/server.py

@@ -107,10 +107,18 @@ if PYGLS_AVAILABLE:
         
         # Parse the document
         try:
-            lexer = Lexer(text)
-            tokens = lexer.tokenize()
-            parser = Parser(tokens)
-            ast = parser.parse()
+            lexer = Lexer(text, filename=uri)
+            # Collect tokens for position mapping (used by providers)
+            tokens = []
+            while True:
+                tok = lexer.next_token()
+                tokens.append(tok)
+                if getattr(tok, 'type', '') == 'EOF':
+                    break
+            # Re-lex for the parser (parser consumes the lexer)
+            parse_lexer = Lexer(text, filename=uri)
+            parser = Parser(parse_lexer)
+            ast = parser.parse_program()
             ls.documents[uri] = {
                 'text': text,
                 'ast': ast,
@@ -136,10 +144,16 @@ if PYGLS_AVAILABLE:
             text = changes[0].text
             # Re-parse the document
             try:
-                lexer = Lexer(text)
-                tokens = lexer.tokenize()
-                parser = Parser(tokens)
-                ast = parser.parse()
+                lexer = Lexer(text, filename=uri)
+                tokens = []
+                while True:
+                    tok = lexer.next_token()
+                    tokens.append(tok)
+                    if getattr(tok, 'type', '') == 'EOF':
+                        break
+                parse_lexer = Lexer(text, filename=uri)
+                parser = Parser(parse_lexer)
+                ast = parser.parse_program()
                 ls.documents[uri] = {
                     'text': text,
                     'ast': ast,

package/src/zexus/lsp/symbol_provider.py

@@ -1,6 +1,7 @@
-"""Symbol provider for Zexus LSP."""
+"""Symbol provider for Zexus LSP — document outline and symbol search."""
+
+from typing import List, Dict, Any, Optional
 
-from typing import List, Dict, Any
 try:
     from pygls.lsp.types import (DocumentSymbol, SymbolKind, Range, Position)
     PYGLS_AVAILABLE = True
@@ -8,7 +9,169 @@ except ImportError:
     PYGLS_AVAILABLE = False
     # Define minimal stubs when pygls not available
     class SymbolKind:
-        pass
+        Function = 12
+        Variable = 13
+        Constant = 14
+        Class = 5
+        Struct = 23
+        Enum = 10
+        Interface = 11
+        Module = 2
+        Package = 4
+        TypeParameter = 26
+
+
+# Map AST node type name → (SymbolKind, detail label)
+_SYMBOL_MAP = {
+    'ActionStatement':       (SymbolKind.Function,      'action'),
+    'FunctionStatement':     (SymbolKind.Function,      'function'),
+    'PureFunctionStatement': (SymbolKind.Function,      'pure function'),
+    'LetStatement':          (SymbolKind.Variable,      'let'),
+    'ConstStatement':        (SymbolKind.Constant,      'const'),
+    'EntityStatement':       (SymbolKind.Class,         'entity'),
+    'ContractStatement':     (SymbolKind.Class,         'contract'),
+    'DataStatement':         (SymbolKind.Struct,        'data'),
+    'EnumStatement':         (SymbolKind.Enum,          'enum'),
+    'InterfaceStatement':    (SymbolKind.Interface,     'interface'),
+    'ProtocolStatement':     (SymbolKind.Interface,     'protocol'),
+    'TypeAliasStatement':    (SymbolKind.TypeParameter, 'type'),
+    'ModuleStatement':       (SymbolKind.Module,        'module'),
+    'PackageStatement':      (SymbolKind.Package,       'package'),
+    'ScreenStatement':       (SymbolKind.Function,      'screen'),
+    'ComponentStatement':    (SymbolKind.Function,      'component'),
+    'MiddlewareStatement':   (SymbolKind.Function,      'middleware'),
+    'PatternStatement':      (SymbolKind.Function,      'pattern'),
+    'StreamStatement':       (SymbolKind.Variable,      'stream'),
+    'ModifierDeclaration':   (SymbolKind.Function,      'modifier'),
+}
+
+
+def _get_name(node) -> Optional[str]:
+    """Extract the string name from an AST definition node."""
+    name = getattr(node, 'name', None)
+    if name is None:
+        return None
+    if hasattr(name, 'value'):
+        return str(name.value)
+    return str(name)
+
+
+def _find_name_line(tokens, name: str, start_line: int = 0) -> int:
+    """Return the 0-based line number where ``name`` appears as an IDENT
+    in the token stream, starting from ``start_line``.  Returns
+    ``start_line`` if not found.
+    """
+    for tok in tokens:
+        ttype = getattr(tok, 'type', '')
+        lit = getattr(tok, 'literal', '')
+        line = getattr(tok, 'line', 0)
+        if ttype == 'IDENT' and lit == name and (line - 1) >= start_line:
+            return max(0, line - 1)
+    return start_line
+
+
+def _make_range(line: int, col: int = 0, end_line: Optional[int] = None, length: int = 1):
+    """Build a pygls Range.  Lines/cols are 0-based."""
+    if end_line is None:
+        end_line = line
+    return Range(
+        start=Position(line=line, character=col),
+        end=Position(line=end_line, character=col + length),
+    )
+
+
+def _node_to_symbol(node, tokens, text_lines) -> Optional[DocumentSymbol]:
+    """Convert an AST definition node into a ``DocumentSymbol``.
+
+    Returns ``None`` if the node does not map to a symbol.
+    """
+    if not PYGLS_AVAILABLE:
+        return None
+
+    node_type = type(node).__name__
+    entry = _SYMBOL_MAP.get(node_type)
+    if entry is None:
+        return None
+
+    kind, detail = entry
+    name = _get_name(node)
+    if not name:
+        return None
+
+    # Locate the name in the token stream
+    line = _find_name_line(tokens, name)
+    symbol_range = _make_range(line, length=len(name))
+    selection_range = symbol_range
+
+    # Build children for container types (entity, contract, enum, data)
+    children = []
+
+    if node_type == 'EntityStatement':
+        # Properties
+        for prop in (getattr(node, 'properties', None) or []):
+            prop_name = _get_name(prop)
+            if prop_name:
+                pline = _find_name_line(tokens, prop_name, line)
+                children.append(DocumentSymbol(
+                    name=prop_name,
+                    kind=SymbolKind.Variable,
+                    range=_make_range(pline, length=len(prop_name)),
+                    selection_range=_make_range(pline, length=len(prop_name)),
+                    detail='property',
+                ))
+        # Methods
+        for method in (getattr(node, 'methods', None) or []):
+            child_sym = _node_to_symbol(method, tokens, text_lines)
+            if child_sym:
+                children.append(child_sym)
+
+    elif node_type == 'ContractStatement':
+        body = getattr(node, 'body', None)
+        stmts = getattr(body, 'statements', None) if body else None
+        if isinstance(stmts, list):
+            for stmt in stmts:
+                child_sym = _node_to_symbol(stmt, tokens, text_lines)
+                if child_sym:
+                    children.append(child_sym)
+
+    elif node_type == 'EnumStatement':
+        for member in (getattr(node, 'members', None) or []):
+            m_name = _get_name(member) or getattr(member, 'value', None)
+            if isinstance(m_name, str):
+                pass
+            elif hasattr(m_name, 'value'):
+                m_name = m_name.value
+            if m_name:
+                mline = _find_name_line(tokens, str(m_name), line)
+                children.append(DocumentSymbol(
+                    name=str(m_name),
+                    kind=SymbolKind.Constant,
+                    range=_make_range(mline, length=len(str(m_name))),
+                    selection_range=_make_range(mline, length=len(str(m_name))),
+                    detail='member',
+                ))
+
+    elif node_type == 'DataStatement':
+        for field in (getattr(node, 'fields', None) or []):
+            f_name = _get_name(field)
+            if f_name:
+                fline = _find_name_line(tokens, f_name, line)
+                children.append(DocumentSymbol(
+                    name=f_name,
+                    kind=SymbolKind.Variable,
+                    range=_make_range(fline, length=len(f_name)),
+                    selection_range=_make_range(fline, length=len(f_name)),
+                    detail='field',
+                ))
+
+    return DocumentSymbol(
+        name=name,
+        kind=kind,
+        range=symbol_range,
+        selection_range=selection_range,
+        detail=detail,
+        children=children if children else None,
+    )
 
 
 class SymbolProvider:
@@ -18,14 +181,24 @@ class SymbolProvider:
         """Get document symbols from AST."""
         if not PYGLS_AVAILABLE:
             return []
-        
+
         symbols = []
         ast = doc_info.get('ast')
-        
+        tokens = doc_info.get('tokens', [])
+        text = doc_info.get('text', '')
+        text_lines = text.split('\n') if text else []
+
         if not ast:
             return symbols
-        
-        # TODO: Walk AST and extract symbols
-        # For now, return empty list
-        
+
+        # Walk top-level statements
+        stmts = getattr(ast, 'statements', [])
+        if not isinstance(stmts, list):
+            return symbols
+
+        for stmt in stmts:
+            sym = _node_to_symbol(stmt, tokens, text_lines)
+            if sym:
+                symbols.append(sym)
+
         return symbols