wafer-lsp 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

wafer_lsp/services/hip_hover_service.py

@@ -0,0 +1,412 @@
+"""
+HIP Hover Service.
+
+Provides rich hover documentation for HIP code including:
+- HIP API functions (hipMalloc, hipMemcpy, etc.)
+- Memory qualifiers (__device__, __shared__, __constant__)
+- Wavefront intrinsics (__shfl, __ballot, etc.)
+- Thread indexing (threadIdx, blockIdx, etc.)
+- Kernel function information
+"""
+
+from lsprotocol.types import Hover, MarkupContent, MarkupKind, Position
+
+from ..parsers.hip_parser import (
+    HIPKernel,
+    HIPDeviceFunction,
+    SharedMemoryAllocation,
+    KernelLaunchSite,
+    HIPParser,
+)
+from .hip_docs import (
+    HIPDocsService,
+    HIPAPIDoc,
+    MemoryQualifierDoc,
+    IntrinsicDoc,
+    ThreadIndexDoc,
+    create_hip_docs_service,
+)
+
+
+class HIPHoverService:
+    """Provides hover documentation for HIP code."""
+
+    def __init__(self, docs_service: HIPDocsService | None = None):
+        self._docs = docs_service or create_hip_docs_service()
+        self._parser = HIPParser()
+
+    def get_hover(self, content: str, position: Position, uri: str) -> Hover | None:
+        """Get hover information for a position in HIP code.
+        
+        Args:
+            content: The document content
+            position: The cursor position
+            uri: The document URI
+            
+        Returns:
+            Hover information or None
+        """
+        word = self._get_word_at_position(content, position)
+        if not word:
+            return None
+
+        # Try different types of hover in order of specificity
+        
+        # 1. Check for HIP API functions
+        api_doc = self._docs.get_api_doc(word)
+        if api_doc:
+            return self._format_api_hover(api_doc)
+
+        # 2. Check for memory qualifiers (including in context)
+        qualifier_doc = self._docs.get_memory_qualifier_doc(word)
+        if qualifier_doc:
+            return self._format_qualifier_hover(qualifier_doc)
+
+        # 3. Check for intrinsics
+        intrinsic_doc = self._docs.get_intrinsic_doc(word)
+        if intrinsic_doc:
+            return self._format_intrinsic_hover(intrinsic_doc)
+
+        # 4. Check for thread indexing variables
+        thread_doc = self._docs.get_thread_index_doc(word)
+        if thread_doc:
+            return self._format_thread_index_hover(thread_doc)
+
+        # 5. Check for kernels/device functions in the file
+        parsed = self._parser.parse_file(content)
+        
+        for kernel in parsed.get("kernels", []):
+            if kernel.name == word:
+                return self._format_kernel_hover(kernel)
+
+        for device_func in parsed.get("device_functions", []):
+            if device_func.name == word:
+                return self._format_device_function_hover(device_func)
+
+        # 6. Check for shared memory variables
+        for shared_var in parsed.get("shared_memory", []):
+            if shared_var.name == word:
+                return self._format_shared_memory_hover(shared_var)
+
+        # 7. Check for kernel launch (when hovering on kernel name at launch site)
+        for launch in parsed.get("launch_sites", []):
+            if launch.kernel_name == word and position.line == launch.line:
+                return self._format_launch_site_hover(launch)
+
+        return None
+
+    def _get_word_at_position(self, content: str, position: Position) -> str:
+        """Extract the word at the given position."""
+        lines = content.split("\n")
+        if position.line >= len(lines):
+            return ""
+
+        line = lines[position.line]
+        if position.character >= len(line):
+            return ""
+
+        # Find word boundaries (include underscores for __global__ etc.)
+        start = position.character
+        while start > 0 and (line[start - 1].isalnum() or line[start - 1] == "_"):
+            start -= 1
+
+        end = position.character
+        while end < len(line) and (line[end].isalnum() or line[end] == "_"):
+            end += 1
+
+        return line[start:end]
+
+    def _format_api_hover(self, doc: HIPAPIDoc) -> Hover:
+        """Format hover content for a HIP API function."""
+        lines = [
+            f"### `{doc.name}`",
+            "",
+            f"```cpp",
+            doc.signature,
+            "```",
+            "",
+            doc.description,
+            "",
+        ]
+
+        if doc.parameters:
+            lines.append("**Parameters:**")
+            for param_name, param_desc in doc.parameters:
+                lines.append(f"- `{param_name}`: {param_desc}")
+            lines.append("")
+
+        lines.append(f"**Returns:** {doc.return_value}")
+        lines.append("")
+
+        if doc.amd_notes:
+            lines.append("**AMD Notes:**")
+            lines.append(f"> {doc.amd_notes}")
+            lines.append("")
+
+        if doc.example:
+            lines.append("**Example:**")
+            lines.append("```cpp")
+            lines.extend(doc.example.replace("\\n", "\n").split("\n"))
+            lines.append("```")
+            lines.append("")
+
+        if doc.related:
+            lines.append(f"**Related:** {', '.join(f'`{r}`' for r in doc.related)}")
+
+        if doc.doc_url:
+            lines.append("")
+            lines.append(f"[📖 Documentation]({doc.doc_url})")
+
+        return Hover(contents=MarkupContent(
+            kind=MarkupKind.Markdown,
+            value="\n".join(lines)
+        ))
+
+    def _format_qualifier_hover(self, doc: MemoryQualifierDoc) -> Hover:
+        """Format hover content for a memory qualifier."""
+        lines = [
+            f"### `{doc.name}`",
+            "",
+            doc.description,
+            "",
+            "**AMD Architecture:**",
+            doc.amd_details,
+            "",
+            "**Performance Tips:**",
+            doc.performance_tips,
+        ]
+
+        if doc.example:
+            lines.append("")
+            lines.append("**Example:**")
+            lines.append("```cpp")
+            lines.extend(doc.example.split("\n"))
+            lines.append("```")
+
+        return Hover(contents=MarkupContent(
+            kind=MarkupKind.Markdown,
+            value="\n".join(lines)
+        ))
+
+    def _format_intrinsic_hover(self, doc: IntrinsicDoc) -> Hover:
+        """Format hover content for a wavefront intrinsic."""
+        lines = [
+            f"### `{doc.name}`",
+            "",
+            f"```cpp",
+            doc.signature,
+            "```",
+            "",
+            doc.description,
+            "",
+            "**⚠️ AMD Wavefront Behavior:**",
+            f"> {doc.amd_behavior}",
+            "",
+        ]
+
+        if doc.parameters:
+            lines.append("**Parameters:**")
+            for param_name, param_desc in doc.parameters:
+                lines.append(f"- `{param_name}`: {param_desc}")
+            lines.append("")
+
+        lines.append(f"**Returns:** {doc.return_value}")
+        lines.append("")
+
+        if doc.example:
+            lines.append("**Example:**")
+            lines.append("```cpp")
+            lines.extend(doc.example.replace("\\n", "\n").split("\n"))
+            lines.append("```")
+            lines.append("")
+
+        if doc.cuda_equivalent:
+            lines.append(f"**CUDA Equivalent:** `{doc.cuda_equivalent}`")
+
+        return Hover(contents=MarkupContent(
+            kind=MarkupKind.Markdown,
+            value="\n".join(lines)
+        ))
+
+    def _format_thread_index_hover(self, doc: ThreadIndexDoc) -> Hover:
+        """Format hover content for thread indexing variables."""
+        lines = [
+            f"### `{doc.name}`",
+            "",
+            doc.description,
+            "",
+            "**AMD Context:**",
+            f"> {doc.amd_context}",
+            "",
+        ]
+
+        if doc.common_patterns:
+            lines.append("**Common Patterns:**")
+            lines.append("```cpp")
+            for pattern in doc.common_patterns:
+                lines.append(pattern)
+            lines.append("```")
+
+        return Hover(contents=MarkupContent(
+            kind=MarkupKind.Markdown,
+            value="\n".join(lines)
+        ))
+
+    def _format_kernel_hover(self, kernel: HIPKernel) -> Hover:
+        """Format hover content for a kernel function."""
+        lines = [
+            f"### 🚀 HIP Kernel: `{kernel.name}`",
+            "",
+        ]
+
+        if kernel.docstring:
+            lines.append(kernel.docstring)
+            lines.append("")
+
+        # Build signature
+        params_str = ", ".join(kernel.parameters) if kernel.parameters else ""
+        lines.append("```cpp")
+        if kernel.attributes:
+            for attr in kernel.attributes:
+                lines.append(attr)
+        lines.append(f"__global__ void {kernel.name}({params_str})")
+        lines.append("```")
+        lines.append("")
+
+        if kernel.parameter_info:
+            lines.append("**Parameters:**")
+            for param in kernel.parameter_info:
+                type_info = f" (`{param.type_str}`)" if param.type_str else ""
+                lines.append(f"- `{param.name}`{type_info}")
+            lines.append("")
+
+        lines.append(f"**Location:** Lines {kernel.line + 1} - {kernel.end_line + 1}")
+        lines.append("")
+        lines.append("**AMD GPU Execution:**")
+        lines.append("- Executed on GPU Compute Units")
+        lines.append("- Threads grouped into 64-thread wavefronts (CDNA)")
+        lines.append("- Use `<<<grid, block>>>` or `hipLaunchKernelGGL` to launch")
+
+        return Hover(contents=MarkupContent(
+            kind=MarkupKind.Markdown,
+            value="\n".join(lines)
+        ))
+
+    def _format_device_function_hover(self, func: HIPDeviceFunction) -> Hover:
+        """Format hover content for a device function."""
+        lines = [
+            f"### ⚡ Device Function: `{func.name}`",
+            "",
+        ]
+
+        # Build signature
+        params_str = ", ".join(func.parameters) if func.parameters else ""
+        inline_str = "__forceinline__ " if func.is_inline else ""
+        lines.append("```cpp")
+        lines.append(f"__device__ {inline_str}{func.return_type} {func.name}({params_str})")
+        lines.append("```")
+        lines.append("")
+
+        if func.parameter_info:
+            lines.append("**Parameters:**")
+            for param in func.parameter_info:
+                type_info = f" (`{param.type_str}`)" if param.type_str else ""
+                lines.append(f"- `{param.name}`{type_info}")
+            lines.append("")
+
+        lines.append(f"**Returns:** `{func.return_type}`")
+        lines.append("")
+        lines.append(f"**Location:** Lines {func.line + 1} - {func.end_line + 1}")
+        lines.append("")
+        lines.append("**Note:** Device functions can only be called from kernel or other device functions.")
+
+        return Hover(contents=MarkupContent(
+            kind=MarkupKind.Markdown,
+            value="\n".join(lines)
+        ))
+
+    def _format_shared_memory_hover(self, shared: SharedMemoryAllocation) -> Hover:
+        """Format hover content for a shared memory allocation."""
+        lines = [
+            f"### 📦 Shared Memory (LDS): `{shared.name}`",
+            "",
+            f"**Type:** `{shared.type_str}`",
+        ]
+
+        if shared.array_size:
+            lines.append(f"**Array Size:** `[{shared.array_size}]`")
+
+        if shared.size_bytes:
+            if shared.size_bytes >= 1024:
+                size_str = f"{shared.size_bytes / 1024:.1f} KB"
+            else:
+                size_str = f"{shared.size_bytes} bytes"
+            lines.append(f"**Size:** {size_str}")
+
+        if shared.is_dynamic:
+            lines.append("**Allocation:** Dynamic (extern)")
+        else:
+            lines.append("**Allocation:** Static")
+
+        lines.append("")
+        lines.append("**AMD LDS Details:**")
+        lines.append("- On-chip memory with ~100x lower latency than HBM")
+        lines.append("- 64 KB per Compute Unit")
+        lines.append("- Shared by all threads in the block")
+        lines.append("- 32 banks of 4 bytes each")
+        lines.append("")
+        lines.append("💡 **Tip:** Avoid bank conflicts by using padding: `[SIZE + 1]`")
+
+        return Hover(contents=MarkupContent(
+            kind=MarkupKind.Markdown,
+            value="\n".join(lines)
+        ))
+
+    def _format_launch_site_hover(self, launch: KernelLaunchSite) -> Hover:
+        """Format hover content for a kernel launch site."""
+        lines = [
+            f"### 🎯 Kernel Launch: `{launch.kernel_name}`",
+            "",
+        ]
+
+        if launch.is_hip_launch_kernel_ggl:
+            lines.append("**Launch Method:** `hipLaunchKernelGGL`")
+        else:
+            lines.append("**Launch Method:** `<<<>>>` syntax")
+
+        lines.append("")
+
+        if launch.grid_dim:
+            lines.append(f"**Grid Dimensions:** `{launch.grid_dim}`")
+        if launch.block_dim:
+            lines.append(f"**Block Dimensions:** `{launch.block_dim}`")
+            # Try to parse block dimensions for wavefront info
+            self._add_wavefront_info(lines, launch.block_dim)
+
+        if launch.shared_mem_bytes:
+            lines.append(f"**Dynamic Shared Memory:** `{launch.shared_mem_bytes}`")
+        if launch.stream:
+            lines.append(f"**Stream:** `{launch.stream}`")
+
+        return Hover(contents=MarkupContent(
+            kind=MarkupKind.Markdown,
+            value="\n".join(lines)
+        ))
+
+    def _add_wavefront_info(self, lines: list[str], block_dim: str) -> None:
+        """Add wavefront information based on block dimensions.
+        
+        Only adds info when block_dim is a simple numeric literal we can parse.
+        For complex expressions (variables, dim3, etc.), we don't display wavefront count
+        because we can't determine the value at parse time.
+        """
+        # Only handle simple numeric block size - we don't guess at complex expressions
+        if block_dim.isdigit():
+            block_size = int(block_dim)
+            wavefronts = (block_size + 63) // 64
+            lines.append(f"**Wavefronts per Block:** {wavefronts} (64 threads each on CDNA)")
+
+
+def create_hip_hover_service(docs_service: HIPDocsService | None = None) -> HIPHoverService:
+    """Create a HIP hover service instance."""
+    return HIPHoverService(docs_service)

