tile-lsp 0.1.0__tar.gz

tile_lsp-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: tile-lsp
+Version: 0.1.0
+Summary: Language server for the TileLang DSL
+Requires-Python: >=3.9
+Requires-Dist: pygls>=1.3.0
+Requires-Dist: lsprotocol>=2023.0.0

tile_lsp-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tile-lsp"
+version = "0.1.0"
+description = "Language server for the TileLang DSL"
+requires-python = ">=3.9"
+dependencies = [
+    "pygls>=1.3.0",
+    "lsprotocol>=2023.0.0",
+]
+
+[project.scripts]
+tiled = "tiled_server.__main__:main"
+
+[tool.setuptools.packages.find]
+include = ["tiled_server*"]

tile_lsp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tile_lsp-0.1.0/tests/test_completion.py

@@ -0,0 +1,95 @@
+"""Tests for TileLang completion logic."""
+
+import pytest
+from lsprotocol import types as lsp
+
+from tiled_server.completion import symbol_to_completion
+from tiled_server.knowledge import (
+    TileLangSymbol,
+    get_t_completions,
+    get_tilelang_completions,
+)
+
+
+class TestSymbolToCompletion:
+    def test_function_symbol(self):
+        sym = TileLangSymbol("gemm", "function", "T.gemm(A, B, C)", "Do gemm.")
+        item = symbol_to_completion(sym)
+        assert item.label == "gemm"
+        assert item.kind == lsp.CompletionItemKind.Function
+        assert item.detail == "T.gemm(A, B, C)"
+
+    def test_type_symbol(self):
+        sym = TileLangSymbol("Tensor", "type", "T.Tensor", "Tensor type.")
+        item = symbol_to_completion(sym)
+        assert item.kind == lsp.CompletionItemKind.Class
+
+    def test_constant_symbol(self):
+        sym = TileLangSymbol("float16", "constant", "T.float16", "float16 dtype.")
+        item = symbol_to_completion(sym)
+        assert item.kind == lsp.CompletionItemKind.Constant
+        assert item.sort_text.startswith("1_")
+
+    def test_function_sort_before_constant(self):
+        func = TileLangSymbol("gemm", "function", "T.gemm()", "gemm")
+        const = TileLangSymbol("float16", "constant", "T.float16", "f16")
+        func_item = symbol_to_completion(func)
+        const_item = symbol_to_completion(const)
+        assert func_item.sort_text < const_item.sort_text
+
+    def test_snippet_uses_snippet_format(self):
+        sym = TileLangSymbol("alloc_shared", "function", "T.alloc_shared()", "Alloc.",
+                            snippet="alloc_shared((${1:M}, ${2:N}), ${3:dtype})")
+        item = symbol_to_completion(sym)
+        assert item.insert_text_format == lsp.InsertTextFormat.Snippet
+        assert "${1:" in item.insert_text
+
+    def test_no_snippet_uses_plain_text(self):
+        sym = TileLangSymbol("clear", "function", "T.clear(buf)", "Clear.")
+        item = symbol_to_completion(sym)
+        assert item.insert_text_format == lsp.InsertTextFormat.PlainText
+        assert item.insert_text == "clear"
+
+    def test_documentation_is_markdown(self):
+        sym = TileLangSymbol("Kernel", "class", "T.Kernel()", "Launch a kernel.\n\n```python\n...\n```")
+        item = symbol_to_completion(sym)
+        assert item.documentation.kind == lsp.MarkupKind.Markdown
+
+
+class TestCompletionLogic:
+    """Test the completion filtering logic directly."""
+
+    def test_t_dot_returns_all_symbols(self):
+        syms = get_t_completions()
+        func_names = {s.name for s in syms if s.kind == "function"}
+        const_names = {s.name for s in syms if s.kind == "constant"}
+        assert "alloc_shared" in func_names
+        assert "float16" in const_names
+
+    def test_filter_by_prefix(self):
+        prefix = "alloc"
+        syms = [s for s in get_t_completions() if s.name.lower().startswith(prefix)]
+        names = {s.name for s in syms}
+        assert "alloc_shared" in names
+        assert "alloc_fragment" in names
+        assert "alloc_local" in names
+        assert "gemm" not in names
+
+    def test_filter_by_prefix_reduce(self):
+        prefix = "reduce"
+        syms = [s for s in get_t_completions() if s.name.lower().startswith(prefix)]
+        names = {s.name for s in syms}
+        assert "reduce_sum" in names
+        assert "reduce_max" in names
+        assert "reduce_min" in names
+        assert "alloc_shared" not in names
+
+    def test_tilelang_completions_have_jit(self):
+        syms = get_tilelang_completions()
+        names = {s.name for s in syms}
+        assert "jit" in names
+
+    def test_decorator_completions(self):
+        """@ trigger should offer T.prim_func and tilelang.jit."""
+        line = "    @"
+        assert line.rstrip().endswith("@")

