Add tests for script configuration machinery, namely ScriptTemplateProvider EP

Test highlighting and navigation depending on provided script definition

generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt

@@ -106,6 +106,8 @@ import org.jetbrains.kotlin.idea.refactoring.rename.AbstractRenameTest
 import org.jetbrains.kotlin.idea.refactoring.safeDelete.AbstractSafeDeleteTest
 import org.jetbrains.kotlin.idea.repl.AbstractIdeReplCompletionTest
 import org.jetbrains.kotlin.idea.resolve.*
+import org.jetbrains.kotlin.idea.script.AbstractScriptConfigurationHighlightingTest
+import org.jetbrains.kotlin.idea.script.AbstractScriptConfigurationNavigationTest
 import org.jetbrains.kotlin.idea.structureView.AbstractKotlinFileStructureTest
 import org.jetbrains.kotlin.idea.stubs.AbstractMultiFileHighlightingTest
 import org.jetbrains.kotlin.idea.stubs.AbstractResolveByStubTest
@@ -830,6 +832,14 @@ fun main(args: Array<String>) {
         testClass<AbstractIdeReplCompletionTest>() {
             model("repl/completion")
         }
+
+        testClass<AbstractScriptConfigurationHighlightingTest> {
+            model("script/definition/highlighting", extension = null, recursive = false)
+        }
+
+        testClass<AbstractScriptConfigurationNavigationTest> {
+            model("script/definition/navigation", extension = null, recursive = false)
+        }
     }
 
     testGroup("idea/idea-maven/test", "idea/idea-maven/testData") {

idea/idea-core/src/org/jetbrains/kotlin/idea/core/script/KotlinScriptConfigurationManager.kt

@@ -32,6 +32,7 @@ import com.intellij.psi.search.FileTypeIndex
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.search.NonClasspathDirectoriesScope
 import com.intellij.util.io.URLUtil
+import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.script.*
@@ -152,6 +153,15 @@ class KotlinScriptConfigurationManager(
             return res
         }
         internal val log = Logger.getInstance(KotlinScriptConfigurationManager::class.java)
+
+        @TestOnly
+        fun reloadScriptDefinitions(project: Project) {
+            with (getInstance(project)) {
+                reloadScriptDefinitions()
+                scriptExternalImportsProvider.invalidateCaches()
+                invalidateLocalCaches()
+            }
+        }
     }
 }
 

idea/testData/script/definition/highlighting/additionalImports/script.kts

@@ -0,0 +1,7 @@
+val c = 3
+
+val g = listOf("a", "b", "c")
+
+val time = measureNanoTime {
+    println("text")
+}

idea/testData/script/definition/highlighting/additionalImports/template/template.kt

@@ -0,0 +1,24 @@
+package custom.scriptDefinition
+
+import org.jetbrains.kotlin.script.*
+import java.io.File
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Future
+
+class TestDependenciesResolver : ScriptDependenciesResolver {
+    override fun resolve(
+            script: ScriptContents,
+            environment: Map<String, Any?>?,
+            report: (ScriptDependenciesResolver.ReportSeverity, String, ScriptContents.Position?) -> Unit, previousDependencies: KotlinScriptExternalDependencies?
+    ): Future<KotlinScriptExternalDependencies?> {
+        return CompletableFuture.completedFuture(
+                object : KotlinScriptExternalDependencies {
+                    override val classpath: Iterable<File> = listOf(environment?.get("runtime-classes") as File)
+                    override val imports: Iterable<String> = listOf("kotlin.system.*")
+                })
+
+    }
+}
+
+@ScriptTemplateDefinition(TestDependenciesResolver::class, scriptFilePattern = "script.kts")
+class Template

idea/testData/script/definition/highlighting/customBaseClass/script.kts

@@ -0,0 +1,3 @@
+val j: Int = i
+
+val s: String = str

idea/testData/script/definition/highlighting/customBaseClass/template/template.kt

@@ -0,0 +1,28 @@
+package custom.scriptDefinition
+
+import org.jetbrains.kotlin.script.*
+import java.io.File
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Future
+
+class TestDependenciesResolver : ScriptDependenciesResolver {
+    override fun resolve(
+            script: ScriptContents,
+            environment: Map<String, Any?>?,
+            report: (ScriptDependenciesResolver.ReportSeverity, String, ScriptContents.Position?) -> Unit, previousDependencies: KotlinScriptExternalDependencies?
+    ): Future<KotlinScriptExternalDependencies?> {
+        return CompletableFuture.completedFuture(
+                object : KotlinScriptExternalDependencies {
+                    override val classpath: Iterable<File> = listOf(environment?.get("template-classes") as File)
+                })
+
+    }
+}
+
+@ScriptTemplateDefinition(TestDependenciesResolver::class, scriptFilePattern = "script.kts")
+class Template: Base()
+
+open class Base {
+    val i = 3
+    val str = ""
+}

