java-functional-lsp 0.4.2__tar.gz → 0.5.0__tar.gz

{java_functional_lsp-0.4.2 → java_functional_lsp-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.4.2
+Version: 0.5.0
 Summary: Java LSP server enforcing functional programming best practices — null safety, immutability, no exceptions
 Project-URL: Homepage, https://github.com/aviadshiber/java-functional-lsp
 Project-URL: Repository, https://github.com/aviadshiber/java-functional-lsp
@@ -33,10 +33,28 @@ Description-Content-Type: text/markdown
 [![Python](https://img.shields.io/pypi/pyversions/java-functional-lsp?v=1)](https://pypi.org/project/java-functional-lsp/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-A Java Language Server that enforces functional programming best practices. Designed for teams using **Vavr**, **Lombok**, and **Spring** with a functional-first approach.
+A Java Language Server that provides two things in one:
+
+1. **Full Java language support** — completions, hover, go-to-definition, compile errors, missing imports — by proxying [Eclipse jdtls](https://github.com/eclipse-jdtls/eclipse.jdt.ls) under the hood
+2. **12 functional programming rules** — catches anti-patterns and suggests Vavr/Lombok/Spring alternatives, all before compilation
+
+Designed for teams using **Vavr**, **Lombok**, and **Spring** with a functional-first approach.
 
 ## What it checks
 
+### Java language (via jdtls)
+
+When [jdtls](https://github.com/eclipse-jdtls/eclipse.jdt.ls) is installed, the server proxies all standard Java language features:
+
+- Compile errors and warnings
+- Missing imports and unresolved symbols
+- Type mismatches
+- Completions, hover, go-to-definition, find references
+
+Install jdtls separately: `brew install jdtls` (requires JDK 21+). Without jdtls, the server runs in standalone mode — the 12 custom rules still work, but you won't get compile errors or completions.
+
+### Functional programming rules
+
 | Rule | Detects | Suggests |
 |------|---------|----------|
 | `null-literal-arg` | `null` passed as method argument | `Option.none()` or default value |
@@ -64,7 +82,7 @@ pip install java-functional-lsp
 # From source
 pip install git+https://github.com/aviadshiber/java-functional-lsp.git
 
-# Optional: install jdtls for full Java language support (completions, hover, go-to-def)
+# Optional: install jdtls for full Java language support (see above)
 brew install jdtls
 ```
 
@@ -212,9 +230,30 @@ Create `.java-functional-lsp.json` in your project root to customize rules:
 - `throw-statement` and `catch-rethrow` are automatically suppressed inside `@Bean` methods
 - `mutable-dto` suggests `@ConstructorBinding` instead of `@Value` when the class has `@ConfigurationProperties`
 
+**Inline suppression** with `@SuppressWarnings`:
+
+```java
+// Suppress a specific rule on a method
+@SuppressWarnings("java-functional-lsp:null-return")
+public String findUser() { return null; }  // no diagnostic
+
+// Suppress multiple rules
+@SuppressWarnings({"java-functional-lsp:null-return", "java-functional-lsp:throw-statement"})
+public String findUser() { ... }
+
+// Suppress all java-functional-lsp rules
+@SuppressWarnings("java-functional-lsp")
+public String legacyMethod() { ... }
+```
+
+Works on classes, methods, constructors, fields, and local variables. Suppression applies to the annotated scope — a class-level annotation suppresses all methods within it.
+
 ## How it works
 
-Uses [tree-sitter](https://tree-sitter.github.io/) with the Java grammar for fast, incremental AST parsing. No Java compiler or classpath needed — analysis runs on raw source files.
+The server has two layers:
+
+- **Custom rules** — uses [tree-sitter](https://tree-sitter.github.io/) with the Java grammar for sub-millisecond AST analysis (~0.4ms per file). No compiler or classpath needed — runs on raw source files.
+- **Java language features** — proxies [Eclipse jdtls](https://github.com/eclipse-jdtls/eclipse.jdt.ls) for compile errors, completions, hover, go-to-definition, and references. Diagnostics from both layers are merged and published together.
 
 The server speaks the Language Server Protocol (LSP) via stdio, making it compatible with any LSP client.
 

{java_functional_lsp-0.4.2 → java_functional_lsp-0.5.0}/README.md

@@ -5,10 +5,28 @@
 [![Python](https://img.shields.io/pypi/pyversions/java-functional-lsp?v=1)](https://pypi.org/project/java-functional-lsp/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-A Java Language Server that enforces functional programming best practices. Designed for teams using **Vavr**, **Lombok**, and **Spring** with a functional-first approach.
+A Java Language Server that provides two things in one:
+
+1. **Full Java language support** — completions, hover, go-to-definition, compile errors, missing imports — by proxying [Eclipse jdtls](https://github.com/eclipse-jdtls/eclipse.jdt.ls) under the hood
+2. **12 functional programming rules** — catches anti-patterns and suggests Vavr/Lombok/Spring alternatives, all before compilation
+
+Designed for teams using **Vavr**, **Lombok**, and **Spring** with a functional-first approach.
 
 ## What it checks
 
+### Java language (via jdtls)
+
+When [jdtls](https://github.com/eclipse-jdtls/eclipse.jdt.ls) is installed, the server proxies all standard Java language features:
+
+- Compile errors and warnings
+- Missing imports and unresolved symbols
+- Type mismatches
+- Completions, hover, go-to-definition, find references
+
+Install jdtls separately: `brew install jdtls` (requires JDK 21+). Without jdtls, the server runs in standalone mode — the 12 custom rules still work, but you won't get compile errors or completions.
+
+### Functional programming rules
+
 | Rule | Detects | Suggests |
 |------|---------|----------|
 | `null-literal-arg` | `null` passed as method argument | `Option.none()` or default value |
@@ -36,7 +54,7 @@ pip install java-functional-lsp
 # From source
 pip install git+https://github.com/aviadshiber/java-functional-lsp.git
 
-# Optional: install jdtls for full Java language support (completions, hover, go-to-def)
+# Optional: install jdtls for full Java language support (see above)
 brew install jdtls
 ```
 
@@ -184,9 +202,30 @@ Create `.java-functional-lsp.json` in your project root to customize rules:
 - `throw-statement` and `catch-rethrow` are automatically suppressed inside `@Bean` methods
 - `mutable-dto` suggests `@ConstructorBinding` instead of `@Value` when the class has `@ConfigurationProperties`
 
+**Inline suppression** with `@SuppressWarnings`:
+
+```java
+// Suppress a specific rule on a method
+@SuppressWarnings("java-functional-lsp:null-return")
+public String findUser() { return null; }  // no diagnostic
+
+// Suppress multiple rules
+@SuppressWarnings({"java-functional-lsp:null-return", "java-functional-lsp:throw-statement"})
+public String findUser() { ... }
+
+// Suppress all java-functional-lsp rules
+@SuppressWarnings("java-functional-lsp")
+public String legacyMethod() { ... }
+```
+
+Works on classes, methods, constructors, fields, and local variables. Suppression applies to the annotated scope — a class-level annotation suppresses all methods within it.
+
 ## How it works
 
-Uses [tree-sitter](https://tree-sitter.github.io/) with the Java grammar for fast, incremental AST parsing. No Java compiler or classpath needed — analysis runs on raw source files.
+The server has two layers:
+
+- **Custom rules** — uses [tree-sitter](https://tree-sitter.github.io/) with the Java grammar for sub-millisecond AST analysis (~0.4ms per file). No compiler or classpath needed — runs on raw source files.
+- **Java language features** — proxies [Eclipse jdtls](https://github.com/eclipse-jdtls/eclipse.jdt.ls) for compile errors, completions, hover, go-to-definition, and references. Diagnostics from both layers are merged and published together.
 
 The server speaks the Language Server Protocol (LSP) via stdio, making it compatible with any LSP client.
 

{java_functional_lsp-0.4.2 → java_functional_lsp-0.5.0}/SKILL.md

@@ -58,6 +58,7 @@ Create `.java-functional-lsp.json` in your project root:
 - `rules` — per-rule severity: `error`, `warning` (default), `info`, `hint`, `off`
 - `throw-statement`/`catch-rethrow` auto-suppressed in `@Bean` methods
 - `mutable-dto` suggests `@ConstructorBinding` for `@ConfigurationProperties` classes
+- Inline suppression: `@SuppressWarnings("java-functional-lsp:rule-id")` on any declaration
 
 ## Automatic Enforcement
 

{java_functional_lsp-0.4.2 → java_functional_lsp-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.4.2"
+version = "0.5.0"
 description = "Java LSP server enforcing functional programming best practices — null safety, immutability, no exceptions"
 readme = "README.md"
 license = { text = "MIT" }

{java_functional_lsp-0.4.2 → java_functional_lsp-0.5.0}/src/java_functional_lsp/__init__.py

@@ -1,3 +1,3 @@
 """java-functional-lsp: A Java LSP server enforcing functional programming best practices."""
 
-__version__ = "0.4.2"
+__version__ = "0.5.0"

{java_functional_lsp-0.4.2 → java_functional_lsp-0.5.0}/src/java_functional_lsp/analyzers/base.py

@@ -160,6 +160,61 @@ def is_excluded(path_str: str, patterns: list[str]) -> bool:
     return any(fnmatch.fnmatch(normalized, pattern) for pattern in patterns)
 
 
+_SUPPRESS_PREFIX = "java-functional-lsp"
+_DECLARATION_TYPES = frozenset(
+    {
+        "method_declaration",
+        "class_declaration",
+        "interface_declaration",
+        "enum_declaration",
+        "record_declaration",
+        "field_declaration",
+        "local_variable_declaration",
+        "constructor_declaration",
+    }
+)
+
+
+def is_suppressed(root: Node, line: int, col: int, rule_id: str) -> bool:
+    """Check if a diagnostic at (line, col) is suppressed by @SuppressWarnings."""
+    node = root.descendant_for_point_range((line, col), (line, col))
+    if node is None:
+        return False
+    current: Node | None = node
+    while current is not None:
+        if current.type in _DECLARATION_TYPES:
+            modifiers = next((c for c in current.children if c.type == "modifiers"), None)
+            if modifiers and _modifiers_suppress(modifiers, rule_id):
+                return True
+        current = current.parent
+    return False
+
+
+def _modifiers_suppress(modifiers: Node, rule_id: str) -> bool:
+    """Check if modifiers contain @SuppressWarnings suppressing the given rule."""
+    for child in modifiers.named_children:
+        if child.type == "annotation":
+            name_node = child.child_by_field_name("name")
+            if name_node and name_node.text == b"SuppressWarnings":
+                args = child.child_by_field_name("arguments")
+                if args and _annotation_args_suppress(args, rule_id):
+                    return True
+    return False
+
+
+def _annotation_args_suppress(args: Node, rule_id: str) -> bool:
+    """Parse @SuppressWarnings value(s) and check for rule match."""
+    for string_node in find_nodes(args, "string_literal"):
+        if string_node.text is None or len(string_node.text) < len('""'):
+            continue
+        value = string_node.text[1:-1].decode("utf-8")
+        if value == _SUPPRESS_PREFIX:
+            return True
+        if value == f"{_SUPPRESS_PREFIX}:{rule_id}":
+            return True
+    return False
+
+
 def has_sibling_annotation(modifiers_node: Node, annotation_name: bytes) -> bool:
     """Check if a modifiers node contains an annotation with the given name.
 

{java_functional_lsp-0.4.2 → java_functional_lsp-0.5.0}/src/java_functional_lsp/server.py

@@ -18,7 +18,7 @@ from lsprotocol import types as lsp
 from pygls.lsp.server import LanguageServer
 from pygls.uris import to_fs_path
 
-from .analyzers.base import Analyzer, Severity, get_parser, is_excluded
+from .analyzers.base import Analyzer, Severity, get_parser, is_excluded, is_suppressed
 from .analyzers.base import Diagnostic as LintDiagnostic
 from .analyzers.exception_checker import ExceptionChecker
 from .analyzers.mutation_checker import MutationChecker
@@ -124,6 +124,11 @@ def _analyze_document(source_text: str, uri: str = "") -> list[lsp.Diagnostic]:
         except Exception as e:
             logger.error("Analyzer %s failed: %s", type(analyzer).__name__, e)
 
+    # Filter out diagnostics suppressed by @SuppressWarnings
+    if all_diagnostics:
+        root = tree.root_node
+        all_diagnostics = [d for d in all_diagnostics if not is_suppressed(root, d.line, d.col, d.code)]
+
     return [_to_lsp_diagnostic(d) for d in all_diagnostics]
 
 

{java_functional_lsp-0.4.2 → java_functional_lsp-0.5.0}/tests/test_e2e.py

@@ -349,3 +349,28 @@ class TestE2EConfig:
         msg = _wait_diagnostics(server)
         assert msg is not None
         assert len(msg["params"]["diagnostics"]) == 0
+
+
+class TestE2ESuppressWarnings:
+    def test_suppress_warnings_annotation(self, server: subprocess.Popen[bytes], tmp_path: Path) -> None:
+        """@SuppressWarnings should suppress diagnostics for the annotated scope."""
+        java_file = tmp_path / "Suppress.java"
+        java_file.write_text(
+            "class T {\n"
+            '    @SuppressWarnings("java-functional-lsp:null-return")\n'
+            "    String f() { return null; }\n"
+            "\n"
+            "    String g() { return null; }\n"
+            "}"
+        )
+        uri = java_file.as_uri()
+
+        _initialize(server, root_uri=tmp_path.as_uri())
+        _did_open(server, uri, java_file.read_text())
+
+        msg = _wait_diagnostics(server)
+        assert msg is not None
+        null_diags = [d for d in msg["params"]["diagnostics"] if d["code"] == "null-return"]
+        # f() suppressed, g() not — should have exactly 1 null-return diagnostic on line 4 (g)
+        assert len(null_diags) == 1
+        assert null_diags[0]["range"]["start"]["line"] == 4

java_functional_lsp-0.5.0/tests/test_suppress.py

@@ -0,0 +1,246 @@
+"""Tests for @SuppressWarnings inline suppression."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from java_functional_lsp.analyzers.base import get_parser, is_suppressed
+
+
+def _codes(diags: list[Any]) -> set[str]:
+    return {d.code for d in diags}
+
+
+def _analyze_all(source: str) -> list[Any]:
+    """Run analysis through server's _analyze_document to include suppression filtering."""
+    from java_functional_lsp.server import _analyze_document
+
+    return _analyze_document(source)
+
+
+class TestSuppressSingleRule:
+    def test_suppress_null_return(self) -> None:
+        source = """
+class T {
+    @SuppressWarnings("java-functional-lsp:null-return")
+    String f() { return null; }
+}
+"""
+        diags = _analyze_all(source)
+        assert "null-return" not in _codes(diags)
+
+    def test_suppress_throw_statement(self) -> None:
+        source = """
+class T {
+    @SuppressWarnings("java-functional-lsp:throw-statement")
+    void f() { throw new RuntimeException(); }
+}
+"""
+        diags = _analyze_all(source)
+        assert "throw-statement" not in _codes(diags)
+
+
+class TestSuppressAllRules:
+    def test_suppress_all(self) -> None:
+        source = """
+class T {
+    @SuppressWarnings("java-functional-lsp")
+    String f() { return null; }
+}
+"""
+        diags = _analyze_all(source)
+        assert "null-return" not in _codes(diags)
+
+    def test_suppress_all_multiple_violations(self) -> None:
+        source = """
+class T {
+    @SuppressWarnings("java-functional-lsp")
+    void f() {
+        String x = null;
+        throw new RuntimeException();
+    }
+}
+"""
+        diags = _analyze_all(source)
+        codes = _codes(diags)
+        assert "null-assignment" not in codes
+        assert "throw-statement" not in codes
+
+
+class TestSuppressMultipleRules:
+    def test_suppress_array_syntax(self) -> None:
+        source = """
+class T {
+    @SuppressWarnings({"java-functional-lsp:null-return", "java-functional-lsp:throw-statement"})
+    String f() {
+        if (true) throw new RuntimeException();
+        return null;
+    }
+}
+"""
+        diags = _analyze_all(source)
+        codes = _codes(diags)
+        assert "null-return" not in codes
+        assert "throw-statement" not in codes
+
+
+class TestSuppressOnClass:
+    def test_class_level_suppresses_all_methods(self) -> None:
+        source = """
+@SuppressWarnings("java-functional-lsp:null-return")
+class T {
+    String f() { return null; }
+    String g() { return null; }
+}
+"""
+        diags = _analyze_all(source)
+        assert "null-return" not in _codes(diags)
+
+
+class TestSuppressOnField:
+    def test_field_suppression(self) -> None:
+        source = """
+class T {
+    @SuppressWarnings("java-functional-lsp:null-field-assignment")
+    String cache = null;
+}
+"""
+        diags = _analyze_all(source)
+        assert "null-field-assignment" not in _codes(diags)
+
+
+class TestSuppressScope:
+    def test_does_not_affect_sibling_methods(self) -> None:
+        source = """
+class T {
+    @SuppressWarnings("java-functional-lsp:null-return")
+    String f() { return null; }
+
+    String g() { return null; }
+}
+"""
+        diags = _analyze_all(source)
+        # f() is suppressed, g() is not
+        assert any(d.code == "null-return" for d in diags)
+        # Verify the remaining diagnostic is on g()'s line
+        null_diags = [d for d in diags if d.code == "null-return"]
+        assert len(null_diags) == 1
+
+
+class TestUnrelatedSuppressIgnored:
+    def test_unrelated_annotation(self) -> None:
+        source = """
+class T {
+    @SuppressWarnings("unchecked")
+    String f() { return null; }
+}
+"""
+        diags = _analyze_all(source)
+        assert "null-return" in _codes(diags)
+
+    def test_other_prefix_ignored(self) -> None:
+        source = """
+class T {
+    @SuppressWarnings("other-linter:null-return")
+    String f() { return null; }
+}
+"""
+        diags = _analyze_all(source)
+        assert "null-return" in _codes(diags)
+
+
+class TestSuppressOnInterface:
+    def test_interface_level_suppression(self) -> None:
+        source = """
+@SuppressWarnings("java-functional-lsp:null-return")
+interface Foo {
+    default String bar() { return null; }
+}
+"""
+        diags = _analyze_all(source)
+        assert "null-return" not in _codes(diags)
+
+
+class TestSuppressOnEnum:
+    def test_enum_level_suppression(self) -> None:
+        source = """
+@SuppressWarnings("java-functional-lsp:null-return")
+enum Status {
+    ACTIVE;
+    public String label() { return null; }
+}
+"""
+        diags = _analyze_all(source)
+        assert "null-return" not in _codes(diags)
+
+
+class TestSuppressSiblingClasses:
+    def test_does_not_leak_across_top_level_classes(self) -> None:
+        source = """
+@SuppressWarnings("java-functional-lsp:null-return")
+class A { String f() { return null; } }
+class B { String g() { return null; } }
+"""
+        diags = _analyze_all(source)
+        null_diags = [d for d in diags if d.code == "null-return"]
+        assert len(null_diags) == 1
+
+
+class TestSuppressNamedElement:
+    def test_value_equals_form(self) -> None:
+        source = """
+class T {
+    @SuppressWarnings(value = "java-functional-lsp:null-return")
+    String f() { return null; }
+}
+"""
+        diags = _analyze_all(source)
+        assert "null-return" not in _codes(diags)
+
+
+class TestSuppressOtherRules:
+    def test_suppress_imperative_loop(self) -> None:
+        source = """
+class T {
+    @SuppressWarnings("java-functional-lsp:imperative-loop")
+    void f() { for (int i = 0; i < 10; i++) {} }
+}
+"""
+        diags = _analyze_all(source)
+        assert "imperative-loop" not in _codes(diags)
+
+    def test_suppress_mutable_variable(self) -> None:
+        source = """
+class T {
+    @SuppressWarnings("java-functional-lsp:mutable-variable")
+    void f() { int x = 0; x = 1; }
+}
+"""
+        diags = _analyze_all(source)
+        assert "mutable-variable" not in _codes(diags)
+
+
+class TestNoSuppress:
+    def test_baseline_no_annotation(self) -> None:
+        source = "class T { String f() { return null; } }"
+        diags = _analyze_all(source)
+        assert "null-return" in _codes(diags)
+
+
+class TestIsSuppressedHelper:
+    def test_returns_false_for_clean_code(self) -> None:
+        parser = get_parser()
+        tree = parser.parse(b'class T { String f() { return "ok"; } }')
+        assert not is_suppressed(tree.root_node, 0, 30, "null-return")
+
+    def test_returns_true_for_suppressed(self) -> None:
+        parser = get_parser()
+        source = b"""class T {
+    @SuppressWarnings("java-functional-lsp:null-return")
+    String f() { return null; }
+}"""
+        tree = parser.parse(source)
+        # null is on line 2, find its column
+        lines = source.split(b"\n")
+        null_col = lines[2].index(b"null")
+        assert is_suppressed(tree.root_node, 2, null_col, "null-return")

{java_functional_lsp-0.4.2 → java_functional_lsp-0.5.0}/uv.lock

@@ -184,7 +184,7 @@ wheels = [
 
 [[package]]
 name = "java-functional-lsp"
-version = "0.4.1"
+version = "0.4.2"
 source = { editable = "." }
 dependencies = [
     { name = "pygls" },