tile_lsp-0.1.0/tests/test_detection.py

@@ -0,0 +1,79 @@
+"""Tests for TileLang file detection and regex patterns."""
+
+import pytest
+
+from tiled_server.detection import (
+    _RE_T_DOT,
+    _RE_TILELANG_DOT,
+    is_tilelang_file,
+)
+
+
+class TestFileDetection:
+    def test_import_as_t(self):
+        assert is_tilelang_file("import tilelang.language as T\n")
+
+    def test_import_tilelang(self):
+        assert is_tilelang_file("import tilelang\n")
+
+    def test_from_import(self):
+        assert is_tilelang_file("from tilelang.language import Kernel\n")
+
+    def test_mixed_imports(self):
+        assert is_tilelang_file("import numpy\nimport tilelang\nimport torch\n")
+
+    def test_not_tilelang_numpy(self):
+        assert not is_tilelang_file("import numpy as np\n")
+
+    def test_not_tilelang_plain(self):
+        assert not is_tilelang_file("print('hello')\n")
+
+    def test_not_tilelang_empty(self):
+        assert not is_tilelang_file("")
+
+    def test_not_tilelang_comment_only(self):
+        assert not is_tilelang_file("# import tilelang in comment\nprint(1)\n")
+
+    def test_import_tilelang_as_alias(self):
+        assert is_tilelang_file("import tilelang.language as TL\n")
+
+
+class TestRegexPatterns:
+    @pytest.mark.parametrize("line,expected_match", [
+        ("            T.", True),
+        ("    T.alloc", True),
+        ("T.Kernel", True),
+        ("T.", True),
+        ("x = T.floa", True),
+        ("print(T.", True),
+        ("S.", False),
+        ("no_dot_t", False),
+        ("", False),
+    ])
+    def test_t_dot_regex(self, line, expected_match):
+        m = _RE_T_DOT.search(line)
+        assert bool(m) == expected_match, f"line={line!r} expected={expected_match}"
+
+    @pytest.mark.parametrize("line,expected_match", [
+        ("tilelang.", True),
+        ("tilelang.jit", True),
+        ("    tilelang.comp", True),
+        ("x = tilelang.", True),
+        ("tilelan.", False),
+        ("", False),
+    ])
+    def test_tilelang_dot_regex(self, line, expected_match):
+        m = _RE_TILELANG_DOT.search(line)
+        assert bool(m) == expected_match
+
+    def test_t_dot_captures_prefix(self):
+        m = _RE_T_DOT.search("    T.alloc_sh")
+        assert m.group(1) == "alloc_sh"
+
+    def test_t_dot_empty_prefix(self):
+        m = _RE_T_DOT.search("    T.")
+        assert m.group(1) == ""
+
+    def test_tilelang_dot_captures_prefix(self):
+        m = _RE_TILELANG_DOT.search("    tilelang.ji")
+        assert m.group(1) == "ji"

tile_lsp-0.1.0/tests/test_diagnostics.py