idea/testData/script/definition/highlighting/customLibrary/lib/lib.kt

@@ -0,0 +1,5 @@
+package custom.library
+
+class C()
+
+fun doStuff(c1: C, c2: C) {}

idea/testData/script/definition/highlighting/customLibrary/script.kts

@@ -0,0 +1,8 @@
+val c1 = C()
+
+val c2 = C()
+
+doStuff(c1, c2)
+
+doStuff(c1, <error>3</error>)
+

idea/testData/script/definition/highlighting/customLibrary/template/template.kt

@@ -0,0 +1,27 @@
+package custom.scriptDefinition
+
+import org.jetbrains.kotlin.script.*
+import java.io.File
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Future
+
+class TestDependenciesResolver : ScriptDependenciesResolver {
+    override fun resolve(
+            script: ScriptContents,
+            environment: Map<String, Any?>?,
+            report: (ScriptDependenciesResolver.ReportSeverity, String, ScriptContents.Position?) -> Unit, previousDependencies: KotlinScriptExternalDependencies?
+    ): Future<KotlinScriptExternalDependencies?> {
+        return CompletableFuture.completedFuture(
+                object : KotlinScriptExternalDependencies {
+                    override val classpath: Iterable<File> = listOf(
+                            environment?.get("lib-classes") as File
+                    )
+
+                    override val imports: Iterable<String> = listOf("custom.library.*")
+                })
+
+    }
+}
+
+@ScriptTemplateDefinition(TestDependenciesResolver::class, scriptFilePattern = "script.kts")
+class Template

idea/testData/script/definition/highlighting/simple/script.kts

@@ -0,0 +1,7 @@
+val c = 3
+
+val g = listOf("a", "b", "c")
+
+val time = <error>measureNanoTime</error> {
+    println("text")
+}

idea/testData/script/definition/highlighting/simple/template/template.kt

@@ -0,0 +1,23 @@
+package custom.scriptDefinition
+
+import org.jetbrains.kotlin.script.*
+import java.io.File
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Future
+
+class TestDependenciesResolver : ScriptDependenciesResolver {
+    override fun resolve(
+            script: ScriptContents,
+            environment: Map<String, Any?>?,
+            report: (ScriptDependenciesResolver.ReportSeverity, String, ScriptContents.Position?) -> Unit, previousDependencies: KotlinScriptExternalDependencies?
+    ): Future<KotlinScriptExternalDependencies?> {
+        return CompletableFuture.completedFuture(
+                object : KotlinScriptExternalDependencies {
+                    override val classpath: Iterable<File> = listOf(environment?.get("runtime-classes") as File)
+                })
+
+    }
+}
+
+@ScriptTemplateDefinition(TestDependenciesResolver::class, scriptFilePattern = "script.kts")
+class Template

idea/testData/script/definition/navigation/customBaseClass/script.kts

@@ -0,0 +1,4 @@
+<caret>str
+
+// REF: (in custom.scriptDefinition.Base).str
+// FILE: scriptDefinition/Base.class

idea/testData/script/definition/navigation/customBaseClass/template/template.kt

@@ -0,0 +1,28 @@
+package custom.scriptDefinition
+
+import org.jetbrains.kotlin.script.*
+import java.io.File
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Future
+
+class TestDependenciesResolver : ScriptDependenciesResolver {
+    override fun resolve(
+            script: ScriptContents,
+            environment: Map<String, Any?>?,
+            report: (ScriptDependenciesResolver.ReportSeverity, String, ScriptContents.Position?) -> Unit, previousDependencies: KotlinScriptExternalDependencies?
+    ): Future<KotlinScriptExternalDependencies?> {
+        return CompletableFuture.completedFuture(
+                object : KotlinScriptExternalDependencies {
+                    override val classpath: Iterable<File> = listOf(environment?.get("template-classes") as File)
+                })
+
+    }
+}
+
+@ScriptTemplateDefinition(TestDependenciesResolver::class, scriptFilePattern = "script.kts")
+class Template: Base()
+
+open class Base {
+    val i = 3
+    val str = ""
+}

