Use ConcurrentHashMap in SymbolIndex

Author: fwcd

server/src/main/kotlin/org/javacs/kt/completion/Completions.kt

@@ -82,11 +82,7 @@ private fun keywordCompletionItems(partial: String): Sequence<CompletionItem> =
 /** Finds completions based on the element around the user's cursor. */
 private fun elementCompletionItems(file: CompiledFile, cursor: Int, index: SymbolIndex, config: CompletionConfiguration, partial: String): Sequence<CompletionItem> {
     val surroundingElement = completableElement(file, cursor) ?: return emptySequence()
-    var completions = elementCompletions(file, cursor, surroundingElement)
-
-    index.withGlobalDescriptors {
-        completions += it // TODO: Filter non-imported (i.e. the elementCompletions already found) and auto-import these when selected by the user
-    }
+    val completions = elementCompletions(file, cursor, surroundingElement) + index.globalDescriptors.values // TODO: Filter non-imported (i.e. the elementCompletions already found) and auto-import these when selected by the user
 
     val matchesName = completions.filter { containsCharactersInOrder(name(it), partial, caseSensitive = false) }
     val sorted = matchesName.takeIf { partial.length >= MIN_SORT_LENGTH }?.sortedBy { stringDistance(name(it), partial) }

server/src/main/kotlin/org/javacs/kt/index/SymbolIndex.kt

@@ -4,34 +4,32 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
+import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.name.FqName
 import org.javacs.kt.compiler.Compiler
 import org.javacs.kt.LOG
+import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
 
 /**
  * A global view of all available symbols across all packages.
  */
 class SymbolIndex {
-    private val globalDescriptors: MutableSet<DeclarationDescriptor> = mutableSetOf()
-    private val lock = ReentrantLock()
+    val globalDescriptors = ConcurrentHashMap<FqName, DeclarationDescriptor>()
 
     fun update(module: ModuleDescriptor) {
         val started = System.currentTimeMillis()
         LOG.info("Updating symbol index...")
 
-        val foundDescriptors = allDescriptors(module)
-        lock.withLock {
-            globalDescriptors += foundDescriptors
+        for (descriptor in allDescriptors(module)) {
+            globalDescriptors[descriptor.fqNameSafe] = descriptor
         }
 
         val finished = System.currentTimeMillis()
         LOG.info("Updated symbol index in ${finished - started} ms! (${globalDescriptors.size} symbol(s))")
     }
 
-    fun <T> withGlobalDescriptors(action: (Set<DeclarationDescriptor>) -> T): T = lock.withLock { action(globalDescriptors) }
-
     private fun allDescriptors(module: ModuleDescriptor): Collection<DeclarationDescriptor> = allPackages(module)
         .map(module::getPackage)
         .flatMap {