@@ -0,0 +1,158 @@
+"""Tests for TileLang diagnostics."""
+
+import pytest
+from lsprotocol import types as lsp
+
+from tiled_server.diagnostics import compute_diagnostics
+from .conftest import GEMM_CODE, ELEMENTWISE_CODE, NON_TILELANG_CODE
+
+
+class TestDiagnostics:
+    def test_no_diagnostics_for_clean_gemm(self):
+        diags = compute_diagnostics("file:///test.py", GEMM_CODE)
+        gemm_warnings = [d for d in diags if "T.clear" in d.message]
+        assert len(gemm_warnings) == 0
+
+    def test_gemm_without_clear_warning(self):
+        code = """\
+import tilelang
+import tilelang.language as T
+
+@T.prim_func
+def gemm(A: T.Tensor((128, 128), T.float16)):
+    with T.Kernel(1, 1, threads=128) as (bx, by):
+        C_local = T.alloc_fragment((128, 128), T.float32)
+        T.gemm(A, A, C_local)
+"""
+        diags = compute_diagnostics("file:///test.py", code)
+        gemm_warnings = [d for d in diags if "T.clear" in d.message]
+        assert len(gemm_warnings) == 1
+        assert gemm_warnings[0].severity == lsp.DiagnosticSeverity.Information
+
+    def test_alloc_buffer_hint(self):
+        code = """\
+import tilelang
+import tilelang.language as T
+
+@T.prim_func
+def kernel():
+    buf = T.alloc_buffer((128, 128), T.float16)
+"""
+        diags = compute_diagnostics("file:///test.py", code)
+        hints = [d for d in diags if "T.alloc_buffer" in d.message]
+        assert len(hints) == 1
+        assert hints[0].severity == lsp.DiagnosticSeverity.Hint
+
+    def test_tensor_missing_dtype_warning(self):
+        code = """\
+import tilelang
+import tilelang.language as T
+
+@T.prim_func
+def kernel(A: T.Tensor((128, 128))):
+    pass
+"""
+        diags = compute_diagnostics("file:///test.py", code)
+        dtype_warnings = [d for d in diags if "dtype" in d.message.lower()]
+        assert len(dtype_warnings) == 1
+        assert dtype_warnings[0].severity == lsp.DiagnosticSeverity.Warning
+
+    def test_no_diagnostics_for_non_tilelang(self):
+        diags = compute_diagnostics("file:///test.py", NON_TILELANG_CODE)
+        assert diags == []
+
+    def test_no_diagnostics_for_correct_elementwise(self):
+        diags = compute_diagnostics("file:///test.py", ELEMENTWISE_CODE)
+        assert all("T.clear" not in d.message for d in diags)
+
+    def test_diagnostic_range_is_correct(self):
+        code = """\
+import tilelang.language as T
+
+@T.prim_func
+def kernel():
+    buf = T.alloc_buffer((4,), T.float32)
+"""
+        diags = compute_diagnostics("file:///test.py", code)
+        hints = [d for d in diags if "alloc_buffer" in d.message]
+        assert len(hints) == 1
+        d = hints[0]
+        assert d.range.start.line == 4
+        assert d.range.start.character == code.split("\n")[4].index("T.alloc_buffer")
+
+    def test_diagnostic_source_is_tiled(self):
+        code = """\
+import tilelang
+@T.prim_func
+def kernel():
+    buf = T.alloc_buffer((4,), T.float32)
+"""
+        diags = compute_diagnostics("file:///test.py", code)
+        for d in diags:
+            assert d.source == "tiled"
+
+    def test_multiple_gemm_no_clear(self):
+        code = """\
+import tilelang.language as T
+
+@T.prim_func
+def kernel():
+    with T.Kernel(1, 1, threads=128) as (bx, by):
+        A = T.alloc_shared((128, 128), T.float16)
+        C = T.alloc_fragment((128, 128), T.float32)
+        T.gemm(A, A, C)
+        T.gemm(A, A, C)
+"""
+        diags = compute_diagnostics("file:///test.py", code)
+        gemm_warnings = [d for d in diags if "T.clear" in d.message]
+        assert len(gemm_warnings) >= 1
+
+    def test_gemm_with_clear_no_warning(self):
+        code = """\
+import tilelang.language as T
+
+@T.prim_func
+def kernel():
+    with T.Kernel(1, 1, threads=128) as (bx, by):
+        A = T.alloc_shared((128, 128), T.float16)
+        C = T.alloc_fragment((128, 128), T.float32)
+        T.clear(C)
+        T.gemm(A, A, C)
+"""
+        diags = compute_diagnostics("file:///test.py", code)
+        gemm_warnings = [d for d in diags if "T.clear" in d.message]
+        assert len(gemm_warnings) == 0
+
+    def test_empty_source(self):
+        diags = compute_diagnostics("file:///test.py", "")
+        assert diags == []
+
+
+class TestEdgeCases:
+    def test_diagnostics_with_only_comments(self):
+        code = """\
+# import tilelang
+# This is just a comment file
+"""
+        diags = compute_diagnostics("file:///test.py", code)
+        assert diags == []
+
+    def test_large_file_no_crash(self):
+        lines = ["import tilelang.language as T\n"]
+        lines.extend(["x = 1\n"] * 10000)
+        code = "".join(lines)
+        diags = compute_diagnostics("file:///test.py", code)
+        assert isinstance(diags, list)
+
+    def test_unicode_in_source(self):
+        code = """\
+import tilelang.language as T
+# 矩阵乘法 — GEMM kernel
+"""
+        diags = compute_diagnostics("file:///test.py", code)
+        assert isinstance(diags, list)
+
+    def test_tab_indentation(self):
+        code = "import tilelang.language as T\n\t\tT.alloc_buffer((4,), T.float32)\n"
+        diags = compute_diagnostics("file:///test.py", code)
+        assert isinstance(diags, list)