idea/testData/script/definition/navigation/javaLib/lib/test/Utils.java

@@ -0,0 +1,7 @@
+package test;
+
+public class Utils {
+    public static void foo(String str) {
+
+    }
+}

idea/testData/script/definition/navigation/javaLib/script.kts

@@ -0,0 +1,3 @@
+test.Utils.fo<caret>o("asd")
+// REF: (in test.Utils).foo(String)
+// FILE: test/Utils.class

idea/testData/script/definition/navigation/javaLib/template/template.kt

@@ -0,0 +1,23 @@
+package custom.scriptDefinition
+
+import org.jetbrains.kotlin.script.*
+import java.io.File
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Future
+
+class TestDependenciesResolver : ScriptDependenciesResolver {
+    override fun resolve(
+            script: ScriptContents,
+            environment: Map<String, Any?>?,
+            report: (ScriptDependenciesResolver.ReportSeverity, String, ScriptContents.Position?) -> Unit, previousDependencies: KotlinScriptExternalDependencies?
+    ): Future<KotlinScriptExternalDependencies?> {
+        return CompletableFuture.completedFuture(
+                object : KotlinScriptExternalDependencies {
+                    override val classpath: Iterable<File> = listOf(environment?.get("lib-classes") as File)
+                })
+
+    }
+}
+
+@ScriptTemplateDefinition(TestDependenciesResolver::class, scriptFilePattern = "script.kts")
+class Template

idea/testData/script/definition/navigation/javaLibWithSources/lib/test/Utils.java

@@ -0,0 +1,7 @@
+package test;
+
+public class Utils {
+    public static void foo(String str) {
+
+    }
+}

idea/testData/script/definition/navigation/javaLibWithSources/script.kts

@@ -0,0 +1,3 @@
+test.Utils.fo<caret>o("asd")
+// REF: (in test.Utils).foo(String)
+// FILE: test/Utils.java

idea/testData/script/definition/navigation/javaLibWithSources/template/template.kt

@@ -0,0 +1,24 @@
+package custom.scriptDefinition
+
+import org.jetbrains.kotlin.script.*
+import java.io.File
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Future
+
+class TestDependenciesResolver : ScriptDependenciesResolver {
+    override fun resolve(
+            script: ScriptContents,
+            environment: Map<String, Any?>?,
+            report: (ScriptDependenciesResolver.ReportSeverity, String, ScriptContents.Position?) -> Unit, previousDependencies: KotlinScriptExternalDependencies?
+    ): Future<KotlinScriptExternalDependencies?> {
+        return CompletableFuture.completedFuture(
+                object : KotlinScriptExternalDependencies {
+                    override val classpath: Iterable<File> = listOf(environment?.get("lib-classes") as File)
+                    override val sources: Iterable<File> = listOf(environment?.get("lib-source") as File)
+                })
+
+    }
+}
+
+@ScriptTemplateDefinition(TestDependenciesResolver::class, scriptFilePattern = "script.kts")
+class Template

idea/testData/script/definition/navigation/stdlib/script.kts

@@ -0,0 +1,4 @@
+val g = lis<caret>tOf("a", "b", "c")
+
+// REF: (kotlin.collections).listOf(T)
+// FILE: collections/CollectionsKt.class

idea/testData/script/definition/navigation/stdlib/template/template.kt

@@ -0,0 +1,23 @@
+package custom.scriptDefinition
+
+import org.jetbrains.kotlin.script.*
+import java.io.File
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Future
+
+class TestDependenciesResolver : ScriptDependenciesResolver {
+    override fun resolve(
+            script: ScriptContents,
+            environment: Map<String, Any?>?,
+            report: (ScriptDependenciesResolver.ReportSeverity, String, ScriptContents.Position?) -> Unit, previousDependencies: KotlinScriptExternalDependencies?
+    ): Future<KotlinScriptExternalDependencies?> {
+        return CompletableFuture.completedFuture(
+                object : KotlinScriptExternalDependencies {
+                    override val classpath: Iterable<File> = listOf(environment?.get("runtime-classes") as File)
+                })
+
+    }
+}
+
+@ScriptTemplateDefinition(TestDependenciesResolver::class, scriptFilePattern = "script.kts")
+class Template

idea/testData/script/definition/navigation/stdlibWithSources/script.kts

@@ -0,0 +1,4 @@
+val g = lis<caret>tOf("a", "b", "c")
+
+// REF: (kotlin.collections).listOf(T)
+// FILE: collections/Collections.kt

