wafer-lsp 0.1.0__tar.gz → 0.1.2__tar.gz

{wafer_lsp-0.1.0 → wafer_lsp-0.1.2}/.gitignore

@@ -40,6 +40,12 @@ experiments/emilio/cutedsl-quack-eval/eval_results/*.txt
 experiments/emilio/cutedsl-quack-eval/eval_results/*.json
 experiments/emilio/cutedsl-quack-eval/eval_results/*.py
 research/evals/kernelbench/results/
+research/evals/retrieval_eval_project/results/
+research/evals/trace_analyze_eval/results/
+research/evals/**/uv.lock
+
+# Large trace files
+**/pmc_perf.csv
 wafer_artifacts/
 **/wafer_artifacts/
 /.deps/
@@ -61,11 +67,14 @@ npm-debug.log*
 .npmrc
 
 # Yarn artifacts
-.yarn/install-state.gz
+**/.yarn/install-state.gz
 
 # NSYS report files (can be very large)
 *.nsys-rep
 
+# ROCprofiler artifacts
+.rocprofv3/
+
 # Turbo build cache
 .turbo/
 **/.turbo/
@@ -80,6 +89,30 @@ supabase/.temp/
 research/evals/kernelbench/kernelbench/results/
 research/evals/retrieval_eval_project/retrieval_eval/results/
 research/evals/retrieval_eval_project/*.log
+research/evals/ask_domain_eval/results/
+research/evals/optimize_performance_eval/results/
+research/evals/**/eval_output*.log
 
 # Wafer extension trace files
 .wafer/traces/
+
+# Test coverage
+coverage/
+**/coverage/
+.coverage
+*.coverage
+coverage.xml
+*.lcov
+htmlcov/
+experiments/steve/amd-model-practice/workloads/**/*.csv
+experiments/steve/amd-model-practice/liquid_profile.json
+
+# Local files
+logs/
+todo.md
+
+# Claude Code context/handoffs
+.claude/context/
+.claude/handoffs/
+KernelBench/
+HIP-Benchmarks-Results/