tile_lsp-0.1.0/tests/test_hover.py

@@ -0,0 +1,51 @@
+"""Tests for TileLang hover and signature help logic."""
+
+import pytest
+
+from tiled_server.knowledge import lookup_symbol
+
+
+class TestHoverLogic:
+    """Test the hover lookup logic directly."""
+
+    def test_hover_t_symbol(self):
+        sym = lookup_symbol("alloc_shared")
+        assert sym is not None
+        assert "shared memory" in sym.documentation.lower()
+
+    def test_hover_gemm(self):
+        sym = lookup_symbol("gemm")
+        assert sym is not None
+        assert "matrix" in sym.documentation.lower() or "gemm" in sym.documentation.lower()
+
+    def test_hover_pipelined(self):
+        sym = lookup_symbol("Pipelined")
+        assert sym is not None
+        assert "pipeline" in sym.documentation.lower()
+
+    def test_hover_kernel(self):
+        sym = lookup_symbol("Kernel")
+        assert sym is not None
+        assert "kernel" in sym.documentation.lower() or "GPU" in sym.documentation
+
+    def test_hover_tilelang_jit(self):
+        sym = lookup_symbol("jit")
+        assert sym is not None
+        assert "JIT" in sym.documentation or "jit" in sym.documentation.lower()
+
+
+class TestSignatureLogic:
+    """Test that symbols have proper detail strings usable for signature help."""
+
+    @pytest.mark.parametrize("name,expected_fragment", [
+        ("alloc_shared", "shape"),
+        ("Kernel", "threads"),
+        ("Pipelined", "num_stages"),
+        ("Tensor", "shape"),
+        ("gemm", "A"),
+        ("copy", "src"),
+    ])
+    def test_detail_contains_params(self, name, expected_fragment):
+        sym = lookup_symbol(name)
+        assert sym is not None
+        assert expected_fragment in sym.detail

tile_lsp-0.1.0/tests/test_knowledge.py

@@ -0,0 +1,94 @@
+"""Tests for the TileLang knowledge base."""
+
+import pytest
+
+from tiled_server.knowledge import (
+    TileLangSymbol,
+    get_t_completions,
+    get_tilelang_completions,
+    get_snippets,
+    lookup_symbol,
+)
+
+
+class TestKnowledgeBase:
+    def test_t_completions_count(self):
+        syms = get_t_completions()
+        assert len(syms) > 50
+
+    def test_tilelang_completions_count(self):
+        syms = get_tilelang_completions()
+        assert len(syms) >= 3
+
+    @pytest.mark.parametrize("name", [
+        "Kernel", "alloc_shared", "alloc_fragment", "alloc_local",
+        "gemm", "copy", "async_copy", "clear", "fill",
+        "Pipelined", "Parallel", "Persistent", "serial", "unroll", "vectorized",
+        "Tensor", "Buffer", "SharedBuffer", "FragmentBuffer",
+        "ceildiv", "print", "device_assert",
+        "reduce_sum", "reduce_max", "reduce_min",
+        "atomic_add", "atomic_max", "atomic_min",
+        "use_swizzle", "reshape", "view",
+        "Layout", "Fragment", "GemmWarpPolicy",
+        "dynamic", "symbolic",
+    ])
+    def test_core_symbol_exists(self, name):
+        sym = lookup_symbol(name)
+        assert sym is not None, f"Missing symbol: {name}"
+
+    @pytest.mark.parametrize("name", [
+        "Kernel", "alloc_shared", "gemm", "copy", "Pipelined", "Parallel",
+    ])
+    def test_core_symbol_has_documentation(self, name):
+        sym = lookup_symbol(name)
+        assert sym.documentation, f"Empty docs for: {name}"
+        assert len(sym.documentation) > 10
+
+    @pytest.mark.parametrize("name", [
+        "Kernel", "alloc_shared", "alloc_fragment", "gemm", "Pipelined", "Parallel",
+        "ceildiv", "Tensor",
+    ])
+    def test_core_symbol_has_snippet(self, name):
+        sym = lookup_symbol(name)
+        assert sym.snippet is not None, f"No snippet for: {name}"
+
+    @pytest.mark.parametrize("dtype", [
+        "float16", "float32", "float64", "bfloat16",
+        "int8", "int16", "int32", "int64",
+        "uint8", "uint16", "uint32", "uint64",
+        "half", "float", "double",
+        "float8_e4m3fn", "float8_e5m2",
+    ])
+    def test_dtype_symbol_exists(self, dtype):
+        sym = lookup_symbol(dtype)
+        assert sym is not None, f"Missing dtype: {dtype}"
+        assert sym.kind == "constant"
+
+    @pytest.mark.parametrize("name", [
+        "jit", "compile", "autotune", "Profiler",
+    ])
+    def test_tilelang_top_level_symbol(self, name):
+        sym = lookup_symbol(name)
+        assert sym is not None, f"Missing tilelang.{name}"
+
+    def test_no_duplicate_symbols(self):
+        syms = get_t_completions()
+        names = [s.name for s in syms]
+        assert len(names) == len(set(names)), f"Duplicate symbols: {[n for n in names if names.count(n) > 1]}"
+
+    def test_symbol_kinds_valid(self):
+        for sym in get_t_completions():
+            assert sym.kind in ("function", "type", "constant", "decorator", "class"), \
+                f"Invalid kind '{sym.kind}' for {sym.name}"
+
+    def test_lookup_nonexistent_returns_none(self):
+        assert lookup_symbol("nonexistent_xyz") is None
+
+    def test_snippets_dict(self):
+        snips = get_snippets()
+        assert isinstance(snips, dict)
+        assert len(snips) >= 2
+        for key, val in snips.items():
+            assert "prefix" in val
+            assert "body" in val
+            assert "description" in val