{wafer_lsp-0.1.0.dist-info → wafer_lsp-0.1.2.dist-info}/METADATA

@@ -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.0.dist-info → wafer_lsp-0.1.2.dist-info}/RECORD

@@ -4,37 +4,41 @@ wafer_lsp/server.py,sha256=ZGFXghuPdKJH7aLhrYvOiKp6zfOdtoqWavdtDwg8Bk4,1938
 wafer_lsp/analyzers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wafer_lsp/analyzers/compiler_integration.py,sha256=SLyIZXk52nKP1b04s9Wo77cRLFn5auc4jGRo59Vl9Wc,341
 wafer_lsp/analyzers/docs_index.py,sha256=hrrBgPzIM_mJewCzHyw-2YEWdIchuB3SAMXI8PhtDq0,1309
-wafer_lsp/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wafer_lsp/handlers/__init__.py,sha256=tPFuceRrlCkyW7N5BSRZJY7IMx9Etb6D5c54pZZHJ-w,926
 wafer_lsp/handlers/code_action.py,sha256=PTWs4X3CkfprMmzqC3cg7uEWdfivNNH9thU4E-c6ztQ,1411
 wafer_lsp/handlers/code_lens.py,sha256=mhdJtbS2LMNHGOirJbXUfatqhqMBess5wndfBBOLnok,1301
 wafer_lsp/handlers/completion.py,sha256=qz36GIJXu2fG6K-FdbFNGCCTYSpyV5A6-WOHHNne7QI,142
