feat(aegis-server): use aegis-core for semantics

Author: TheNuclearNexus

aegis-core/aegis_core/ast/features/__init__.py

@@ -1,22 +1,41 @@
 from dataclasses import dataclass, field
 
 from beet import Context
-from bolt import AstAttribute, AstIdentifier, AstImportedItem, AstTargetAttribute, AstTargetIdentifier
-from mecha import AstNode, AstResourceLocation
+from bolt import (
+    AstAttribute,
+    AstClassName,
+    AstFormatString,
+    AstFunctionSignature,
+    AstFunctionSignatureArgument,
+    AstIdentifier,
+    AstImportedItem,
+    AstTargetAttribute,
+    AstTargetIdentifier,
+    AstValue,
+)
+from mecha import AstNode, AstResourceLocation, AstItemSlot
 
 from .provider import *
 from .resource_location import *
 from .variable import *
-
+from .generic import *
 
 def get_default_providers() -> dict[type[AstNode], type[BaseFeatureProvider]]:
     return {
+        # Bolt Specific
         AstIdentifier: VariableFeatureProvider,
         AstAttribute: VariableFeatureProvider,
         AstTargetAttribute: VariableFeatureProvider,
         AstTargetIdentifier: VariableFeatureProvider,
         AstImportedItem: VariableFeatureProvider,
+        AstClassName: ClassNameProvider,
+        AstFunctionSignature: FunctionSignatureProvider,
+        AstFunctionSignatureArgument: FunctionSignatureArgProvider,
+        AstValue: ValueProvider,
+        AstFormatString: FormatStringProvider,
+        # Mecha Specific
         AstResourceLocation: ResourceLocationFeatureProvider,
+        AstItemSlot: ItemSlotProvider,
     }
 
 

aegis-core/aegis_core/ast/features/generic.py

@@ -0,0 +1,137 @@
+import logging
+import re
+from types import NoneType
+from typing import ClassVar
+from aegis_core.ast.helpers import offset_location
+from aegis_core.ast.metadata import VariableMetadata, retrieve_metadata
+from aegis_core.semantics import TokenModifier, TokenType
+from bolt import (
+    AstClassName,
+    AstFormatString,
+    AstFunctionSignature,
+    AstFunctionSignatureArgument,
+    AstValue,
+)
+from mecha import AstNode
+from mecha.ast import AstItemSlot
+from tokenstream import SourceLocation
+from .provider import BaseFeatureProvider
+
+
+__all__ = [
+    "ItemSlotProvider",
+    "ClassNameProvider",
+    "FunctionSignatureProvider",
+    "FunctionSignatureArgProvider",
+    "ValueProvider",
+    "FormatStringProvider",
+]
+
+
+# --- Mecha ---
+class ItemSlotProvider(BaseFeatureProvider[AstItemSlot]):
+    @classmethod
+    def semantics(cls, params):
+        return [(params.node, "variable", ["readonly"])]
+
+
+# --- Bolt ---
+class ClassNameProvider(BaseFeatureProvider[AstClassName]):
+    @classmethod
+    def semantics(cls, params):
+        return [(params.node, "class", [])]
+
+
+class FunctionSignatureProvider(BaseFeatureProvider[AstFunctionSignature]):
+    @classmethod
+    def semantics(cls, params):
+        signature = params.node
+        location = signature.location
+        node = AstNode(
+            location=location,
+            end_location=offset_location(signature.location, len(signature.name)),
+        )
+
+        tokens = [(node, "function", [])]
+
+        if len(signature.arguments) >= 1:
+            first = signature.arguments[0]
+
+            if isinstance(first, AstFunctionSignatureArgument) and first.name == "self":
+                tokens.append((first, "macro", []))
+
+        return tokens
+
+
+class FunctionSignatureArgProvider(BaseFeatureProvider[AstFunctionSignatureArgument]):
+    @classmethod
+    def semantics(cls, params):
+        if params.node.type_annotation:
+            return [(params.node.type_annotation, "class", [])]
+
+        return None
+
+
+class ValueProvider(BaseFeatureProvider[AstValue]):
+    @classmethod
+    def semantics(cls, params):
+        value = params.node
+
+        metadata = retrieve_metadata(value, VariableMetadata)
+
+        if not metadata or not metadata.type_annotation:
+            return None
+
+        annotation = metadata.type_annotation
+
+        if annotation is NoneType:
+
+            return [(value, "variable", ["readonly"])]
+
+        elif annotation is bool:
+            return [(value, "macro", [])]
+
+        return None
+
+
+class FormatStringProvider(BaseFeatureProvider[AstFormatString]):
+    FORMAT_REGEX: ClassVar[re.Pattern] = re.compile(r"\{(:.+)?\}")
+
+    @classmethod
+    def semantics(cls, params):
+        format_string = params.node
+
+        formats = cls.FORMAT_REGEX.findall(format_string.fmt)
+
+        nodes: list[tuple[AstNode, TokenType, list[TokenModifier]]] = []
+
+        nodes.append(
+            (
+                AstNode(
+                    format_string.location, offset_location(format_string.location, 1)
+                ),
+                "macro",
+                [],
+            )
+        )
+
+        for format, value in zip(formats, format_string.values):
+            nodes.append(
+                (
+                    AstNode(offset_location(value.location, -1), value.location),
+                    "macro",
+                    [],
+                )
+            )
+            nodes.append(
+                (
+                    AstNode(
+                        value.end_location,
+                        offset_location(value.end_location, 1 + len(format)),
+                    ),
+                    "macro",
+                    [],
+                )
+            )
+
+        return nodes

aegis-core/aegis_core/ast/features/provider.py

@@ -25,6 +25,7 @@
 class BaseParams(Generic[Node]):
     ctx: Context
     node: Node
+    resource_location: str
 
 
 @dataclass
@@ -81,5 +82,5 @@ def rename(cls, params: RenameParams[Node]) -> lsp.WorkspaceEdit | None:
     @classmethod
     def semantics(
         cls, params: SemanticsParams[Node]
-    ) -> list[tuple[AstNode, TokenType, TokenModifier]] | None:
+    ) -> list[tuple[AstNode, TokenType, list[TokenModifier]]] | None:
         return None

aegis-core/aegis_core/ast/features/resource_location.py

@@ -212,3 +212,8 @@ def completion(cls, params):
             )
 
             return lsp.CompletionList(False, items)
+        
+    @classmethod
+    def semantics(cls, params):
+        return [(params.node, "function", [])]
+