tile_lsp-0.1.0/tests/test_server_creation.py

@@ -0,0 +1,13 @@
+"""Tests for server creation."""
+
+from tiled_server.server import create_server
+
+
+class TestServerCreation:
+    def test_server_name(self):
+        server = create_server()
+        assert server.name == "tiled"
+
+    def test_server_version(self):
+        server = create_server()
+        assert server.version == "v0.1.0"

tile_lsp-0.1.0/tile_lsp.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: tile-lsp
+Version: 0.1.0
+Summary: Language server for the TileLang DSL
+Requires-Python: >=3.9
+Requires-Dist: pygls>=1.3.0
+Requires-Dist: lsprotocol>=2023.0.0

tile_lsp-0.1.0/tile_lsp.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+pyproject.toml
+tests/test_completion.py
+tests/test_detection.py
+tests/test_diagnostics.py
+tests/test_hover.py
+tests/test_knowledge.py
+tests/test_server_creation.py
+tile_lsp.egg-info/PKG-INFO
+tile_lsp.egg-info/SOURCES.txt
+tile_lsp.egg-info/dependency_links.txt
+tile_lsp.egg-info/entry_points.txt
+tile_lsp.egg-info/requires.txt
+tile_lsp.egg-info/top_level.txt
+tiled_server/__init__.py
+tiled_server/__main__.py
+tiled_server/completion.py
+tiled_server/detection.py
+tiled_server/diagnostics.py
+tiled_server/hover.py
+tiled_server/knowledge.py
+tiled_server/server.py
+tiled_server/signature.py
+tiled_server/utils.py

tile_lsp-0.1.0/tile_lsp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tile_lsp-0.1.0/tile_lsp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tiled = tiled_server.__main__:main

tile_lsp-0.1.0/tile_lsp.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pygls>=1.3.0
+lsprotocol>=2023.0.0

tile_lsp-0.1.0/tile_lsp.egg-info/top_level.txt

@@ -0,0 +1 @@
+tiled_server

tile_lsp-0.1.0/tiled_server/__init__.py

@@ -0,0 +1 @@
+"""tiled — Language server for the TileLang DSL."""

tile_lsp-0.1.0/tiled_server/__main__.py

@@ -0,0 +1,28 @@
+"""Entry point for the tiled language server."""
+
+import argparse
+import logging
+
+from .server import create_server
+
+
+def main():
+    parser = argparse.ArgumentParser(description="tiled — TileLang Language Server")
+    parser.add_argument("--tcp", action="store_true", help="Use TCP transport")
+    parser.add_argument("--host", default="127.0.0.1", help="TCP host (default: 127.0.0.1)")
+    parser.add_argument("--port", type=int, default=2087, help="TCP port (default: 2087)")
+    parser.add_argument("--log-level", default="info", choices=["debug", "info", "warning", "error"])
+    args = parser.parse_args()
+
+    logging.basicConfig(level=getattr(logging, args.log_level.upper()))
+
+    server = create_server()
+
+    if args.tcp:
+        server.start_tcp(args.host, args.port)
+    else:
+        server.start_io()
+
+
+if __name__ == "__main__":
+    main()