-wafer_lsp/handlers/diagnostics.py,sha256=gapTVWObW9xwqLkZbjEn4dhuvaqduD9ozNZDEALnumM,378
-wafer_lsp/handlers/document_symbol.py,sha256=u-SUAjZgLVEs3nkhBmd6icfAqIiqYP6TfDas3JHdiD0,3165
-wafer_lsp/handlers/hover.py,sha256=uTp190gvwOJyRVpJ0Y8VpP-8D5E5V67-GwzuVZ81dpU,7632
-wafer_lsp/handlers/inlay_hint.py,sha256=usPK7a6Z55tHGdd6LrHDO7RHL_UG0G1IGBSVrTF3nHo,1932
-wafer_lsp/handlers/semantic_tokens.py,sha256=w90P__qqCeCe1yDZkPNPHj_vxHVzcUylGmgYqPkfaWs,3427
+wafer_lsp/handlers/diagnostics.py,sha256=zSaBYdZCqBK2Nb2WhCyQfKDATf8nsj6jMv-K1lvxnQc,1137
+wafer_lsp/handlers/document_symbol.py,sha256=H9rehZlbJKZ-2ueyvTYvz0_-0xfiGaAEPXSWbp76JUk,6465
+wafer_lsp/handlers/hip_diagnostics.py,sha256=YFaSBuwBb7DJNWhBQpwVzYDJvA0KmMV5X9aEEk4X8eM,10923
+wafer_lsp/handlers/hover.py,sha256=F3vweiSHcFlF66qvneJkX02hTq3iaxfXK2h9EkufL7w,8788
+wafer_lsp/handlers/inlay_hint.py,sha256=HW-AFeWps2VbEGPMTAG9KHyiT1s2JS81F71BXq7rwoA,7765
+wafer_lsp/handlers/semantic_tokens.py,sha256=JNJetP7Flh6yxNFzkGM3Ho9D4HaHsVSmoXdgcJnJtZM,7447
 wafer_lsp/handlers/workspace_symbol.py,sha256=YGSkf6doChh1BjVezEQFgIsI2NsQHhOjLchoF5bfBK4,2934
 wafer_lsp/languages/README.md,sha256=hLBqOBvKSqeCrNH9Wrr6XAHa8eBnd81IargPDurodU8,5527
 wafer_lsp/languages/__init__.py,sha256=5cXQkPRsh4JLyZd2QubvTxvuip10695Hb2zjyGF6Frc,472
 wafer_lsp/languages/converter.py,sha256=LPKJfkUV-rNXyJg7Tr5AZ1AlREKH4ulfjDHWlUNvyXU,2487
