172: AbstractSlicerTest.kt reverted to previous rebase

idea/tests/org/jetbrains/kotlin/idea/slicer/AbstractSlicerTest.kt.172

@@ -17,41 +17,61 @@
 package org.jetbrains.kotlin.idea.slicer
 
 import com.intellij.analysis.AnalysisScope
-import com.intellij.ide.projectView.TreeStructureProvider
-import com.intellij.ide.util.treeView.AbstractTreeStructureBase
 import com.intellij.openapi.util.io.FileUtil
-import com.intellij.slicer.DuplicateMap
 import com.intellij.slicer.SliceAnalysisParams
-import com.intellij.slicer.SliceNode
+import com.intellij.slicer.SliceUsage
-import com.intellij.slicer.SliceRootNode
 import com.intellij.usages.TextChunk
+import com.intellij.util.CommonProcessors
+import com.intellij.util.Processor
+import gnu.trove.THashSet
+import gnu.trove.TObjectHashingStrategy
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
+import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import java.awt.Font
 import java.io.File
 
 abstract class AbstractSlicerTest : KotlinLightCodeInsightFixtureTestCase() {
-    protected class SliceTreeStructure(private val rootNode: SliceNode) : AbstractTreeStructureBase(rootNode.project) {
+    object SliceUsageHashingStrategy : TObjectHashingStrategy<KotlinSliceUsage> {
-        override fun getProviders(): List<TreeStructureProvider>? = emptyList()
+        override fun computeHashCode(`object`: KotlinSliceUsage): Int {
-
+            return `object`.usageInfo.hashCode() * 31 + `object`.forcedExpressionMode.hashCode()
-        override fun getRootElement() = rootNode
-
-        override fun commit() {
-
         }
 
-        override fun hasSomethingToCommit() = false
+        override fun equals(o1: KotlinSliceUsage, o2: KotlinSliceUsage): Boolean {
+            return o1.usageInfo == o2.usageInfo && o1.forcedExpressionMode == o2.forcedExpressionMode
+        }
     }
 
-    companion object {
+    // Based on SliceUsage.processChildren
-        private val SliceNode.sortedChildren : List<SliceNode>
+    private fun KotlinSliceUsage.processChildrenWithoutProgress(processor: (KotlinSliceUsage) -> Unit) {
-            get() = children.sortedBy { it.value.element?.startOffset ?: -1 }
+        if (this is KotlinSliceDereferenceUsage) return
+
+        val element = runReadAction { element }
+
+        @Suppress("UNCHECKED_CAST")
+        val uniqueProcessor = CommonProcessors.UniqueProcessor(
+                {
+                    processor(it as KotlinSliceUsage)
+                    true
+                },
+                SliceUsageHashingStrategy
+        ) as Processor<SliceUsage>
+
+        runReadAction {
+            if (params.dataFlowToThis) {
+                processUsagesFlownDownTo(element, uniqueProcessor)
+            }
+            else {
+                processUsagesFlownFromThe(element, uniqueProcessor)
+            }
+        }
+    }
+
+    private fun buildTreeRepresentation(rootUsage: KotlinSliceUsage): String {
+        val visitedUsages = THashSet<KotlinSliceUsage>(SliceUsageHashingStrategy)
 
-        @JvmStatic
-        protected fun buildTreeRepresentation(rootNode: SliceNode): String {
         fun TextChunk.render(): String {
             var text = text
             if (attributes.fontType == Font.BOLD) {
@@ -60,19 +80,10 @@ abstract class AbstractSlicerTest : KotlinLightCodeInsightFixtureTestCase() {
             return text
         }
 
-            fun process(node: SliceNode, indent: Int): String {
+        fun process(usage: KotlinSliceUsage, indent: Int): String {
-                val usage = node.element!!.value as KotlinSliceUsage
+            val isDuplicated = !visitedUsages.add(usage)
-
-                node.calculateDupNode()
-                val isDuplicated = node.duplicate != null
 
             return buildString {
-                    when {
-                        node is SliceRootNode && usage.element is KtFile -> {
-                            node.sortedChildren.forEach { append(process(it, indent)) }
-                            return@buildString
-                        }
-                        else -> {
                 val chunks = usage.text
                 append(chunks.first().render() + " ")
                 append("\t".repeat(indent))
@@ -86,20 +97,16 @@ abstract class AbstractSlicerTest : KotlinLightCodeInsightFixtureTestCase() {
                         prefix = if (isDuplicated) "DUPLICATE: " else "",
                         postfix = "\n"
                 ) { it.render() }
-                        }
-                    }
-
                 if (!isDuplicated) {
-                        node.sortedChildren.forEach { append(process(it, indent + 1)) }
+                    usage.processChildrenWithoutProgress {
+                        append(process(it, indent + 1))
+                    }
                 }
             }.replace(Regex("</bold><bold>"), "")
         }
 
-            return process(rootNode, 0)
+        return process(rootUsage, 0)
     }
-    }
-
-    protected abstract fun doTest(path: String, sliceProvider: KotlinSliceProvider, rootNode: SliceRootNode)
 
     protected fun doTest(path: String) {
         val mainFile = File(path)
@@ -129,7 +136,6 @@ abstract class AbstractSlicerTest : KotlinLightCodeInsightFixtureTestCase() {
         val sliceProvider = KotlinSliceProvider()
         val expression = sliceProvider.getExpressionAtCaret(elementAtCaret, analysisParams.dataFlowToThis)!!
         val rootUsage = sliceProvider.createRootUsage(expression, analysisParams)
-        val rootNode = SliceRootNode(project, DuplicateMap(), rootUsage)
+        KotlinTestUtils.assertEqualsToFile(File(path.replace(".kt", ".results.txt")), buildTreeRepresentation(rootUsage))
-        doTest(path, sliceProvider, rootNode)
     }
 }