Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.
Python aicode-complexitycode-healthcode-intelligencecode-qualitydead-codedeveloper-toolsdocumentationgit-analyticsmcpopen-sourcepythonrefactoringstatic-analysistechnical-debt
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.pyindex 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-discovereddiff --git a/packages/core/src/repowise/core/ingestion/queries/kotlin.scm b/packages/core/src/repowise/core/ingestion/queries/kotlin.scmindex 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.defdiff --git a/packages/core/src/repowise/core/ingestion/resolvers/jvm_gradle.py b/packages/core/src/repowise/core/ingestion/resolvers/jvm_gradle.pyindex 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.pyindex 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.pyindex 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.pyindex 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.pyindex 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.pyindex 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 fqnsassert "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(