-wafer_lsp/languages/detector.py,sha256=B2YrRN3KaSwcTM5UHMQkamRaqcQgySXYbHD71cN2bP8,1109
+wafer_lsp/languages/detector.py,sha256=7FDQZlnfnkI7DCeySzecIarYnNLINlIRgRkCj7L3SQY,4235
 wafer_lsp/languages/parser_manager.py,sha256=RBYS0w2wIRkKlrEDYvMEGKbsTkOSEpfUB3fjH_9X0Hk,945
-wafer_lsp/languages/registry.py,sha256=g8WuTIuwsssHTqM-t3QLsLsUqL0zFUGq3qnBbVxX6sY,2869
+wafer_lsp/languages/registry.py,sha256=Ka9WDURUniqUAZDpdrQtRTLLzS36n4hq2dIwqj_AFdc,3703
 wafer_lsp/languages/types.py,sha256=c22sDECraXHvazqJSF7WC1ntFNyf9Mbx60EXA9jrbWk,624
-wafer_lsp/parsers/__init__.py,sha256=7DUHQE1aA14zXF_3piSqVGr9wBSmDDa7PHtmHzhGkXs,345
+wafer_lsp/parsers/__init__.py,sha256=yh41cxz8Siuv0doHXnhuSY-JPoN82XtqDiOrbJAGeEg,709
 wafer_lsp/parsers/base_parser.py,sha256=RQjk5QOHrS398CrUGP2ZtSsisSl6Kh0KgWLPssSv8ss,176
 wafer_lsp/parsers/cuda_parser.py,sha256=X2EX8gFcZCK8-lSsedby1-vSgYsl2CHLxRxzwr5yIlI,2621
 wafer_lsp/parsers/cutedsl_parser.py,sha256=1r2gdAuwFrp4fQQNEQCRpkwtfunus-hq4h92j2MZyFE,3711