idea/testData/script/definition/navigation/stdlibWithSources/template/template.kt

@@ -0,0 +1,24 @@
+package custom.scriptDefinition
+
+import org.jetbrains.kotlin.script.*
+import java.io.File
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Future
+
+class TestDependenciesResolver : ScriptDependenciesResolver {
+    override fun resolve(
+            script: ScriptContents,
+            environment: Map<String, Any?>?,
+            report: (ScriptDependenciesResolver.ReportSeverity, String, ScriptContents.Position?) -> Unit, previousDependencies: KotlinScriptExternalDependencies?
+    ): Future<KotlinScriptExternalDependencies?> {
+        return CompletableFuture.completedFuture(
+                object : KotlinScriptExternalDependencies {
+                    override val classpath: Iterable<File> = listOf(environment?.get("runtime-classes") as File)
+                    override val sources: Iterable<File> = listOf(environment?.get("runtime-source") as File)
+                })
+
+    }
+}
+
+@ScriptTemplateDefinition(TestDependenciesResolver::class, scriptFilePattern = "script.kts")
+class Template

idea/tests/org/jetbrains/kotlin/checkers/AbstractPsiCheckerTest.java

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.checkers;
 
+import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.rt.execution.junit.FileComparisonFailure;
 import com.intellij.spellchecker.inspections.SpellCheckingInspection;
 import com.intellij.testFramework.LightProjectDescriptor;
