From 893955e1feefea5d17e7d9994badd9f4557c17ef Mon Sep 17 00:00:00 2001 From: Roman Shevchenko Date: Mon, 10 Oct 2016 17:46:56 +0200 Subject: [PATCH] [java] using module stubs in analysis/highlighting code --- .../impl/analysis/JavaModuleGraphUtil.java | 58 +++++++++--------- .../impl/analysis/ModuleHighlightUtil.java | 18 ++---- .../com/intellij/psi/PsiExportsStatement.java | 7 +++ .../intellij/psi/PsiRequiresStatement.java | 3 + .../compiled/ClsExportsStatementImpl.java | 48 ++++++++++++++- .../compiled/ClsRequiresStatementImpl.java | 24 +++++++- .../impl/source/PsiExportsStatementImpl.java | 44 ++++++++++++-- .../impl/source/PsiJavaModuleReference.java | 60 ++++++++++++++----- .../impl/source/PsiRequiresStatementImpl.java | 34 +++++++++-- .../daemon/ModuleHighlightingTest.kt | 19 +++--- 10 files changed, 236 insertions(+), 79 deletions(-) diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/JavaModuleGraphUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/JavaModuleGraphUtil.java index bafac3e51e14..f26cf534f6c0 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/JavaModuleGraphUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/JavaModuleGraphUtil.java @@ -20,10 +20,10 @@ import com.intellij.openapi.module.ModuleManager; import com.intellij.openapi.project.Project; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.*; +import com.intellij.psi.impl.source.PsiJavaModuleReference; import com.intellij.psi.search.FilenameIndex; import com.intellij.psi.util.CachedValueProvider.Result; import com.intellij.psi.util.CachedValuesManager; -import com.intellij.psi.util.PsiUtil; import com.intellij.util.containers.ContainerUtil; import com.intellij.util.containers.MultiMap; import com.intellij.util.graph.DFSTBuilder; @@ -36,7 +36,6 @@ import java.util.*; import java.util.stream.Collectors; import static com.intellij.psi.PsiJavaModule.MODULE_INFO_FILE; -import static com.intellij.psi.SyntaxTraverser.psiTraverser; import static com.intellij.psi.util.PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT; public class JavaModuleGraphUtil { @@ -50,6 +49,13 @@ public class JavaModuleGraphUtil { return ContainerUtil.find(cycles, set -> set.contains(module)); } + public static boolean exports(@NotNull PsiJavaModule source, @NotNull String packageName, @NotNull PsiJavaModule target) { + Map> exports = CachedValuesManager.getCachedValue(source, () -> + Result.create(exportsMap(source), OUT_OF_CODE_BLOCK_MODIFICATION_COUNT)); + Set targets = exports.get(packageName); + return targets != null && (targets.isEmpty() || targets.contains(target.getModuleName())); + } + public static boolean reads(@NotNull PsiJavaModule source, @NotNull PsiJavaModule destination) { Project project = source.getProject(); RequiresGraph graph = CachedValuesManager.getManager(project).getCachedValue(project, () -> @@ -74,14 +80,11 @@ public class JavaModuleGraphUtil { if (!projectModules.isEmpty()) { MultiMap relations = MultiMap.create(); for (PsiJavaModule module : projectModules) { - for (PsiRequiresStatement statement : psiTraverser().children(module).filter(PsiRequiresStatement.class)) { - Optional.ofNullable(statement.getReferenceElement()) - .map(PsiJavaModuleReferenceElement::getReference) - .map(ref -> ref.multiResolve(true)) - .map(a -> a.length == 1 ? a[0].getElement() : null) - .map(e -> e instanceof PsiJavaModule ? (PsiJavaModule)e : null) - .filter(projectModules::contains) - .ifPresent(dependency -> relations.putValue(module, dependency)); + for (PsiRequiresStatement statement : module.getRequires()) { + PsiJavaModule dependency = PsiJavaModuleReference.resolve(statement, statement.getModuleName(), true); + if (dependency != null && projectModules.contains(dependency)) { + relations.putValue(module, dependency); + } } } @@ -98,6 +101,16 @@ public class JavaModuleGraphUtil { return Collections.emptyList(); } + private static Map> exportsMap(@NotNull PsiJavaModule source) { + Map> map = ContainerUtil.newHashMap(); + for (PsiExportsStatement statement : source.getExports()) { + String pkg = statement.getPackageName(); + List targets = statement.getModuleNames(); + map.put(pkg, targets.isEmpty() ? Collections.emptySet() : ContainerUtil.newTroveSet(targets)); + } + return map; + } + // Starting from source modules, collects all module dependencies in the project. // The resulting graph is used for tracing readability. private static RequiresGraph buildRequiresGraph(Project project) { @@ -118,28 +131,17 @@ public class JavaModuleGraphUtil { private static void visit(PsiJavaModule module, MultiMap relations, Set publicEdges) { if (!relations.containsKey(module)) { relations.putValues(module, Collections.emptyList()); - for (PsiRequiresStatement statement : psiTraverser().children(module).filter(PsiRequiresStatement.class)) { - Optional.ofNullable(statement.getReferenceElement()) - .map(PsiJavaModuleReferenceElement::getReference) - .map(PsiReference::resolve) - .map(e -> e instanceof PsiJavaModule ? (PsiJavaModule)e : null) - .ifPresent(dependency -> { - relations.putValue(module, dependency); - if (isPublic(statement)) publicEdges.add(RequiresGraph.key(dependency, module)); - visit(dependency, relations, publicEdges); - }); + for (PsiRequiresStatement statement : module.getRequires()) { + PsiJavaModule dependency = PsiJavaModuleReference.resolve(statement, statement.getModuleName(), false); + if (dependency != null) { + relations.putValue(module, dependency); + if (statement.isPublic()) publicEdges.add(RequiresGraph.key(dependency, module)); + visit(dependency, relations, publicEdges); + } } } } - private static boolean isPublic(PsiRequiresStatement statement) { - for (PsiElement child = statement.getFirstChild(); child != null; child = child.getNextSibling()) { - if (PsiUtil.isJavaToken(child, JavaTokenType.PUBLIC_KEYWORD)) return true; - if (child instanceof PsiJavaModuleReferenceElement) break; - } - return false; - } - private static class RequiresGraph { private final Graph myGraph; private final Set myPublicEdges; diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/ModuleHighlightUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/ModuleHighlightUtil.java index 480c5b0af920..f268eefe3391 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/ModuleHighlightUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/ModuleHighlightUtil.java @@ -118,12 +118,12 @@ public class ModuleHighlightUtil { List results = ContainerUtil.newSmartList(); checkDuplicateRefs( - psiTraverser().children(module).filter(PsiRequiresStatement.class), + module.getRequires(), st -> Optional.ofNullable(st.getReferenceElement()).map(PsiJavaModuleReferenceElement::getReferenceText), "module.duplicate.requires", results); checkDuplicateRefs( - psiTraverser().children(module).filter(PsiExportsStatement.class), + module.getExports(), st -> Optional.ofNullable(st.getPackageReference()).map(ModuleHighlightUtil::refText), "module.duplicate.export", results); @@ -267,7 +267,7 @@ public class ModuleHighlightUtil { List results = ContainerUtil.newSmartList(); Set targets = ContainerUtil.newTroveSet(); - for (PsiJavaModuleReferenceElement refElement : psiTraverser().children(statement).filter(PsiJavaModuleReferenceElement.class)) { + for (PsiJavaModuleReferenceElement refElement : statement.getModuleReferences()) { String refText = refElement.getReferenceText(); PsiPolyVariantReference ref = refElement.getReference(); assert ref != null : statement; @@ -376,7 +376,7 @@ public class ModuleHighlightUtil { String refModuleName = refModule.getModuleName(); String requiredName = targetModule.getModuleName(); - if (!(targetModule instanceof PsiCompiledElement) && !isExported(targetModule, packageName)) { + if (!(targetModule instanceof PsiCompiledElement) && !JavaModuleGraphUtil.exports(targetModule, packageName, refModule)) { String message = JavaErrorMessages.message("module.package.not.exported", requiredName, packageName, refModuleName); return HighlightInfo.newHighlightInfo(HighlightInfoType.WRONG_REF).range(ref).description(message).create(); } @@ -389,16 +389,6 @@ public class ModuleHighlightUtil { return null; } - private static boolean isExported(PsiJavaModule module, String packageName) { - for (PsiExportsStatement statement : psiTraverser().children(module).filter(PsiExportsStatement.class)) { - String exportedName = Optional.ofNullable(statement.getPackageReference()).map(ModuleHighlightUtil::refText).orElse(""); - if (packageName.equals(exportedName)) { - return true; - } - } - return false; - } - private static HighlightInfo moduleResolveError(PsiJavaModuleReferenceElement refElement, PsiPolyVariantReference ref) { boolean missing = ref.multiResolve(true).length == 0; String message = JavaErrorMessages.message(missing ? "module.not.found" : "module.not.on.path", refElement.getReferenceText()); diff --git a/java/java-psi-api/src/com/intellij/psi/PsiExportsStatement.java b/java/java-psi-api/src/com/intellij/psi/PsiExportsStatement.java index b0c68a8e4072..8376db142dcc 100644 --- a/java/java-psi-api/src/com/intellij/psi/PsiExportsStatement.java +++ b/java/java-psi-api/src/com/intellij/psi/PsiExportsStatement.java @@ -15,8 +15,11 @@ */ package com.intellij.psi; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.List; + /** * Represents an {@code exports} statement of a Java module declaration. * @@ -26,4 +29,8 @@ public interface PsiExportsStatement extends PsiElement { PsiExportsStatement[] EMPTY_ARRAY = new PsiExportsStatement[0]; @Nullable PsiJavaCodeReferenceElement getPackageReference(); + @Nullable String getPackageName(); + + @NotNull Iterable getModuleReferences(); + @NotNull List getModuleNames(); } \ No newline at end of file diff --git a/java/java-psi-api/src/com/intellij/psi/PsiRequiresStatement.java b/java/java-psi-api/src/com/intellij/psi/PsiRequiresStatement.java index 0396011c63b9..41b703090e24 100644 --- a/java/java-psi-api/src/com/intellij/psi/PsiRequiresStatement.java +++ b/java/java-psi-api/src/com/intellij/psi/PsiRequiresStatement.java @@ -26,4 +26,7 @@ public interface PsiRequiresStatement extends PsiElement { PsiRequiresStatement[] EMPTY_ARRAY = new PsiRequiresStatement[0]; @Nullable PsiJavaModuleReferenceElement getReferenceElement(); + @Nullable String getModuleName(); + + boolean isPublic(); } \ No newline at end of file diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/compiled/ClsExportsStatementImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/compiled/ClsExportsStatementImpl.java index 1360368bd1be..f6684de532bb 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/compiled/ClsExportsStatementImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/compiled/ClsExportsStatementImpl.java @@ -15,26 +15,70 @@ */ package com.intellij.psi.impl.compiled; +import com.intellij.openapi.util.AtomicNotNullLazyValue; +import com.intellij.openapi.util.NotNullLazyValue; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiExportsStatement; import com.intellij.psi.PsiJavaCodeReferenceElement; +import com.intellij.psi.PsiJavaModuleReferenceElement; import com.intellij.psi.impl.java.stubs.PsiExportsStatementStub; import com.intellij.psi.impl.source.tree.JavaElementType; import com.intellij.psi.impl.source.tree.TreeElement; +import com.intellij.util.Function; +import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.List; public class ClsExportsStatementImpl extends ClsRepositoryPsiElement implements PsiExportsStatement { + private final NotNullLazyValue myPackageReference; + private final NotNullLazyValue> myModuleReferences; + public ClsExportsStatementImpl(PsiExportsStatementStub stub) { super(stub); + myPackageReference = new AtomicNotNullLazyValue() { + @NotNull + @Override + protected PsiJavaCodeReferenceElement compute() { + return new ClsJavaCodeReferenceElementImpl(ClsExportsStatementImpl.this, getStub().getPackageName()); + } + }; + myModuleReferences = new AtomicNotNullLazyValue>() { + @NotNull + @Override + protected Iterable compute() { + return ContainerUtil.map(getStub().getTargets(), new Function() { + @Override + public PsiJavaModuleReferenceElement fun(String target) { + return new ClsJavaModuleReferenceElementImpl(ClsExportsStatementImpl.this, target); + } + }); + } + }; + } + + @Override + public PsiJavaCodeReferenceElement getPackageReference() { + return myPackageReference.getValue(); } @Nullable @Override - public PsiJavaCodeReferenceElement getPackageReference() { - return null; + public String getPackageName() { + return StringUtil.nullize(getStub().getPackageName()); + } + + @NotNull + @Override + public Iterable getModuleReferences() { + return myModuleReferences.getValue(); + } + + @NotNull + @Override + public List getModuleNames() { + return getStub().getTargets(); } @Override diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/compiled/ClsRequiresStatementImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/compiled/ClsRequiresStatementImpl.java index 9b617657ad9b..7aa54b9532c7 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/compiled/ClsRequiresStatementImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/compiled/ClsRequiresStatementImpl.java @@ -15,6 +15,8 @@ */ package com.intellij.psi.impl.compiled; +import com.intellij.openapi.util.AtomicNotNullLazyValue; +import com.intellij.openapi.util.NotNullLazyValue; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiJavaModuleReferenceElement; import com.intellij.psi.PsiRequiresStatement; @@ -25,14 +27,34 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; public class ClsRequiresStatementImpl extends ClsRepositoryPsiElement implements PsiRequiresStatement { + private final NotNullLazyValue myModuleReference; + public ClsRequiresStatementImpl(PsiRequiresStatementStub stub) { super(stub); + myModuleReference = new AtomicNotNullLazyValue() { + @NotNull + @Override + protected PsiJavaModuleReferenceElement compute() { + return new ClsJavaModuleReferenceElementImpl(ClsRequiresStatementImpl.this, getStub().getModuleName()); + } + }; } @Nullable @Override public PsiJavaModuleReferenceElement getReferenceElement() { - return null; + return myModuleReference.getValue(); + } + + @Nullable + @Override + public String getModuleName() { + return getStub().getModuleName(); + } + + @Override + public boolean isPublic() { + return getStub().isPublic(); } @Override diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiExportsStatementImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiExportsStatementImpl.java index e0c5f1f35b29..d91c6652fb7e 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiExportsStatementImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiExportsStatementImpl.java @@ -16,16 +16,19 @@ package com.intellij.psi.impl.source; import com.intellij.lang.ASTNode; -import com.intellij.psi.JavaElementVisitor; -import com.intellij.psi.PsiElementVisitor; -import com.intellij.psi.PsiExportsStatement; -import com.intellij.psi.PsiJavaCodeReferenceElement; +import com.intellij.openapi.util.text.StringUtil; +import com.intellij.psi.*; import com.intellij.psi.impl.java.stubs.JavaStubElementTypes; import com.intellij.psi.impl.java.stubs.PsiExportsStatementStub; import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.List; + +import static com.intellij.psi.SyntaxTraverser.psiTraverser; + public class PsiExportsStatementImpl extends JavaStubPsiElement implements PsiExportsStatement { public PsiExportsStatementImpl(@NotNull PsiExportsStatementStub stub) { super(stub, JavaStubElementTypes.EXPORTS_STATEMENT); @@ -41,6 +44,39 @@ public class PsiExportsStatementImpl extends JavaStubPsiElement getModuleReferences() { + return psiTraverser().children(this).filter(PsiJavaModuleReferenceElement.class); + } + + @NotNull + @Override + public List getModuleNames() { + PsiExportsStatementStub stub = getGreenStub(); + if (stub != null) { + return stub.getTargets(); + } + else { + List targets = ContainerUtil.newSmartList(); + for (PsiJavaModuleReferenceElement refElement : getModuleReferences()) targets.add(refElement.getReferenceText()); + return targets; + } + } + @Override public void accept(@NotNull PsiElementVisitor visitor) { if (visitor instanceof JavaElementVisitor) { diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiJavaModuleReference.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiJavaModuleReference.java index 6808766177c1..f9b98a3ace86 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiJavaModuleReference.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiJavaModuleReference.java @@ -19,17 +19,29 @@ import com.intellij.core.JavaCoreBundle; import com.intellij.openapi.module.Module; import com.intellij.openapi.project.Project; import com.intellij.openapi.roots.FileIndexFacade; +import com.intellij.openapi.util.Key; +import com.intellij.openapi.util.Pair; import com.intellij.openapi.util.TextRange; +import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.*; import com.intellij.psi.impl.file.impl.JavaFileManager; import com.intellij.psi.impl.source.resolve.ResolveCache; import com.intellij.psi.search.GlobalSearchScope; +import com.intellij.psi.util.CachedValueProvider; +import com.intellij.psi.util.CachedValuesManager; +import com.intellij.psi.util.ParameterizedCachedValue; +import com.intellij.psi.util.ParameterizedCachedValueProvider; import com.intellij.util.ArrayUtil; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import java.util.Collection; +import java.util.Collections; + +import static com.intellij.openapi.util.Pair.pair; +import static com.intellij.psi.util.PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT; public class PsiJavaModuleReference extends PsiReferenceBase.Poly { public PsiJavaModuleReference(@NotNull PsiJavaModuleReferenceElement element) { @@ -75,10 +87,24 @@ public class PsiJavaModuleReference extends PsiReferenceBase.Poly modules = findModules(file, moduleName, incompleteCode); + if (!modules.isEmpty()) { + ResolveResult[] result = new ResolveResult[modules.size()]; + int i = 0; + for (PsiJavaModule module : modules) result[i++] = new PsiElementResolveResult(module); + return result; + } + else { + return ResolveResult.EMPTY_ARRAY; + } + } + + private static Collection findModules(PsiFile file, String moduleName, boolean incompleteCode) { + Project project = file.getProject(); GlobalSearchScope scope = null; - PsiFile file = reference.getElement().getContainingFile(); if (incompleteCode || file.getOriginalFile() instanceof PsiCompiledFile) { scope = GlobalSearchScope.allScope(project); } @@ -92,18 +118,24 @@ public class PsiJavaModuleReference extends PsiReferenceBase.Poly modules = service.findModules(reference.getCanonicalText(), scope); - if (!modules.isEmpty()) { - ResolveResult[] result = new ResolveResult[modules.size()]; - int i = 0; - for (PsiJavaModule module : modules) result[i++] = new PsiElementResolveResult(module); - return result; - } - } - - return ResolveResult.EMPTY_ARRAY; + return scope != null ? JavaFileManager.SERVICE.getInstance(project).findModules(moduleName, scope) : Collections.emptyList(); } } + + private static final Key>> KEY = Key.create("java.module.ref.text.resolve"); + + @Nullable + public static PsiJavaModule resolve(@NotNull final PsiElement refOwner, String refText, boolean incompleteCode) { + if (StringUtil.isEmpty(refText)) return null; + CachedValuesManager manager = CachedValuesManager.getManager(refOwner.getProject()); + return manager.getParameterizedCachedValue(refOwner, KEY, new ParameterizedCachedValueProvider>() { + @Nullable + @Override + public CachedValueProvider.Result compute(Pair p) { + Collection modules = Resolver.findModules(refOwner.getContainingFile(), p.first, p.second); + PsiJavaModule module = modules.size() == 1 ? modules.iterator().next() : null; + return CachedValueProvider.Result.create(module, OUT_OF_CODE_BLOCK_MODIFICATION_COUNT); + } + }, false, pair(refText, incompleteCode)); + } } \ No newline at end of file diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiRequiresStatementImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiRequiresStatementImpl.java index 00dc7981d979..5e4f6c4c9780 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiRequiresStatementImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiRequiresStatementImpl.java @@ -16,13 +16,11 @@ package com.intellij.psi.impl.source; import com.intellij.lang.ASTNode; -import com.intellij.psi.JavaElementVisitor; -import com.intellij.psi.PsiElementVisitor; -import com.intellij.psi.PsiJavaModuleReferenceElement; -import com.intellij.psi.PsiRequiresStatement; +import com.intellij.psi.*; import com.intellij.psi.impl.java.stubs.JavaStubElementTypes; import com.intellij.psi.impl.java.stubs.PsiRequiresStatementStub; import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.psi.util.PsiUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -41,6 +39,34 @@ public class PsiRequiresStatementImpl extends JavaStubPsiElementuses pkg. main . /*...*/ C; provides pkg .main .C with pkg.main.Impl; provides pkg.main.C with pkg. main. Impl; - }""".trimIndent(), true) + }""".trimIndent()) } fun testUnusedStatements() { @@ -63,7 +61,7 @@ class ModuleHighlightingTest : LightJava9ModulesCodeInsightFixtureTestCase() { highlight(""" module M { provides pkg.main.C with pkg.main.Impl; - }""".trimIndent(), true) + }""".trimIndent()) } fun testRequires() { @@ -74,7 +72,7 @@ class ModuleHighlightingTest : LightJava9ModulesCodeInsightFixtureTestCase() { requires M1; requires M2; requires M3; - }""".trimIndent(), true) + }""".trimIndent()) } fun testExports() { @@ -137,7 +135,7 @@ class ModuleHighlightingTest : LightJava9ModulesCodeInsightFixtureTestCase() { fun testPackageAccessibility() { addFile("module-info.java", "module M { requires M2; requires M6; }") - addFile("module-info.java", "module M2 { exports pkg.m2; }", M2) + addFile("module-info.java", "module M2 { exports pkg.m2; exports pkg.m2.impl to close.friends.only; }", M2) addFile("pkg/m2/C2.java", "package pkg.m2;\npublic class C2 { }", M2) addFile("pkg/m2/impl/C2Impl.java", "package pkg.m2.impl;\nimport pkg.m2.C2;\npublic class C2Impl { public static C2 make() {} }", M2) addFile("pkg/m4/C4.java", "package pkg.m4;\npublic class C4 { }", M4) @@ -159,17 +157,14 @@ class ModuleHighlightingTest : LightJava9ModulesCodeInsightFixtureTestCase() { import static pkg.m2.impl.C2Impl.make; class C { } - """.trimIndent(), true) + """.trimIndent()) } // - private fun highlight(text: String, filter: Boolean = false) = highlight("module-info.java", text, filter) + private fun highlight(text: String) = highlight("module-info.java", text) - private fun highlight(path: String, text: String, filter: Boolean = false) { + private fun highlight(path: String, text: String) { myFixture.configureFromExistingVirtualFile(addFile(path, text)) - if (filter) { - (myFixture as CodeInsightTestFixtureImpl).setVirtualFileFilter { it.name != PsiJavaModule.MODULE_INFO_FILE } - } myFixture.checkHighlighting() }