-wafer_lsp/services/__init__.py,sha256=ILqsbYVzyOUXZqAy1FBkyP860vrSoAhCBW3VpanTDio,773
+wafer_lsp/parsers/hip_parser.py,sha256=nJdwsyTWxdeRJkLMHzUC_4px2fWvtwxd5FgdqOvIXAU,26465
+wafer_lsp/services/__init__.py,sha256=lMMuCBSMfKQeTlUnSo82tXuMGN9rmeoTmCfUigZReL0,1191
 wafer_lsp/services/analysis_service.py,sha256=J6jcg0YQZh9iQYyOXO9bF5NqaJDfnIKhwssCLNcUJjA,619
 wafer_lsp/services/docs_service.py,sha256=ltjkPuQ4DUmuc95AZVfQ6GSWgpjKqv_6-Luh2CFPocQ,1393
 wafer_lsp/services/document_service.py,sha256=gdQ-leIUSK7tiffFsi4UsseIyBx2TO_WIlBPFh57GU8,559
+wafer_lsp/services/hip_docs.py,sha256=mmbFy89Jpj3KUXLO_0M73f0zrkiIw6omtqwCva0Y7Jw,40442
+wafer_lsp/services/hip_hover_service.py,sha256=zbnjdsU6jlCIJh38EDM0sGnLr8I7VKbLABaULJxcXwE,14112
 wafer_lsp/services/hover_service.py,sha256=Zby2lhMO4US2IVTAVuU-ntkRKWrrR7HEjWdlGFSRQj4,9743
 wafer_lsp/services/language_registry_service.py,sha256=qvMR9oI1pUrSv09Q-WRF5-sEu2Nma2fZeUhdydIWaqg,864
 wafer_lsp/services/position_service.py,sha256=Nx-_AuBEr_yUXjAYPfJ_wmeGM_Gy5vbIUW163GqblCU,2831
 wafer_lsp/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wafer_lsp/utils/lsp_helpers.py,sha256=pXYvm_gJiJ_TAwwyGxhqvWJQx6CBecYK1c6tVY7gUF8,2739
-wafer_lsp-0.1.0.dist-info/METADATA,sha256=gLx1YqnfAhI55s3EeaIMXb_Jm8xJoD1vBHXHcCDSv0A,1622
-wafer_lsp-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-wafer_lsp-0.1.0.dist-info/entry_points.txt,sha256=XHcM0QZy6GzCYY2ajejqL0tZ2X6y6zYWP0Lg1egxGW4,54
-wafer_lsp-0.1.0.dist-info/RECORD,,
+wafer_lsp-0.1.2.dist-info/METADATA,sha256=nGBlPcHE---A85ZbfH8lH9efnWr_noq9FSs9TL3OYXo,1741
+wafer_lsp-0.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+wafer_lsp-0.1.2.dist-info/entry_points.txt,sha256=XHcM0QZy6GzCYY2ajejqL0tZ2X6y6zYWP0Lg1egxGW4,54
+wafer_lsp-0.1.2.dist-info/RECORD,,