Skip to content

Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.

fix(jvm): flag Java and Kotlin public API for published modules (#3577)

Rishabh Mishrad2d8dda7bb45
diff --git a/packages/core/src/repowise/core/ingestion/graph_warmups.py b/packages/core/src/repowise/core/ingestion/graph_warmups.py
index 5d76fa825..d9e11838e 100644
--- a/packages/core/src/repowise/core/ingestion/graph_warmups.py
+++ b/packages/core/src/repowise/core/ingestion/graph_warmups.py
@@ -135,6 +135,93 @@ def _warmup_jvm(ctx: ResolverContext) -> None:
if nd is not None:
nd["is_never_flag"] = True
+ # Stamp qualifying JVM source files in publishing modules as package_export.
+ # A module publishes if:
+ # 1. Gradle: applies java-library or maven-publish (or java-library.*) and not application.
+ # 2. Maven: packaging is jar.
+ # If the module defines a module-info.java, only files in packages it exports qualify.
+ # Test files and pom aggregators never qualify.
+ parsed = getattr(ctx, "parsed_files", None) or {}
+ repo_path = getattr(ctx, "repo_path", None)
+ snapshot = getattr(ctx, "walk_snapshot", None)
+ jpms_exports = getattr(index, "jpms_exports", {})
+
+ def _qualifies(path: str, mod_dir: str) -> bool:
+ pf = parsed.get(path)
+ if pf is not None and getattr(pf.file_info, "is_test", False):
+ return False
+ if path.endswith(("module-info.java", "package-info.java")):
+ return False
+ if mod_dir in jpms_exports:
+ pkg = index.package_for_file(path)
+ if not pkg or pkg not in jpms_exports[mod_dir]:
+ return False
+ return True
+
+ # 1. Gradle publishing modules
+ if gradle_index is not None:
+ from .resolvers.jvm_gradle import is_publishing_gradle_project
+
+ for project in gradle_index.projects.values():
+ if not is_publishing_gradle_project(project):
+ continue
+ base = project.root_dir.rstrip("/")
+ mod_dir = project.root_dir.strip("/")
+ if mod_dir == ".":
+ mod_dir = ""
+ main_src_dirs: list[str] = []
+ for ss in project.source_sets.values():
+ if ss.is_main:
+ main_src_dirs.extend(ss.src_dirs)
+ if not main_src_dirs:
+ main_src_dirs = ["src/main/java", "src/main/kotlin"]
+
+ prefixes = [f"{base}/{sd}/" if base else f"{sd}/" for sd in main_src_dirs]
+ for path in parsed:
+ if (
+ (path.endswith(".java") or path.endswith(".kt"))
+ and any(path.startswith(p) for p in prefixes)
+ and _qualifies(path, mod_dir)
+ ):
+ node = graph.nodes.get(path)
+ if node is not None:
+ node["package_export"] = True
+
+ # 2. Maven publishing modules
+ if repo_path is not None:
+ from pathlib import PurePosixPath
+
+ from repowise.core.fs_walk import glob_via
+
+ pom_paths = [
+ p
+ for p in glob_via(
+ snapshot, repo_path, "pom.xml", prune_nested_git=ctx.prune_nested_git
+ )
+ if p.is_file()
+ ]
+ if pom_paths:
+ try:
+ from .external_systems.maven_model import load_maven_reactor
+
+ reactor = load_maven_reactor(repo_path, pom_paths)
+ for proj in reactor.projects:
+ if proj.packaging.lower() == "jar":
+ pom_parent = PurePosixPath(proj.manifest).parent
+ mod_dir = "" if str(pom_parent) == "." else str(pom_parent).strip("/")
+ prefix = f"{mod_dir}/src/main/" if mod_dir else "src/main/"
+ for path in parsed:
+ if (
+ (path.endswith(".java") or path.endswith(".kt"))
+ and path.startswith(prefix)
+ and _qualifies(path, mod_dir)
+ ):
+ node = graph.nodes.get(path)
+ if node is not None:
+ node["package_export"] = True
+ except Exception:
+ pass
+
def _warmup_cpp(ctx: ResolverContext) -> None:
"""Build the C/C++ workspace index and propagate workspace-discovered
diff --git a/packages/core/src/repowise/core/ingestion/queries/kotlin.scm b/packages/core/src/repowise/core/ingestion/queries/kotlin.scm
index 6b896adf1..8365e7fb3 100644
--- a/packages/core/src/repowise/core/ingestion/queries/kotlin.scm
+++ b/packages/core/src/repowise/core/ingestion/queries/kotlin.scm
@@ -14,10 +14,12 @@
) @symbol.def
(class_declaration
+ (modifiers)? @symbol.modifiers
(identifier) @symbol.name
) @symbol.def
(object_declaration
+ (modifiers)? @symbol.modifiers
(identifier) @symbol.name
) @symbol.def
diff --git a/packages/core/src/repowise/core/ingestion/resolvers/jvm_gradle.py b/packages/core/src/repowise/core/ingestion/resolvers/jvm_gradle.py
index 81b9b0c48..cd728d7a8 100644
--- a/packages/core/src/repowise/core/ingestion/resolvers/jvm_gradle.py
+++ b/packages/core/src/repowise/core/ingestion/resolvers/jvm_gradle.py
@@ -47,9 +47,18 @@ _SOURCESET_NAME_RE = re.compile(
r'(?:val\s+|getByName\s*\(\s*"|named\s*\(\s*"|create\s*\(\s*"|register\s*\(\s*")?'
r'(\w+)(?:"\s*\))?\s*\{',
)
-_PLUGIN_ID_RE = re.compile(r'id\s*\(\s*"([^"]+)"\s*\)')
+_PLUGIN_ID_RE = re.compile(r'id\s*\(\s*["\']([^"\']+)["\']\s*\)')
_PLUGIN_ID_GROOVY_RE = re.compile(r"id\s+['\"]([^'\"]+)['\"]")
_APPLY_PLUGIN_RE = re.compile(r"apply\s+plugin:\s*['\"]([^'\"]+)['\"]")
+_APPLY_PLUGIN_KTS_RE = re.compile(r'apply\s*\(\s*plugin\s*=\s*["\']([^"\']+)["\']\s*\)')
+_ALIAS_PLUGIN_RE = re.compile(r"alias\s*\(\s*([^)]+)\s*\)")
+_PLUGINS_BLOCK_RE = re.compile(r"plugins\s*\{([^}]+)\}", re.DOTALL)
+_KTS_BACKTICK_PLUGIN_RE = re.compile(r"`([^`]+)`")
+_KTS_BARE_CORE_PLUGIN_RE = re.compile(
+ r"^\s*(application|java-library|maven-publish|java)\s*$", re.MULTILINE
+)
+_GRADLE_BLOCK_COMMENT_RE = re.compile(r"/\*.*?\*/", re.DOTALL)
+_GRADLE_LINE_COMMENT_RE = re.compile(r"//[^\n]*")
_PACKAGE_RE = re.compile(r"^\s*package\s+([\w.]+)", re.MULTILINE)
_ROOT_PROJECT_NAME_RE = re.compile(r'rootProject\s*\.\s*name\s*=\s*"([^"]+)"')
# A quoted fully-qualified class name: lowercase package segments, then a
@@ -245,12 +254,42 @@ def _detect_plugins(module_dir: Path) -> frozenset[str]:
text = build.read_text(encoding="utf-8", errors="ignore")
except Exception:
continue
- for pat in (_PLUGIN_ID_RE, _PLUGIN_ID_GROOVY_RE, _APPLY_PLUGIN_RE):
- for m in pat.finditer(text):
+ clean_text = _GRADLE_BLOCK_COMMENT_RE.sub(
+ lambda m: "\n" * m.group(0).count("\n"), text
+ )
+ clean_text = _GRADLE_LINE_COMMENT_RE.sub("", clean_text)
+ for pat in (_PLUGIN_ID_RE, _PLUGIN_ID_GROOVY_RE, _APPLY_PLUGIN_RE, _APPLY_PLUGIN_KTS_RE):
+ for m in pat.finditer(clean_text):
+ plugins.append(m.group(1))
+ for m in _ALIAS_PLUGIN_RE.finditer(clean_text):
+ raw_alias = m.group(1).strip()
+ if "plugins." in raw_alias:
+ plugin_sub = raw_alias.split("plugins.", 1)[1].strip()
+ plugins.append(plugin_sub)
+ plugins.append(plugin_sub.replace(".", "-"))
+ for blk in _PLUGINS_BLOCK_RE.finditer(clean_text):
+ block_content = blk.group(1)
+ for m in _KTS_BACKTICK_PLUGIN_RE.finditer(block_content):
+ plugins.append(m.group(1))
+ for m in _KTS_BARE_CORE_PLUGIN_RE.finditer(block_content):
plugins.append(m.group(1))
return frozenset(plugins)
+def is_publishing_gradle_project(project: JvmGradleProject) -> bool:
+ """Whether a Gradle module publishes an artifact to consumers.
+
+ Published modules apply ``java-library``, ``maven-publish``, or a convention
+ plugin matching ``java-library.*``, and do not apply ``application``.
+ """
+ if "application" in project.plugins:
+ return False
+ return any(
+ p in ("java-library", "maven-publish") or p.startswith("java-library.")
+ for p in project.plugins
+ )
+
+
# ---------------------------------------------------------------------------
# Package extraction (cached per file)
# ---------------------------------------------------------------------------
diff --git a/packages/core/src/repowise/core/ingestion/resolvers/jvm_workspace.py b/packages/core/src/repowise/core/ingestion/resolvers/jvm_workspace.py
index 3eb23463f..e44041e6e 100644
--- a/packages/core/src/repowise/core/ingestion/resolvers/jvm_workspace.py
+++ b/packages/core/src/repowise/core/ingestion/resolvers/jvm_workspace.py
@@ -184,6 +184,9 @@ class JvmWorkspaceIndex:
autoconfig_imports: dict[str, tuple[str, ...]] = field(default_factory=dict)
"""Spring Boot autoconfig import files → listed FQNs (for Phase 3/4)."""
+ jpms_exports: dict[str, frozenset[str]] = field(default_factory=dict)
+ """Module dir → frozenset of exported package FQNs (from module-info.java)."""
+
def files_for_package(self, fqn: str) -> tuple[str, ...]:
"""Return all files in the package."""
pkg = self.packages.get(fqn)
@@ -340,6 +343,14 @@ _JPMS_PROVIDES_RE = re.compile(
r"provides\s+([\w.]+)\s+with\s+([\w.,\s]+);",
re.MULTILINE,
)
+_JPMS_EXPORTS_RE = re.compile(
+ r"\bexports\s+([\w.]+)",
+ re.MULTILINE,
+)
+_JAVA_COMMENT_OR_STRING_RE = re.compile(
+ r'"(?:[^"\\]|\\.)*"|//[^\n]*|/\*.*?\*/',
+ re.DOTALL,
+)
def _scan_jpms_provides(
@@ -371,6 +382,46 @@ def _scan_jpms_provides(
return {k: tuple(v) for k, v in out.items()}
+def _scan_jpms_exports(
+ repo_path: Path, *, prune_nested_git: bool = True, snapshot: Any | None = None
+) -> dict[str, frozenset[str]]:
+ """Scan ``module-info.java`` files for ``exports <pkg>;`` directives.
+
+ Keyed by module directory (relative to repo_root). For paths containing
+ ``/src/``, the module directory is the path before ``/src/``; for root
+ or top-level module files, it is the enclosing directory (or ``""`` for root).
+ Ignores test ``module-info.java`` files and comments/strings.
+ """
+ out: dict[str, set[str]] = {}
+ for mi in glob_via(
+ snapshot, repo_path, "module-info.java", prune_nested_git=prune_nested_git
+ ):
+ if not mi.is_file():
+ continue
+ try:
+ rel = mi.relative_to(repo_path).as_posix()
+ except ValueError:
+ continue
+ if "/src/test/" in rel or rel.startswith("src/test/") or "/test/" in rel:
+ continue
+ if "/src/" in rel:
+ mod_dir = rel.split("/src/", 1)[0]
+ else:
+ mod_dir = rel.rsplit("/", 1)[0] if "/" in rel else ""
+ try:
+ text = mi.read_text(encoding="utf-8", errors="ignore")
+ except OSError:
+ continue
+ clean_text = _JAVA_COMMENT_OR_STRING_RE.sub(" ", text)
+ pkgs = set()
+ for m in _JPMS_EXPORTS_RE.finditer(clean_text):
+ pkg = m.group(1).strip()
+ if pkg:
+ pkgs.add(pkg)
+ out.setdefault(mod_dir, set()).update(pkgs)
+ return {k: frozenset(v) for k, v in out.items()}
+
+
def _scan_meta_inf_services(
repo_path: Path, *, prune_nested_git: bool = True, snapshot: Any | None = None
) -> dict[str, tuple[str, ...]]:
@@ -547,6 +598,10 @@ def build_jvm_workspace_index(ctx: ResolverContext) -> JvmWorkspaceIndex:
index.autoconfig_imports = _scan_spring_autoconfig(
repo_path, prune_nested_git=ctx.prune_nested_git, snapshot=snapshot
)
+ with contextlib.suppress(Exception):
+ index.jpms_exports = _scan_jpms_exports(
+ repo_path, prune_nested_git=ctx.prune_nested_git, snapshot=snapshot
+ )
_scan_jvm_file.cache_clear()
diff --git a/tests/unit/analysis/test_public_api_flag.py b/tests/unit/analysis/test_public_api_flag.py
index 2f5ef9cf3..48c816f02 100644
--- a/tests/unit/analysis/test_public_api_flag.py
+++ b/tests/unit/analysis/test_public_api_flag.py
@@ -44,8 +44,8 @@ _REPO = {
}
-def build_fixture(repo: Path) -> GraphBuilder:
- for rel, body in _REPO.items():
+def build_fixture(repo: Path, files: dict[str, str] = _REPO) -> GraphBuilder:
+ for rel, body in files.items():
(repo / rel).parent.mkdir(parents=True, exist_ok=True)
(repo / rel).write_text(body, encoding="utf-8")
parser = ASTParser()
@@ -88,3 +88,159 @@ def test_exported_symbols_carry_the_file_that_exports_them(tmp_path: Path) -> No
):
assert flags[node] == "", node
+
+def test_maven_published_module_flags_public_api(tmp_path: Path) -> None:
+ files = {
+ "pom.xml": (
+ '<project xmlns="http://maven.apache.org/POM/4.0.0">\n'
+ ' <modelVersion>4.0.0</modelVersion>\n'
+ ' <groupId>com.example</groupId>\n'
+ ' <artifactId>parent</artifactId>\n'
+ ' <version>1.0.0</version>\n'
+ ' <packaging>pom</packaging>\n'
+ ' <modules><module>lib</module></modules>\n'
+ '</project>\n'
+ ),
+ "lib/pom.xml": (
+ '<project xmlns="http://maven.apache.org/POM/4.0.0">\n'
+ ' <modelVersion>4.0.0</modelVersion>\n'
+ ' <groupId>com.example</groupId>\n'
+ ' <artifactId>lib</artifactId>\n'
+ ' <version>1.0.0</version>\n'
+ ' <packaging>jar</packaging>\n'
+ '</project>\n'
+ ),
+ "lib/src/main/java/a/Api.java": (
+ "package a;\n\n"
+ "public class Api {\n"
+ " public void run() {}\n"
+ " private void secret() {}\n"
+ "}\n"
+ ),
+ "lib/src/main/java/a/Hidden.java": (
+ "package a;\n\n"
+ "class Hidden {\n"
+ " public void foo() {}\n"
+ "}\n"
+ ),
+ "lib/src/test/java/a/ApiTest.java": (
+ "package a;\n\n"
+ "public class ApiTest {\n"
+ " public void testRun() {}\n"
+ "}\n"
+ ),
+ }
+ graph = build_fixture(tmp_path, files).graph()
+ flags = {
+ node: data["public_api"]
+ for node, data in graph.nodes(data=True)
+ if data.get("node_type") == "symbol" and "public_api" in data
+ }
+ assert flags["lib/src/main/java/a/Api.java::Api"] == "lib/src/main/java/a/Api.java"
+ assert flags["lib/src/main/java/a/Api.java::Api::run"] == "lib/src/main/java/a/Api.java"
+ assert flags.get("lib/src/main/java/a/Api.java::Api::secret", "") == ""
+ assert flags.get("lib/src/main/java/a/Hidden.java::Hidden", "") == ""
+ assert flags.get("lib/src/test/java/a/ApiTest.java::ApiTest", "") == ""
+
+
+def test_gradle_and_jpms_published_module_flags_public_api(tmp_path: Path) -> None:
+ files = {
+ "settings.gradle.kts": 'include("lib")\ninclude("app")\n',
+ "lib/build.gradle.kts": 'plugins {\n `java-library`\n}\n',
+ "app/build.gradle.kts": 'plugins {\n application\n}\n',
+ "lib/src/main/java/module-info.java": (
+ "module lib {\n"
+ " exports a;\n"
+ "}\n"
+ ),
+ "lib/src/main/java/a/LibApi.java": (
+ "package a;\n\n"
+ "public class LibApi {\n"
+ " public void serve() {}\n"
+ "}\n"
+ ),
+ "lib/src/main/java/a/impl/InternalLib.java": (
+ "package a.impl;\n\n"
+ "public class InternalLib {\n"
+ " public void internalServe() {}\n"
+ "}\n"
+ ),
+ "app/src/main/java/b/AppMain.java": (
+ "package b;\n\n"
+ "public class AppMain {\n"
+ " public void start() {}\n"
+ "}\n"
+ ),
+ }
+ graph = build_fixture(tmp_path, files).graph()
+ flags = {
+ node: data["public_api"]
+ for node, data in graph.nodes(data=True)
+ if data.get("node_type") == "symbol" and "public_api" in data
+ }
+ assert flags["lib/src/main/java/a/LibApi.java::LibApi"] == "lib/src/main/java/a/LibApi.java"
+ assert flags["lib/src/main/java/a/LibApi.java::LibApi::serve"] == "lib/src/main/java/a/LibApi.java"
+ assert flags.get("lib/src/main/java/a/impl/InternalLib.java::InternalLib", "") == ""
+ assert flags.get("lib/src/main/java/a/impl/InternalLib.java::InternalLib::internalServe", "") == ""
+ assert flags.get("app/src/main/java/b/AppMain.java::AppMain", "") == ""
+
+
+def test_kotlin_public_api_and_visibility(tmp_path: Path) -> None:
+ files = {
+ "build.gradle.kts": 'plugins {\n `java-library`\n}\n',
+ "src/main/kotlin/a/Open.kt": (
+ "package a\n\n"
+ "class Open {\n"
+ " fun execute() {}\n"
+ "}\n"
+ ),
+ "src/main/kotlin/a/Hidden.kt": (
+ "package a\n\n"
+ "internal class Hidden {\n"
+ " fun run() {}\n"
+ "}\n\n"
+ "internal object HiddenObj {\n"
+ " fun compute() {}\n"
+ "}\n"
+ ),
+ }
+ parser = ASTParser()
+ hidden_bytes = (
+ b"package a\n\n"
+ b"internal class Hidden {\n"
+ b" fun run() {}\n"
+ b"}\n\n"
+ b"internal object HiddenObj {\n"
+ b" fun compute() {}\n"
+ b"}\n"
+ )
+ from repowise.core.ingestion.traverser import FileInfo
+ fi = FileInfo(
+ path="src/main/kotlin/a/Hidden.kt",
+ abs_path=str(tmp_path / "src/main/kotlin/a/Hidden.kt"),
+ language="kotlin",
+ size_bytes=len(hidden_bytes),
+ git_hash="0",
+ last_modified=0.0,
+ is_test=False,
+ is_config=False,
+ is_api_contract=False,
+ is_entry_point=False,
+ )
+ pf = parser.parse_file(fi, hidden_bytes)
+ symbols = {s.name: s.visibility for s in pf.symbols}
+ assert symbols["Hidden"] == "internal"
+ assert symbols["HiddenObj"] == "internal"
+
+ graph = build_fixture(tmp_path, files).graph()
+ flags = {
+ node: data["public_api"]
+ for node, data in graph.nodes(data=True)
+ if data.get("node_type") == "symbol" and "public_api" in data
+ }
+ assert flags["src/main/kotlin/a/Open.kt::Open"] == "src/main/kotlin/a/Open.kt"
+ assert flags["src/main/kotlin/a/Open.kt::Open::execute"] == "src/main/kotlin/a/Open.kt"
+ assert flags.get("src/main/kotlin/a/Hidden.kt::Hidden", "") == ""
+ assert flags.get("src/main/kotlin/a/Hidden.kt::HiddenObj", "") == ""
+
+
diff --git a/tests/unit/health/test_plan_annotations.py b/tests/unit/health/test_plan_annotations.py
index a970c955e..f8af0ac20 100644
--- a/tests/unit/health/test_plan_annotations.py
+++ b/tests/unit/health/test_plan_annotations.py
@@ -265,6 +265,25 @@ def test_changing_an_exported_symbol_warns_about_outside_callers() -> None:
assert not annotate_any(plan(file_path="svc/other.py", target_symbol="handle"), facts)
+def test_changing_an_exported_jvm_symbol_warns_about_outside_callers() -> None:
+ exported = {
+ "lib/src/main/java/a/Api.java": {
+ "lib/src/main/java/a/Api.java::Api::run": "lib/src/main/java/a/Api.java"
+ }
+ }
+ facts = AnnotationFacts(exported=exported)
+ notes = annotate(
+ plan(file_path="lib/src/main/java/a/Api.java", target_symbol="Api.run"), facts
+ )
+ assert notes.risks == (
+ PlanRisk(
+ "public_api",
+ "`Api.run` is exported from `lib/src/main/java/a/Api.java`; changing its signature "
+ "breaks consumers outside the repo.",
+ ),
+ )
+
+
def test_a_moved_exported_method_carries_one_public_api_risk() -> None:
exported = {
"svc/orders.py": {
diff --git a/tests/unit/ingestion/test_jvm_gradle.py b/tests/unit/ingestion/test_jvm_gradle.py
index 721e0186b..64b34aa4d 100644
--- a/tests/unit/ingestion/test_jvm_gradle.py
+++ b/tests/unit/ingestion/test_jvm_gradle.py
@@ -127,3 +127,54 @@ class TestJvmGradleIndex:
index = build_jvm_gradle_index(tmp_path)
matches = index.lookup_class("com.example.Custom")
assert java_path in matches
+
+ def test_plugin_detection_and_publishing(self, tmp_path: Path) -> None:
+ from repowise.core.ingestion.resolvers.jvm_gradle import (
+ JvmGradleProject,
+ _detect_plugins,
+ is_publishing_gradle_project,
+ )
+
+ (tmp_path / "lib").mkdir()
+ (tmp_path / "lib" / "build.gradle.kts").write_text(
+ "plugins {\n"
+ " `java-library`\n"
+ " `maven-publish`\n"
+ "}\n"
+ )
+ lib_plugins = _detect_plugins(tmp_path / "lib")
+ assert "java-library" in lib_plugins
+ assert "maven-publish" in lib_plugins
+ assert is_publishing_gradle_project(
+ JvmGradleProject(id="lib", root_dir="lib", plugins=lib_plugins)
+ )
+
+ (tmp_path / "app").mkdir()
+ (tmp_path / "app" / "build.gradle.kts").write_text(
+ 'plugins {\n'
+ ' id("application")\n'
+ ' id("java-library.caffeine")\n'
+ '}\n'
+ )
+ app_plugins = _detect_plugins(tmp_path / "app")
+ assert "application" in app_plugins
+ assert "java-library.caffeine" in app_plugins
+ assert not is_publishing_gradle_project(
+ JvmGradleProject(id="app", root_dir="app", plugins=app_plugins)
+ )
+
+ (tmp_path / "lib_comment").mkdir()
+ (tmp_path / "lib_comment" / "build.gradle.kts").write_text(
+ "plugins {\n"
+ " `java-library`\n"
+ " // application is not used here\n"
+ " /* application */\n"
+ " alias(libs.plugins.some.tool)\n"
+ "}\n"
+ )
+ lib_comment_plugins = _detect_plugins(tmp_path / "lib_comment")
+ assert "application" not in lib_comment_plugins
+ assert "java-library" in lib_comment_plugins
+ assert is_publishing_gradle_project(
+ JvmGradleProject(id="lib_comment", root_dir="lib_comment", plugins=lib_comment_plugins)
+ )
diff --git a/tests/unit/ingestion/test_jvm_workspace.py b/tests/unit/ingestion/test_jvm_workspace.py
index 600b92758..6e80f9f94 100644
--- a/tests/unit/ingestion/test_jvm_workspace.py
+++ b/tests/unit/ingestion/test_jvm_workspace.py
@@ -158,6 +158,36 @@ class TestJvmWorkspaceIndex:
assert "com.example.MyAutoConfig" in fqns
assert "com.example.OtherConfig" in fqns
+ def test_jpms_exports(self, tmp_path: Path) -> None:
+ mi_caffeine = tmp_path / "caffeine" / "src" / "main" / "java" / "module-info.java"
+ mi_caffeine.parent.mkdir(parents=True)
+ mi_caffeine.write_text(
+ "module caffeine {\n"
+ " // exports com.example.commented;\n"
+ " /* exports com.example.blockcomment; */\n"
+ ' String s = "exports com.example.string";\n'
+ " exports com.github.benmanes.caffeine.cache;\n"
+ " exports com.github.benmanes.caffeine.cache.stats;\n"
+ "}\n"
+ )
+ mi_javalin = tmp_path / "javalin" / "module-info.java"
+ mi_javalin.parent.mkdir(parents=True)
+ mi_javalin.write_text(
+ "module io.javalin {\n"
+ " exports io.javalin;\n"
+ "}\n"
+ )
+ ctx = _ctx(tmp_path, [])
+ index = build_jvm_workspace_index(ctx)
+ assert index.jpms_exports["caffeine"] == frozenset({
+ "com.github.benmanes.caffeine.cache",
+ "com.github.benmanes.caffeine.cache.stats",
+ })
+ assert "com.example.commented" not in index.jpms_exports["caffeine"]
+ assert "com.example.blockcomment" not in index.jpms_exports["caffeine"]
+ assert "com.example.string" not in index.jpms_exports["caffeine"]
+ assert index.jpms_exports["javalin"] == frozenset({"io.javalin"})
+
class TestMemberFqnResolution:
def test_kotlin_companion_member_import_resolves_to_declaring_type(