{wafer_lsp-0.1.0 → wafer_lsp-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wafer-lsp
-Version: 0.1.0
+Version: 0.1.2
 Summary: Language Server Protocol server for GPU programming languages
 Author-email: Wafer <support@wafer.ai>
 License: MIT
@@ -16,6 +16,9 @@ Requires-Python: >=3.12
 Requires-Dist: lsprotocol>=2024.0.0
 Requires-Dist: pygls>=1.0.0
 Requires-Dist: wafer-core
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # Wafer LSP

wafer_lsp-0.1.2/pyproject.toml

@@ -0,0 +1,73 @@
+[project]
+name = "wafer-lsp"
+version = "0.1.2"
+description = "Language Server Protocol server for GPU programming languages"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "pygls>=1.0.0",
+    "lsprotocol>=2024.0.0",
+    "wafer-core",  # For core analysis utilities
+]
+authors = [
+    { name = "Wafer", email = "support@wafer.ai" }
+]
+license = { text = "MIT" }
+keywords = ["lsp", "language-server", "gpu", "cuda", "cutedsl", "c++"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Text Editors :: Integrated Development Environments (IDE)",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project.scripts]
+wafer-lsp = "wafer_lsp.__main__:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/wafer_lsp"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+preview = true
+
+[tool.ruff.lint]
+select = [
+    "E",       # pycodestyle errors
+    "W",       # pycodestyle warnings
+    "F",       # pyflakes
+    "I",       # isort
+    "B",       # flake8-bugbear
+    "C4",      # flake8-comprehensions
+    "UP",      # pyupgrade
+    "ARG",     # flake8-unused-arguments
+    "SIM",     # flake8-simplify
+    "PLR",     # pylint refactor
+    "PLW",     # pylint warnings
+    "PT",      # flake8-pytest-style
+    "RUF",     # Ruff-specific rules
+]
+ignore = [
+    "E501",    # line too long (handled by formatter)
+    "B008",    # do not perform function calls in argument defaults
+    "PLR0913", # too many arguments
+    "PLR2004", # magic value used in comparison
+]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"

wafer_lsp-0.1.0/pyproject.toml → wafer_lsp-0.1.2/pyproject.toml.bak

@@ -7,7 +7,7 @@ requires-python = ">=3.12"
 dependencies = [
     "pygls>=1.0.0",
     "lsprotocol>=2024.0.0",
-    "wafer-core",  # For compiler analyzer
+    "wafer-core",  # For core analysis utilities
 ]
 authors = [
     { name = "Wafer", email = "support@wafer.ai" }
@@ -24,6 +24,12 @@ classifiers = [
     "Topic :: Text Editors :: Integrated Development Environments (IDE)",
 ]
 
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+]
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

wafer_lsp-0.1.2/src/wafer_lsp/handlers/__init__.py

@@ -0,0 +1,30 @@
+from .code_action import handle_code_action
+from .code_lens import handle_code_lens
+from .completion import handle_completion
+from .diagnostics import handle_diagnostics
+from .document_symbol import handle_document_symbol
+from .hip_diagnostics import (
+    HIPDiagnosticsProvider,
+    create_hip_diagnostics_provider,
+    get_hip_diagnostics,
+)
+from .hover import handle_hover
+from .inlay_hint import handle_inlay_hint
+from .semantic_tokens import handle_semantic_tokens, SEMANTIC_TOKENS_LEGEND
+from .workspace_symbol import handle_workspace_symbol
+
+__all__ = [
+    "handle_code_action",
+    "handle_code_lens",
+    "handle_completion",
+    "handle_diagnostics",
+    "handle_document_symbol",
+    "handle_hover",
+    "handle_inlay_hint",
+    "handle_semantic_tokens",
+    "handle_workspace_symbol",
+    "SEMANTIC_TOKENS_LEGEND",
+    "HIPDiagnosticsProvider",
+    "create_hip_diagnostics_provider",
+    "get_hip_diagnostics",
+]

wafer_lsp-0.1.2/src/wafer_lsp/handlers/diagnostics.py

@@ -0,0 +1,41 @@
+
+from lsprotocol.types import Diagnostic
+
+from ..languages.registry import get_language_registry
+from .hip_diagnostics import get_hip_diagnostics
+
+
+def handle_diagnostics(
+    uri: str,
+    content: str,
+    enable_wavefront_diagnostics: bool = True,
+) -> list[Diagnostic]:
+    """Handle diagnostics for a document.
+    
+    Args:
+        uri: Document URI
+        content: Document content
+        enable_wavefront_diagnostics: Whether to enable HIP wavefront warnings
+        
+    Returns:
+        List of diagnostics
+    """
+    diagnostics: list[Diagnostic] = []
+
+    registry = get_language_registry()
+    language_info = registry.parse_file(uri, content)
+
+    if not language_info:
+        return diagnostics
+
+    # Add HIP-specific diagnostics for HIP, CUDA, and C++ files
+    # (C++ files might contain HIP code if they have HIP markers)
+    if language_info.language in ("hip", "cuda", "cpp"):
+        hip_diagnostics = get_hip_diagnostics(
+            content,
+            uri,
+            enable_wavefront_diagnostics=enable_wavefront_diagnostics,
+        )
+        diagnostics.extend(hip_diagnostics)
+
+    return diagnostics

wafer_lsp-0.1.2/src/wafer_lsp/handlers/document_symbol.py

@@ -0,0 +1,176 @@
+
+from lsprotocol.types import DocumentSymbol, Position, Range, SymbolKind
+
+from ..languages.registry import get_language_registry
+
+
+def handle_document_symbol(uri: str, content: str) -> list[DocumentSymbol]:
+    registry = get_language_registry()
+    language_info = registry.parse_file(uri, content)
+
+    if not language_info:
+        return []
+
+    symbols: list[DocumentSymbol] = []
+    lines = content.split("\n")
+
+    # Kernels
+    for kernel in language_info.kernels:
+        kernel_line = lines[kernel.line] if kernel.line < len(lines) else ""
+        name_start = kernel_line.find(kernel.name)
+        name_end = name_start + len(kernel.name) if name_start >= 0 else 0
+
+        selection_range = Range(
+            start=Position(line=kernel.line, character=max(0, name_start)),
+            end=Position(line=kernel.line, character=name_end)
+        )
+        full_range = Range(
+            start=Position(line=kernel.line, character=0),
+            end=Position(line=min(kernel.line + 10, len(lines) - 1), character=0)
+        )
+
+        # Different detail based on language
+        if kernel.language == "hip":
+            detail = "🚀 HIP Kernel (AMD GPU)"
+        elif kernel.language in ("cuda", "cpp"):
+            detail = "🚀 CUDA Kernel"
+        else:
+            detail = f"GPU Kernel ({registry.get_language_name(kernel.language)})"
+
+        symbols.append(DocumentSymbol(
+            name=kernel.name,
+            kind=SymbolKind.Function,
+            range=full_range,
+            selection_range=selection_range,
+            detail=detail,
+        ))
+
+    # Layouts (CuTeDSL)
+    for layout in language_info.layouts:
+        layout_line = lines[layout.line] if layout.line < len(lines) else ""
+        name_start = layout_line.find(layout.name)
+        name_end = name_start + len(layout.name) if name_start >= 0 else 0
+
+        detail = f"Layout: {layout.shape}" if layout.shape else "Layout"
+
+        selection_range = Range(
+            start=Position(line=layout.line, character=max(0, name_start)),
+            end=Position(line=layout.line, character=name_end)
+        )
+        full_range = Range(
+            start=Position(line=layout.line, character=0),
+            end=Position(line=layout.line, character=len(layout_line))
+        )
+
+        symbols.append(DocumentSymbol(
+            name=layout.name,
+            kind=SymbolKind.Variable,
+            range=full_range,
+            selection_range=selection_range,
+            detail=detail,
+        ))
+
+    # Structs
+    for struct in language_info.structs:
+        struct_line = lines[struct.line] if struct.line < len(lines) else ""
+        name_start = struct_line.find(struct.name)
+        name_end = name_start + len(struct.name) if name_start >= 0 else 0
+
+        selection_range = Range(
+            start=Position(line=struct.line, character=max(0, name_start)),
+            end=Position(line=struct.line, character=name_end)
+        )
+        full_range = Range(
+            start=Position(line=struct.line, character=0),
+            end=Position(line=min(struct.line + 10, len(lines) - 1), character=0)
+        )
+
+        symbols.append(DocumentSymbol(
+            name=struct.name,
+            kind=SymbolKind.Struct,
+            range=full_range,
+            selection_range=selection_range,
+            detail=f"Struct ({registry.get_language_name(struct.language)})",
+        ))
+
+    # HIP-specific: Device functions and shared memory
+    if language_info.language in ("hip", "cuda", "cpp"):
+        symbols.extend(_get_hip_symbols(language_info.raw_data, lines))
+
+    return symbols
+
+
+def _get_hip_symbols(raw_data: dict, lines: list[str]) -> list[DocumentSymbol]:
+    """Extract HIP-specific symbols: device functions, shared memory allocations."""
+    symbols: list[DocumentSymbol] = []
+    
+    # Device functions (from HIP parser)
+    device_functions = raw_data.get("device_functions", [])
+    for func in device_functions:
+        if not hasattr(func, "line") or not hasattr(func, "name"):
+            continue
+            
+        func_line = lines[func.line] if func.line < len(lines) else ""
+        name_start = func_line.find(func.name)
+        name_end = name_start + len(func.name) if name_start >= 0 else 0
+        
+        end_line = getattr(func, "end_line", func.line + 10)
+        
+        selection_range = Range(
+            start=Position(line=func.line, character=max(0, name_start)),
+            end=Position(line=func.line, character=name_end)
+        )
+        full_range = Range(
+            start=Position(line=func.line, character=0),
+            end=Position(line=min(end_line, len(lines) - 1), character=0)
+        )
+        
+        return_type = getattr(func, "return_type", "void")
+        detail = f"⚡ Device Function -> {return_type}"
+        
+        symbols.append(DocumentSymbol(
+            name=func.name,
+            kind=SymbolKind.Method,
+            range=full_range,
+            selection_range=selection_range,
+            detail=detail,
+        ))
+    
+    # Shared memory allocations
+    shared_memory = raw_data.get("shared_memory", [])
+    for shared in shared_memory:
+        if not hasattr(shared, "line") or not hasattr(shared, "name"):
+            continue
+            
+        shared_line = lines[shared.line] if shared.line < len(lines) else ""
+        name_start = shared_line.find(shared.name)
+        name_end = name_start + len(shared.name) if name_start >= 0 else 0
+        
+        selection_range = Range(
+            start=Position(line=shared.line, character=max(0, name_start)),
+            end=Position(line=shared.line, character=name_end)
+        )
+        full_range = Range(
+            start=Position(line=shared.line, character=0),
+            end=Position(line=shared.line, character=len(shared_line))
+        )
+        
+        type_str = getattr(shared, "type_str", "")
+        size_bytes = getattr(shared, "size_bytes", None)
+        if size_bytes:
+            if size_bytes >= 1024:
+                detail = f"📦 __shared__ {type_str} ({size_bytes / 1024:.1f} KB)"
+            else:
+                detail = f"📦 __shared__ {type_str} ({size_bytes} bytes)"
+        else:
+            detail = f"📦 __shared__ {type_str}"
+        
+        symbols.append(DocumentSymbol(
+            name=shared.name,
+            kind=SymbolKind.Variable,
+            range=full_range,
+            selection_range=selection_range,
+            detail=detail,
+        ))
+    
+    return symbols