@@ -32,6 +33,12 @@ import java.io.File;
 import static org.jetbrains.kotlin.resolve.lazy.ResolveSession.areDescriptorsCreatedForDeclaration;
 
 public abstract class AbstractPsiCheckerTest extends KotlinLightCodeInsightFixtureTestCase {
+    public void doTest(@NotNull VirtualFile file) throws Exception {
+        myFixture.configureFromExistingVirtualFile(file);
+        checkHighlighting(true, false, false);
+        checkResolveToDescriptor();
+    }
+
     public void doTest(@NotNull String filePath) throws Exception {
         myFixture.configureByFile(filePath);
         checkHighlighting(true, false, false);

idea/tests/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolverTest.java

@@ -40,6 +40,9 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
+import static org.jetbrains.kotlin.test.ReferenceUtils.getFileWithDir;
+import static org.jetbrains.kotlin.test.ReferenceUtils.renderAsGotoImplementation;
+
 public class BuiltInsReferenceResolverTest extends KotlinLightCodeInsightFixtureTestCase {
     public void testAny() throws Exception {
         doTest();
@@ -124,19 +127,11 @@ public class BuiltInsReferenceResolverTest extends KotlinLightCodeInsightFixture
         String expectedTarget = InTextDirectivesUtils.findStringWithPrefixes(text, "// TARGET:");
 
         assertEquals(expectedBinaryFile, getFileWithDir(resolved));
-        assertEquals(expectedTarget, ReferenceUtils.renderAsGotoImplementation(resolved));
+        assertEquals(expectedTarget, renderAsGotoImplementation(resolved));
         PsiElement srcElement = resolved.getNavigationElement();
         Assert.assertNotEquals(srcElement, resolved);
         assertEquals(expectedSourceFile, getFileWithDir(srcElement));
-        assertEquals(expectedTarget, ReferenceUtils.renderAsGotoImplementation(srcElement));
-    }
-
-    @NotNull
-    private static String getFileWithDir(@NotNull PsiElement resolved) {
-        PsiFile targetFile = resolved.getContainingFile();
-        PsiDirectory targetDir = targetFile.getParent();
-        assertNotNull(targetDir);
-        return targetDir.getName() + "/" + targetFile.getName();
+        assertEquals(expectedTarget, renderAsGotoImplementation(srcElement));
     }
 
     @Override

idea/tests/org/jetbrains/kotlin/idea/script/AbstractScriptConfigurationTest.kt

@@ -0,0 +1,148 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.idea.script
+
+import com.intellij.openapi.extensions.Extensions
+import com.intellij.openapi.util.io.FileUtil
+import com.intellij.openapi.util.text.StringUtil
+import com.intellij.openapi.vfs.LocalFileSystem
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.testFramework.PlatformTestUtil
+import org.jetbrains.kotlin.checkers.AbstractPsiCheckerTest
+import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
+import org.jetbrains.kotlin.idea.core.script.KotlinScriptConfigurationManager
+import org.jetbrains.kotlin.idea.test.KotlinLightProjectDescriptor
+import org.jetbrains.kotlin.script.ScriptTemplatesProvider
+import org.jetbrains.kotlin.test.InTextDirectivesUtils
+import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.MockLibraryUtil
+import org.jetbrains.kotlin.test.ReferenceUtils
+import org.jetbrains.kotlin.utils.PathUtil
+import org.junit.Assert
+import java.io.File
+import java.util.regex.Pattern
+
+
+abstract class AbstractScriptConfigurationHighlightingTest : AbstractScriptConfigurationTest() {
+    override fun doTest(path: String) {
+        configureScriptEnvironment(path)
+
+        super.doTest(copyScriptFile(path))
+    }
+}
+
+abstract class AbstractScriptConfigurationNavigationTest : AbstractScriptConfigurationTest() {
+
+    override fun doTest(path: String) {
+        configureScriptEnvironment(path)
+
+        myFixture.configureFromExistingVirtualFile(copyScriptFile(path))
+        val reference = myFixture.getReferenceAtCaretPosition()!!
+
+        val resolved = reference.resolve()!!.navigationElement!!
+
+        val expectedReference = InTextDirectivesUtils.findStringWithPrefixes(myFixture.file.text, "// REF:")
+        val actualReference = ReferenceUtils.renderAsGotoImplementation(resolved)
+
+        Assert.assertEquals(expectedReference, actualReference)
+
+        val expectedFile = InTextDirectivesUtils.findStringWithPrefixes(myFixture.file.text, "// FILE:")
+        val actualFile = ReferenceUtils.getFileWithDir(resolved)
+
+        Assert.assertEquals(expectedFile, actualFile)
+    }
+}
+
+abstract class AbstractScriptConfigurationTest : AbstractPsiCheckerTest() {
+    protected fun configureScriptEnvironment(path: String) {
+        val templateOutDir = compileLibToDir(
+                File("${path}template"),
+                classpath = listOf(PathUtil.getKotlinPathsForDistDirectory().compilerPath.path)
+        )
+
+        val libSrcDir = File("${path}lib")
+        val libClasses = if (libSrcDir.isDirectory) {
+            compileLibToDir(libSrcDir, classpath = listOf())
+        }
+        else null
+
+        registerScriptTemplateProvider(templateOutDir, libClasses, libSrcDir)
+    }
+
+    protected fun copyScriptFile(path: String): VirtualFile {
+        val scriptDir = KotlinTestUtils.tmpDir("scriptDir")
+        val target = File(scriptDir, "script.kts")
+        File("${path}script.kts").copyTo(target)
+        val vFile = LocalFileSystem.getInstance().findFileByPath(target.path)!!
+        return vFile
+    }
+
+    private fun compileLibToDir(srcDir: File, classpath: List<String>): File {
+        val outDir = KotlinTestUtils.tmpDir("${getTestName(false)}${srcDir.name}Out")
+
+        val kotlinSourceFiles = FileUtil.findFilesByMask(Pattern.compile(".+\\.kt$"), srcDir)
+        if (kotlinSourceFiles.isNotEmpty()) {
+            MockLibraryUtil.compileKotlin(
+                    srcDir.path, outDir,
+                    *classpath.toTypedArray()
+            )
+        }
+
+        val javaSourceFiles = FileUtil.findFilesByMask(Pattern.compile(".+\\.java$"), srcDir)
+        if (javaSourceFiles.isNotEmpty()) {
+            KotlinTestUtils.compileJavaFiles(
+                    javaSourceFiles,
+                    listOf("-cp", StringUtil.join(classpath + outDir, File.pathSeparator), "-d", outDir.path)
+            )
+        }
+        return outDir
+    }
+
+    private fun registerScriptTemplateProvider(templateDir: File, libClasses: File?, libSource: File?) {
+        val provider = TestScriptTemplateProvider(
+                templateDir,
+                mapOf(
+                        "runtime-classes" to ForTestCompileRuntime.runtimeJarForTests(),
+                        "runtime-source" to File("libraries/stdlib/src"),
+                        "lib-classes" to libClasses,
+                        "lib-source" to libSource,
+                        "template-classes" to templateDir
+                )
+        )
+
+        PlatformTestUtil.registerExtension(
+                Extensions.getArea(project),
+                ScriptTemplatesProvider.EP_NAME,
+                provider,
+                myTestRootDisposable
+        )
+        KotlinScriptConfigurationManager.reloadScriptDefinitions(project)
+    }
+
+    override fun getProjectDescriptor() = KotlinLightProjectDescriptor.INSTANCE
+}
+
+class TestScriptTemplateProvider(
+        compiledTemplateDir: File,
+        override val environment: Map<String, Any?>
+) : ScriptTemplatesProvider {
+    override val id = "Test"
+    override val version = 0
+    override val isValid = true
+    override val templateClassNames = listOf("custom.scriptDefinition.Template")
+    override val dependenciesClasspath = listOf(compiledTemplateDir.canonicalPath)
+}

idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationHighlightingTestGenerated.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.idea.script;
+
+import com.intellij.testFramework.TestDataPath;
+import org.jetbrains.kotlin.test.JUnit3RunnerWithInners;
+import org.jetbrains.kotlin.test.KotlinTestUtils;
+import org.jetbrains.kotlin.test.TestMetadata;
+import org.junit.runner.RunWith;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@TestMetadata("idea/testData/script/definition/highlighting")
+@TestDataPath("$PROJECT_ROOT")
+@RunWith(JUnit3RunnerWithInners.class)
+public class ScriptConfigurationHighlightingTestGenerated extends AbstractScriptConfigurationHighlightingTest {
+    @TestMetadata("additionalImports")
+    public void testAdditionalImports() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/script/definition/highlighting/additionalImports/");
+        doTest(fileName);
+    }
+
+    public void testAllFilesPresentInHighlighting() throws Exception {
+        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/script/definition/highlighting"), Pattern.compile("^([^\\.]+)$"), false);
+    }
+
+    @TestMetadata("customBaseClass")
+    public void testCustomBaseClass() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/script/definition/highlighting/customBaseClass/");
+        doTest(fileName);
+    }
+
+    @TestMetadata("customLibrary")
+    public void testCustomLibrary() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/script/definition/highlighting/customLibrary/");
+        doTest(fileName);
+    }
+
+    @TestMetadata("simple")
+    public void testSimple() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/script/definition/highlighting/simple/");
+        doTest(fileName);
+    }
+}

idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationNavigationTestGenerated.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.idea.script;
+
+import com.intellij.testFramework.TestDataPath;
+import org.jetbrains.kotlin.test.JUnit3RunnerWithInners;
+import org.jetbrains.kotlin.test.KotlinTestUtils;
+import org.jetbrains.kotlin.test.TestMetadata;
+import org.junit.runner.RunWith;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@TestMetadata("idea/testData/script/definition/navigation")
+@TestDataPath("$PROJECT_ROOT")
+@RunWith(JUnit3RunnerWithInners.class)
+public class ScriptConfigurationNavigationTestGenerated extends AbstractScriptConfigurationNavigationTest {
+    public void testAllFilesPresentInNavigation() throws Exception {
+        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/script/definition/navigation"), Pattern.compile("^([^\\.]+)$"), false);
+    }
+
+    @TestMetadata("customBaseClass")
+    public void testCustomBaseClass() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/script/definition/navigation/customBaseClass/");
+        doTest(fileName);
+    }
+
+    @TestMetadata("javaLib")
+    public void testJavaLib() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/script/definition/navigation/javaLib/");
+        doTest(fileName);
+    }
+
+    @TestMetadata("javaLibWithSources")
+    public void testJavaLibWithSources() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/script/definition/navigation/javaLibWithSources/");
+        doTest(fileName);
+    }
+
+    @TestMetadata("stdlib")
+    public void testStdlib() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/script/definition/navigation/stdlib/");
+        doTest(fileName);
+    }
+
+    @TestMetadata("stdlibWithSources")
+    public void testStdlibWithSources() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/script/definition/navigation/stdlibWithSources/");
+        doTest(fileName);
+    }
+}

idea/tests/org/jetbrains/kotlin/test/ReferenceUtils.java

@@ -18,9 +18,7 @@ package org.jetbrains.kotlin.test;
 
 import com.intellij.navigation.ItemPresentation;
 import com.intellij.navigation.NavigationItem;
-import com.intellij.psi.PsiAnonymousClass;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiPackage;
+import com.intellij.psi.*;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.psi.KtClass;
@@ -65,4 +63,11 @@ public final class ReferenceUtils {
                ? presentableText
                : locationString + "." + presentableText;
     }
+
+    @NotNull
+    public static String getFileWithDir(@NotNull PsiElement resolved) {
+        PsiFile targetFile = resolved.getContainingFile();
+        PsiDirectory targetDir = targetFile.getParent();
+        return targetDir.getName() + "/" + targetFile.getName();
+    }
 }