[workspace model] IJPL-345 Make VirtualFileUrlManager as a part of WorkspaceModel interface

It'll help us to avoid guessing when we need to use the global or project `VirtualFileUrlManager`

GitOrigin-RevId: 93a8a62634d3b3b284b85c3ca1187403fefc90cc

java/compiler/impl/src/com/intellij/packaging/impl/artifacts/workspacemodel/ArtifactBridge.kt

@@ -25,9 +25,7 @@ import com.intellij.platform.diagnostic.telemetry.helpers.addMeasuredTimeMillis
 import com.intellij.platform.workspace.jps.JpsImportedEntitySource
 import com.intellij.platform.workspace.storage.*
 import com.intellij.platform.workspace.storage.impl.VersionedEntityStorageOnBuilder
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.util.EventDispatcher
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.toExternalSource
 import io.opentelemetry.api.metrics.Meter
 import org.jetbrains.annotations.NonNls
@@ -174,7 +172,9 @@ open class ArtifactBridge(
   }
 
   override fun setOutputPath(outputPath: String?) {
-    val outputUrl = outputPath?.let { VirtualFileUrlManager.getInstance(project).getOrCreateFromUri(VfsUtilCore.pathToUrl(it)) }
+    val outputUrl = outputPath?.let {
+      WorkspaceModel.getInstance(project).getVirtualFileUrlManager().getOrCreateFromUri(VfsUtilCore.pathToUrl(it))
+    }
     val entity = diff.get(artifactId)
     diff.modifyEntity(entity) {
       this.outputUrl = outputUrl

java/compiler/impl/src/com/intellij/packaging/impl/artifacts/workspacemodel/ArtifactModifiableModelBridge.kt

@@ -26,13 +26,11 @@ import com.intellij.platform.workspace.storage.MutableEntityStorage
 import com.intellij.platform.workspace.storage.impl.VersionedEntityStorageOnBuilder
 import com.intellij.platform.workspace.storage.instrumentation.EntityStorageInstrumentationApi
 import com.intellij.platform.workspace.storage.instrumentation.MutableEntityStorageInstrumentation
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.util.EventDispatcher
 import com.intellij.util.concurrency.annotations.RequiresWriteLock
 import com.intellij.util.containers.BidirectionalMap
 import com.intellij.util.containers.mapInPlace
 import com.intellij.util.text.UniqueNameGenerator
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.impl.LegacyBridgeJpsEntitySourceFactory
 import io.opentelemetry.api.metrics.Meter
 import java.util.concurrent.atomic.AtomicLong
@@ -130,7 +128,7 @@ class ArtifactModifiableModelBridge(
 
     val outputPath = ArtifactUtil.getDefaultArtifactOutputPath(uniqueName, project)
 
-    val fileManager = VirtualFileUrlManager.getInstance(project)
+    val fileManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
 
     val source = LegacyBridgeJpsEntitySourceFactory.createEntitySourceForArtifact(project, externalSource)
 

java/compiler/tests/com/intellij/compiler/artifacts/workspaceModel/ArtifactTest.kt

@@ -35,12 +35,10 @@ import com.intellij.platform.workspace.jps.entities.LibraryId
 import com.intellij.platform.workspace.jps.entities.LibraryTableId
 import com.intellij.platform.workspace.jps.entities.ModuleId
 import com.intellij.platform.workspace.storage.EntitySource
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.testFramework.JUnit38AssumeSupportRunner
 import com.intellij.testFramework.workspaceModel.updateProjectModel
 import com.intellij.util.ConcurrencyUtil
 import com.intellij.util.concurrency.AppExecutorUtil
-import com.intellij.workspaceModel.ide.getInstance
 import junit.framework.TestCase
 import org.junit.runner.RunWith
 import java.util.concurrent.Callable
@@ -138,11 +136,12 @@ class ArtifactTest : ArtifactsTestCase() {
     val file2 = createTempFile("file2.txt", null)
     addArtifact("a", TestPackagingElementBuilder.root(project).file(file1.systemIndependentPath).build())
     runWriteAction {
-      WorkspaceModel.getInstance(project).updateProjectModel { builder ->
+      val workspaceModel = WorkspaceModel.getInstance(project)
+      workspaceModel.updateProjectModel { builder ->
         val artifactEntity = builder.entities(ArtifactEntity::class.java).single()
         val elementEntity = artifactEntity.rootElement!!.children.single() as FileCopyPackagingElementEntity
         builder.modifyEntity(FileCopyPackagingElementEntity.Builder::class.java, elementEntity) {
-          filePath = VirtualFileUrlManager.getInstance(project).getOrCreateFromUri(VfsUtilCore.pathToUrl(file2.systemIndependentPath))
+          filePath = workspaceModel.getVirtualFileUrlManager().getOrCreateFromUri(VfsUtilCore.pathToUrl(file2.systemIndependentPath))
         }
       }
     }

java/compiler/tests/com/intellij/compiler/artifacts/workspaceModel/ArtifactWatchRootsTest.kt

@@ -16,7 +16,6 @@ import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.workspace.storage.EntitySource
 import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.testFramework.workspaceModel.updateProjectModel
-import com.intellij.workspaceModel.ide.getInstance
 import java.nio.file.Files
 import java.nio.file.Path
 
@@ -30,11 +29,12 @@ class ArtifactWatchRootsTest : ArtifactsTestCase() {
       testRoot.createChildDirectory(Any(), "source").createChildData(Any(), "JustAFile")
     }
 
-    val virtualFileUrlManager = VirtualFileUrlManager.getInstance(project)
+    val workspaceModel = WorkspaceModel.getInstance(project)
+    val virtualFileUrlManager = workspaceModel.getVirtualFileUrlManager()
     val outputVirtualUrl = virtualFileUrlManager.getOrCreateFromUri(VfsUtilCore.pathToUrl(outputDir.path))
     val fileVirtualUrl = virtualFileUrlManager.getOrCreateFromUri(VfsUtilCore.pathToUrl(file.path))
     runWriteAction {
-      WorkspaceModel.getInstance(project).updateProjectModel {
+      workspaceModel.updateProjectModel {
         val fileCopy = it addEntity FileCopyPackagingElementEntity(fileVirtualUrl, MySource)
         val rootElement = it addEntity ArtifactRootElementEntity(MySource) {
           children = listOf(fileCopy)
@@ -50,7 +50,7 @@ class ArtifactWatchRootsTest : ArtifactsTestCase() {
       file.rename(this, "AnotherName")
     }
 
-    val artifactEntity = WorkspaceModel.getInstance(project).currentSnapshot.entities(ArtifactEntity::class.java).single()
+    val artifactEntity = workspaceModel.currentSnapshot.entities(ArtifactEntity::class.java).single()
     val copyElement = artifactEntity.rootElement!!.children.single() as FileCopyPackagingElementEntity
     assertEquals("AnotherName", copyElement.filePath.fileName)
   }

java/idea-ui/src/com/intellij/codeInsight/daemon/impl/IdeaLibDependencyNotifier.kt

@@ -23,9 +23,7 @@ import com.intellij.platform.workspace.jps.entities.LibraryEntity
 import com.intellij.platform.workspace.jps.entities.LibraryPropertiesEntity
 import com.intellij.platform.workspace.jps.entities.LibraryRoot
 import com.intellij.platform.workspace.jps.entities.LibraryRootTypeId
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.workspaceModel.ide.JpsProjectLoadingManager
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.toPath
 import org.jetbrains.idea.maven.aether.ArtifactKind
 import org.jetbrains.jps.model.library.JpsMavenRepositoryLibraryDescriptor
@@ -143,7 +141,8 @@ private fun convertToRepositoryLibraryAction(
     val newLibraryConfig = JarRepositoryManager.resolveAndDownload(project, artifact, setOf(ArtifactKind.ARTIFACT), null, null)
 
     WriteAction.run<Nothing> {
-      WorkspaceModel.getInstance(project).updateProjectModel("Converting library '${library.name}' to repository type") { builder ->
+      val workspaceModel = WorkspaceModel.getInstance(project)
+      workspaceModel.updateProjectModel("Converting library '${library.name}' to repository type") { builder ->
         val libraryEditor = NewLibraryEditor()
         newLibraryConfig?.addRoots(libraryEditor)
 
@@ -152,7 +151,7 @@ private fun convertToRepositoryLibraryAction(
             propertiesXmlTag = """<properties maven-id="${artifact.mavenId}" />"""
           }
 
-          val urlManager = VirtualFileUrlManager.getInstance(project)
+          val urlManager = workspaceModel.getVirtualFileUrlManager()
           libraryEditor.getUrls(OrderRootType.CLASSES)
             .asSequence()
             .map { urlString -> urlManager.getOrCreateFromUri(urlString) }

java/idea-ui/src/com/intellij/jarRepository/ExternalAnnotationsRepositoryResolver.kt

@@ -13,15 +13,14 @@ import com.intellij.openapi.roots.libraries.Library
 import com.intellij.openapi.roots.libraries.ui.OrderRoot
 import com.intellij.openapi.roots.ui.configuration.libraryEditor.ExistingLibraryEditor
 import com.intellij.openapi.util.Disposer
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.backend.workspace.toVirtualFileUrl
 import com.intellij.platform.workspace.jps.entities.LibraryEntity
 import com.intellij.platform.workspace.jps.entities.LibraryRoot
 import com.intellij.platform.workspace.jps.entities.LibraryRootTypeId
 import com.intellij.platform.workspace.jps.entities.modifyEntity
 import com.intellij.platform.workspace.storage.MutableEntityStorage
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.util.concurrency.annotations.RequiresEdt
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.impl.legacyBridge.library.LibraryBridge
 import com.intellij.workspaceModel.ide.impl.legacyBridge.library.ProjectLibraryTableBridgeImpl.Companion.findLibraryEntity
 import org.jetbrains.concurrency.AsyncPromise
@@ -93,7 +92,7 @@ class ExternalAnnotationsRepositoryResolver : ExternalAnnotationsArtifactsResolv
     LOG.debug("Found ${newRoots.size} external annotations for ${library.name}")
 
     val libraryEntity: LibraryEntity = diff.findLibraryEntity(library) ?: return true
-    val vfUrlManager = VirtualFileUrlManager.getInstance(project)
+    val vfUrlManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
     val newUrls = newRoots.map { it.file.toVirtualFileUrl(vfUrlManager) }.toHashSet()
     val toRemove = mutableListOf<LibraryRoot>()
     val annotationsRootType = LibraryRootTypeId(AnnotationOrderRootType.ANNOTATIONS_ID)

java/java-impl/src/com/intellij/workspaceModel/ide/legacyBridge/impl/java/CompilerModuleExtensionBridge.kt

@@ -8,13 +8,12 @@ import com.intellij.openapi.roots.CompilerProjectExtension
 import com.intellij.openapi.roots.ModuleExtension
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.vfs.pointers.VirtualFilePointer
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.backend.workspace.toVirtualFileUrl
 import com.intellij.platform.backend.workspace.virtualFile
 import com.intellij.platform.workspace.storage.MutableEntityStorage
 import com.intellij.platform.workspace.storage.VersionedEntityStorage
 import com.intellij.platform.workspace.storage.url.VirtualFileUrl
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.impl.legacyBridge.module.findModuleEntity
 import com.intellij.workspaceModel.ide.legacyBridge.ModuleBridge
 import com.intellij.workspaceModel.ide.legacyBridge.ModuleExtensionBridge
@@ -27,7 +26,7 @@ internal class CompilerModuleExtensionBridge(
 ) : CompilerModuleExtension(), ModuleExtensionBridge {
 
   private var changed = false
-  private val virtualFileManager = VirtualFileUrlManager.getInstance(module.project)
+  private val virtualFileManager = WorkspaceModel.getInstance(module.project).getVirtualFileUrlManager()
 
   private val javaSettings: JavaModuleSettingsEntity?
     get() = module.findModuleEntity(entityStorage.current)?.javaSettings

java/java-tests/testSrc/com/intellij/java/configurationStore/SaveFacetsTest.kt

@@ -18,14 +18,12 @@ import com.intellij.platform.workspace.jps.entities.ModuleDependencyItem
 import com.intellij.platform.workspace.jps.entities.ModuleEntity
 import com.intellij.platform.workspace.jps.entities.modifyEntity
 import com.intellij.platform.workspace.storage.EntitySource
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.testFramework.ApplicationRule
 import com.intellij.testFramework.DisposableRule
 import com.intellij.testFramework.rules.ProjectModelRule
 import com.intellij.testFramework.workspaceModel.updateProjectModel
 import com.intellij.util.io.assertMatches
 import com.intellij.util.io.directoryContentOf
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.getJpsProjectConfigLocation
 import org.jetbrains.jps.model.serialization.JpsProjectLoader
 import org.junit.Before
@@ -75,11 +73,12 @@ class SaveFacetsTest {
   @Test
   fun `facet in module with custom storage`() {
     class SampleCustomModuleSource(override val internalSource: JpsFileEntitySource) : EntitySource, CustomModuleEntitySource
-    val moduleDir = projectModel.baseProjectDir.virtualFileRoot.toVirtualFileUrl(VirtualFileUrlManager.getInstance(projectModel.project))
+    val workspaceModel = WorkspaceModel.getInstance(projectModel.project)
+    val moduleDir = projectModel.baseProjectDir.virtualFileRoot.toVirtualFileUrl(workspaceModel.getVirtualFileUrlManager())
     val source = SampleCustomModuleSource(
       JpsProjectFileEntitySource.FileInDirectory(moduleDir, getJpsProjectConfigLocation(projectModel.project)!!))
     runWriteActionAndWait {
-      WorkspaceModel.getInstance(projectModel.project).updateProjectModel {
+      workspaceModel.updateProjectModel {
         val moduleEntity = it addEntity ModuleEntity("foo", listOf(ModuleDependencyItem.ModuleSourceDependency), source)
         it addEntity ModuleCustomImlDataEntity(HashMap(mapOf(JpsProjectLoader.CLASSPATH_ATTRIBUTE to SampleCustomModuleRootsSerializer.ID)),
                                                source) {
@@ -95,7 +94,7 @@ class SaveFacetsTest {
     projectModel.baseProjectDir.root.assertMatches(directoryContentOf(configurationStoreTestDataRoot.resolve("facet-in-module-with-custom-storage")))
 
     runWriteActionAndWait {
-      WorkspaceModel.getInstance(projectModel.project).updateProjectModel {
+      workspaceModel.updateProjectModel {
         val moduleEntity = it.entities(ModuleEntity::class.java).single()
         it.modifyEntity(moduleEntity) {
           dependencies = mutableListOf(ModuleDependencyItem.ModuleSourceDependency, ModuleDependencyItem.InheritedSdkDependency)

platform/backend/workspace/src/WorkspaceModel.kt

@@ -6,6 +6,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.platform.workspace.storage.ImmutableEntityStorage
 import com.intellij.platform.workspace.storage.MutableEntityStorage
 import com.intellij.platform.workspace.storage.VersionedStorageChange
+import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import kotlinx.coroutines.flow.Flow
 import org.jetbrains.annotations.ApiStatus
 import org.jetbrains.annotations.NonNls
@@ -67,6 +68,12 @@ public interface WorkspaceModel {
   @ApiStatus.Experimental
   public suspend fun update(description: @NonNls String, updater: (MutableEntityStorage) -> Unit)
 
+  /**
+   * Returns the actual instance of VirtualFileUrlManager for URLs (in the Virtual File System format) of files that
+   * are referenced from workspace model entities.
+   */
+  public fun getVirtualFileUrlManager(): VirtualFileUrlManager
+
   public companion object {
     @JvmStatic
     public fun getInstance(project: Project): WorkspaceModel = project.service()

platform/lang-impl/src/com/intellij/ide/scratch/workspace/ScratchRootsEntityUtils.kt

@@ -5,13 +5,12 @@ import com.intellij.ide.scratch.RootType
 import com.intellij.ide.scratch.ScratchFileService
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VfsUtilCore
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
-import com.intellij.workspaceModel.ide.getInstance
+import com.intellij.platform.backend.workspace.WorkspaceModel
 
 internal fun createScratchRootsEntityForProject(project: Project): ScratchRootsEntity? {
   if (!ScratchFileService.isWorkspaceModelIntegrationEnabled()) return null
   val scratchFileService = ScratchFileService.getInstance()
-  val urlManager = VirtualFileUrlManager.getInstance(project)
+  val urlManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
   val urls = RootType.getAllRootTypes().filter { !it.isHidden }.map {
     scratchFileService.getRootPath(it)
   }.sorted().map { urlManager.getOrCreateFromUri(VfsUtilCore.pathToUrl(it)) }.toList()

platform/lang-impl/src/com/intellij/workspaceModel/ide/impl/legacyBridge/module/ModuleManagerComponentBridge.kt

@@ -13,6 +13,7 @@ import com.intellij.openapi.progress.blockingContext
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.startup.InitProjectActivity
 import com.intellij.openapi.vfs.LocalFileSystem
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.diagnostic.telemetry.impl.span
 import com.intellij.platform.workspace.jps.entities.LibraryEntity
 import com.intellij.platform.workspace.jps.entities.LibraryTableId
@@ -28,7 +29,6 @@ import com.intellij.platform.workspace.storage.VersionedEntityStorage
 import com.intellij.platform.workspace.storage.url.VirtualFileUrl
 import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.serviceContainer.ComponentManagerImpl
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.getJpsProjectConfigLocation
 import com.intellij.workspaceModel.ide.impl.jps.serialization.BaseIdeSerializationContext
 import com.intellij.workspaceModel.ide.impl.jps.serialization.CachingJpsFileContentReader
@@ -46,7 +46,7 @@ import java.nio.file.Path
 
 internal class ModuleManagerComponentBridge(private val project: Project, coroutineScope: CoroutineScope)
   : ModuleManagerBridgeImpl(project = project, coroutineScope = coroutineScope, moduleRootListenerBridge = ModuleRootListenerBridgeImpl) {
-  private val virtualFileManager: VirtualFileUrlManager = VirtualFileUrlManager.getInstance(project)
+  private val virtualFileManager: VirtualFileUrlManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
 
   internal class ModuleManagerInitProjectActivity : InitProjectActivity {
     override suspend fun run(project: Project) {

platform/lang-impl/src/com/intellij/workspaceModel/ide/impl/legacyBridge/watcher/VirtualFileUrlWatcher.kt

@@ -14,11 +14,10 @@ import com.intellij.platform.workspace.storage.MutableEntityStorage
 import com.intellij.platform.workspace.storage.WorkspaceEntity
 import com.intellij.platform.workspace.storage.url.VirtualFileUrl
 import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
-import com.intellij.workspaceModel.ide.getInstance
 import kotlin.reflect.KClass
 
 open class VirtualFileUrlWatcher(val project: Project) {
-  private val virtualFileManager = VirtualFileUrlManager.getInstance(project)
+  private val virtualFileManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
   internal var isInsideFilePointersUpdate: Boolean = false
     private set
 

platform/lang-impl/testSources/com/intellij/util/indexing/EntityIndexingServiceTestBase.java

@@ -4,6 +4,7 @@ package com.intellij.util.indexing;
 import com.intellij.openapi.application.WriteAction;
 import com.intellij.openapi.util.ThrowableComputable;
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.platform.backend.workspace.WorkspaceModel;
 import com.intellij.platform.backend.workspace.WorkspaceModelChangeListener;
 import com.intellij.platform.backend.workspace.WorkspaceModelTopics;
 import com.intellij.platform.workspace.storage.EntityChange;
@@ -15,7 +16,6 @@ import com.intellij.util.ThrowableConsumer;
 import com.intellij.util.indexing.roots.IndexableFilesIterator;
 import com.intellij.util.indexing.roots.IndexableIteratorPresentation;
 import com.intellij.util.indexing.roots.kind.IndexableSetOrigin;
-import com.intellij.workspaceModel.ide.VirtualFileUrlManagerUtil;
 import kotlin.Pair;
 import org.jetbrains.annotations.NotNull;
 
@@ -29,7 +29,7 @@ public abstract class EntityIndexingServiceTestBase extends HeavyPlatformTestCas
   @Override
   protected void setUp() throws Exception {
     super.setUp();
-    fileUrlManager = VirtualFileUrlManagerUtil.getInstance(VirtualFileUrlManager.Companion, myProject);
+    fileUrlManager = WorkspaceModel.getInstance(myProject).getVirtualFileUrlManager();
   }
 
   @Override

platform/platform-impl/src/com/intellij/workspaceModel/ide/impl/WorkspaceModelCacheImpl.kt

@@ -20,8 +20,6 @@ import com.intellij.platform.workspace.storage.MutableEntityStorage
 import com.intellij.platform.workspace.storage.VersionedStorageChange
 import com.intellij.platform.workspace.storage.impl.assertConsistency
 import com.intellij.platform.workspace.storage.impl.isConsistent
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
-import com.intellij.workspaceModel.ide.getInstance
 import io.opentelemetry.api.metrics.Meter
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.BufferOverflow
@@ -55,7 +53,8 @@ class WorkspaceModelCacheImpl(private val project: Project, coroutineScope: Coro
       null
     }
 
-  private val cacheSerializer = WorkspaceModelCacheSerializer(VirtualFileUrlManager.getInstance(project), urlRelativizer)
+  private val cacheSerializer = WorkspaceModelCacheSerializer(WorkspaceModel.getInstance(project).getVirtualFileUrlManager(),
+                                                              urlRelativizer)
 
   init {
     if (enabled) {

platform/platform-impl/src/com/intellij/workspaceModel/ide/impl/jps/serialization/JpsProjectModelSynchronizer.kt

@@ -49,7 +49,6 @@ import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.project.stateStore
 import com.intellij.util.PlatformUtils.*
 import com.intellij.workspaceModel.ide.EntitiesOrphanage
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.getJpsProjectConfigLocation
 import com.intellij.workspaceModel.ide.impl.*
 import com.intellij.workspaceModel.ide.impl.legacyBridge.library.LegacyCustomLibraryEntitySource
@@ -99,7 +98,7 @@ class JpsProjectModelSynchronizer(private val project: Project) : Disposable {
   }
 
   private val incomingChanges = Collections.synchronizedList(ArrayList<JpsConfigurationFilesChange>())
-  private val virtualFileManager: VirtualFileUrlManager = VirtualFileUrlManager.getInstance(project)
+  private val virtualFileManager: VirtualFileUrlManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
   private lateinit var fileContentReader: JpsFileContentReaderWithCache
   private val serializers = AtomicReference<JpsProjectSerializers?>()
   private val sourcesToSave = Collections.synchronizedSet(HashSet<EntitySource>())

platform/platform-tests/testSrc/com/intellij/ide/impl/TrustedProjectsHeavyTestCase.kt

@@ -14,7 +14,6 @@ import com.intellij.platform.backend.workspace.toVirtualFileUrl
 import com.intellij.platform.workspace.jps.entities.ContentRootEntity
 import com.intellij.platform.workspace.jps.entities.ModuleEntity
 import com.intellij.platform.workspace.storage.MutableEntityStorage
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.testFramework.closeOpenedProjectsIfFailAsync
 import com.intellij.testFramework.fixtures.IdeaTestFixtureFactory
 import com.intellij.testFramework.fixtures.TempDirTestFixture
@@ -23,7 +22,6 @@ import com.intellij.testFramework.junit5.TestDisposable
 import com.intellij.testFramework.utils.vfs.createDirectory
 import com.intellij.testFramework.utils.vfs.refreshAndGetVirtualDirectory
 import com.intellij.workspaceModel.ide.NonPersistentEntitySource
-import com.intellij.workspaceModel.ide.getInstance
 import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.BeforeEach
@@ -129,7 +127,7 @@ abstract class TrustedProjectsHeavyTestCase {
     moduleName: String,
     contentRoots: List<VirtualFile>
   ) {
-    val fileUrlManager = VirtualFileUrlManager.getInstance(project)
+    val fileUrlManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
     val moduleEntity = ModuleEntity(moduleName, emptyList(), NonPersistentEntitySource) {
       this.contentRoots = contentRoots.map {
         ContentRootEntity.invoke(it.toVirtualFileUrl(fileUrlManager), emptyList(), NonPersistentEntitySource)

platform/platform-tests/testSrc/com/intellij/openapi/roots/impl/ModuleRootsInProjectFileIndexTest.kt

@@ -21,7 +21,6 @@ import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.workspace.jps.entities.ContentRootEntity
 import com.intellij.platform.workspace.jps.entities.ExcludeUrlEntity
 import com.intellij.platform.workspace.jps.entities.ModuleId
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.testFramework.PsiTestUtil
 import com.intellij.testFramework.junit5.RunInEdt
 import com.intellij.testFramework.junit5.TestApplication
@@ -29,7 +28,6 @@ import com.intellij.testFramework.rules.ProjectModelExtension
 import com.intellij.testFramework.workspaceModel.updateProjectModel
 import com.intellij.util.ThreeState
 import com.intellij.workspaceModel.core.fileIndex.WorkspaceFileIndex
-import com.intellij.workspaceModel.ide.getInstance
 import org.jetbrains.jps.model.java.JavaModuleSourceRootTypes
 import org.jetbrains.jps.model.java.JavaResourceRootType
 import org.jetbrains.jps.model.java.JavaSourceRootProperties
@@ -395,9 +393,10 @@ class ModuleRootsInProjectFileIndexTest {
     val moduleUrl = moduleDir.url
     val rootUrl = "$moduleUrl/root"
     val excludedUrl = "$moduleUrl/root/excluded"
-    val urlManager = VirtualFileUrlManager.getInstance(projectModel.project)
+    val workspaceModel = WorkspaceModel.getInstance(projectModel.project)
+    val urlManager = workspaceModel.getVirtualFileUrlManager()
     runWriteActionAndWait {
-      WorkspaceModel.getInstance(projectModel.project).updateProjectModel {
+      workspaceModel.updateProjectModel {
         val module = it.resolve(ModuleId(module.name))!!
         it addEntity ContentRootEntity(urlManager.getOrCreateFromUri(rootUrl),
                                        emptyList<@NlsSafe String>(),

platform/platform-tests/testSrc/com/intellij/openapi/roots/impl/NoIteratingUnderExcludedRootsTest.kt

@@ -21,7 +21,6 @@ import com.intellij.openapi.vfs.pointers.VirtualFilePointerManager
 import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.backend.workspace.toVirtualFileUrl
 import com.intellij.platform.workspace.jps.entities.ExcludeUrlEntity
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.testFramework.PsiTestUtil
 import com.intellij.testFramework.UsefulTestCase
 import com.intellij.testFramework.VfsTestUtil
@@ -29,7 +28,6 @@ import com.intellij.testFramework.junit5.RunInEdt
 import com.intellij.testFramework.junit5.TestApplication
 import com.intellij.testFramework.rules.ProjectModelExtension
 import com.intellij.workspaceModel.ide.NonPersistentEntitySource
-import com.intellij.workspaceModel.ide.getInstance
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.extension.RegisterExtension
@@ -211,8 +209,9 @@ class NoIteratingUnderExcludedRootsTest {
 
   private fun excludeFolder(folderToExclude: VirtualFile) {
     WriteAction.run<Throwable> {
-      WorkspaceModel.getInstance(projectModel.project).updateProjectModel("exclude") {
-        val virtualFileUrlManager = VirtualFileUrlManager.getInstance(projectModel.project)
+      val workspaceModel = WorkspaceModel.getInstance(projectModel.project)
+      workspaceModel.updateProjectModel("exclude") {
+        val virtualFileUrlManager = workspaceModel.getVirtualFileUrlManager()
         it.addEntity(ExcludeUrlEntity(folderToExclude.toVirtualFileUrl(virtualFileUrlManager), NonPersistentEntitySource))
       }
     }

platform/platform-tests/testSrc/com/intellij/openapi/roots/impl/ProjectFileIndexPerformanceTest.kt

@@ -11,7 +11,6 @@ import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.backend.workspace.toVirtualFileUrl
 import com.intellij.platform.workspace.jps.entities.*
 import com.intellij.platform.workspace.storage.MutableEntityStorage
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.testFramework.LightVirtualFile
 import com.intellij.testFramework.PlatformTestUtil
 import com.intellij.testFramework.PsiTestUtil
@@ -19,7 +18,6 @@ import com.intellij.testFramework.VfsTestUtil
 import com.intellij.testFramework.junit5.TestApplication
 import com.intellij.testFramework.rules.ClassLevelProjectModelExtension
 import com.intellij.workspaceModel.ide.NonPersistentEntitySource
-import com.intellij.workspaceModel.ide.getInstance
 import org.jetbrains.jps.model.serialization.module.JpsModuleRootModelSerializer
 import org.junit.jupiter.api.AfterAll
 import org.junit.jupiter.api.Assertions.assertFalse
@@ -46,7 +44,7 @@ class ProjectFileIndexPerformanceTest {
     fun initProject() {
       runWriteActionAndWait {
         val builder = MutableEntityStorage.create()
-        val fileUrlManager = VirtualFileUrlManager.getInstance(ourProjectModel.project)
+        val fileUrlManager = WorkspaceModel.getInstance(ourProjectModel.project).getVirtualFileUrlManager()
         val fsRoot = VirtualFileManager.getInstance().findFileByUrl("temp:///")!!
         ourProjectRoot = fsRoot.subdir(ProjectFileIndexPerformanceTest::class.java.simpleName)
         val bigModuleRoot = ourProjectRoot.subdir("big")

platform/platform-tests/testSrc/com/intellij/util/indexing/IndexableFilesIndexOrigingsTestBase.kt

@@ -15,9 +15,9 @@ import com.intellij.openapi.roots.libraries.Library
 import com.intellij.openapi.util.Condition
 import com.intellij.openapi.util.EmptyRunnable
 import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.backend.workspace.toVirtualFileUrl
 import com.intellij.platform.workspace.storage.url.VirtualFileUrl
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.testFramework.*
 import com.intellij.testFramework.UsefulTestCase.assertSize
 import com.intellij.testFramework.assertions.Assertions.assertThat
@@ -28,7 +28,6 @@ import com.intellij.util.indexing.roots.LibraryIndexableFilesIteratorImpl
 import com.intellij.util.indexing.roots.SdkIndexableFilesIteratorImpl
 import com.intellij.util.indexing.roots.kind.IndexableSetOrigin
 import com.intellij.util.indexing.roots.origin.IndexingUrlRootHolder
-import com.intellij.workspaceModel.ide.getInstance
 import org.junit.Before
 import org.junit.ClassRule
 import org.junit.Rule
@@ -78,7 +77,7 @@ abstract class IndexableFilesIndexOriginsTestBase {
   protected fun createSdkOrigin(sdk: Sdk): IndexableSetOrigin = SdkIndexableFilesIteratorImpl.createIterator(sdk).origin
 
   protected fun createIndexableSetOrigin(contributor: IndexableSetContributor,
-                                       project: Project?): IndexableSetOrigin =
+                                         project: Project?): IndexableSetOrigin =
     IndexableEntityProviderMethods.createForIndexableSetContributor(contributor,
                                                                     project != null,
                                                                     project?.let { contributor.getAdditionalProjectRootsToIndex(project) }
@@ -167,5 +166,5 @@ abstract class IndexableFilesIndexOriginsTestBase {
     get() = resolveVirtualFile()
 
   private val ContentSpec.virtualFileUrl: VirtualFileUrl
-    get() = file.toVirtualFileUrl(VirtualFileUrlManager.getInstance(project))
+    get() = file.toVirtualFileUrl(WorkspaceModel.getInstance(project).getVirtualFileUrlManager())
 }

platform/platform-tests/testSrc/com/intellij/workspaceModel/core/fileIndex/CustomContentFileSetTest.kt

@@ -10,7 +10,6 @@ import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.backend.workspace.toVirtualFileUrl
 import com.intellij.platform.workspace.storage.EntityStorage
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.testFramework.junit5.TestApplication
 import com.intellij.testFramework.junit5.TestDisposable
 import com.intellij.testFramework.rules.ProjectModelExtension
@@ -19,7 +18,6 @@ import com.intellij.util.indexing.testEntities.IndexingTestEntity
 import com.intellij.workspaceModel.core.fileIndex.impl.ModuleRelatedRootData
 import com.intellij.workspaceModel.core.fileIndex.impl.WorkspaceFileIndexImpl
 import com.intellij.workspaceModel.ide.NonPersistentEntitySource
-import com.intellij.workspaceModel.ide.getInstance
 import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.BeforeEach
@@ -60,7 +58,7 @@ class CustomContentFileSetTest {
     }
 
     WorkspaceModel.getInstance(projectModel.project).update {
-      val url = root.toVirtualFileUrl(VirtualFileUrlManager.getInstance(projectModel.project))
+      val url = root.toVirtualFileUrl(WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager())
       it.addEntity(IndexingTestEntity(listOf(url), emptyList(), NonPersistentEntitySource))
     }
 

platform/platform-tests/testSrc/com/intellij/workspaceModel/core/fileIndex/CustomExternalFileSetTest.kt

@@ -9,7 +9,6 @@ import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.backend.workspace.toVirtualFileUrl
 import com.intellij.platform.workspace.storage.EntityStorage
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.psi.PsiManager
 import com.intellij.testFramework.PsiTestUtil
 import com.intellij.testFramework.junit5.TestApplication
@@ -19,7 +18,6 @@ import com.intellij.testFramework.workspaceModel.update
 import com.intellij.util.indexing.testEntities.IndexingTestEntity
 import com.intellij.workspaceModel.core.fileIndex.impl.WorkspaceFileIndexImpl
 import com.intellij.workspaceModel.ide.NonPersistentEntitySource
-import com.intellij.workspaceModel.ide.getInstance
 import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertNull
@@ -56,8 +54,9 @@ class CustomExternalFileSetTest {
     }
     
     WorkspaceModel.getInstance(projectModel.project).update {
-      val url = externalRoot.toVirtualFileUrl(VirtualFileUrlManager.getInstance(projectModel.project))
-      val excludedUrl = excludedRoot.toVirtualFileUrl(VirtualFileUrlManager.getInstance(projectModel.project))
+      val virtualFileManager = WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager()
+      val url = externalRoot.toVirtualFileUrl(virtualFileManager)
+      val excludedUrl = excludedRoot.toVirtualFileUrl(virtualFileManager)
       it.addEntity(IndexingTestEntity(listOf(url), listOf(excludedUrl), NonPersistentEntitySource))
     }
 

platform/platform-tests/testSrc/com/intellij/workspaceModel/core/fileIndex/CustomKindFileSetTest.kt

@@ -10,7 +10,6 @@ import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.backend.workspace.toVirtualFileUrl
 import com.intellij.platform.workspace.storage.EntityStorage
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.testFramework.junit5.TestApplication
 import com.intellij.testFramework.junit5.TestDisposable
 import com.intellij.testFramework.rules.ProjectModelExtension
@@ -18,7 +17,6 @@ import com.intellij.testFramework.workspaceModel.update
 import com.intellij.util.indexing.testEntities.IndexingTestEntity
 import com.intellij.workspaceModel.core.fileIndex.impl.WorkspaceFileIndexImpl
 import com.intellij.workspaceModel.ide.NonPersistentEntitySource
-import com.intellij.workspaceModel.ide.getInstance
 import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.BeforeEach
@@ -59,8 +57,9 @@ class CustomKindFileSetTest {
       assertIteratedContent(projectModel.project, mustNotContain = listOf(root, file))
     }
 
-    WorkspaceModel.getInstance(projectModel.project).update {
-      val url = root.toVirtualFileUrl(VirtualFileUrlManager.getInstance(projectModel.project))
+    val workspaceModel = WorkspaceModel.getInstance(projectModel.project)
+    workspaceModel.update {
+      val url = root.toVirtualFileUrl(workspaceModel.getVirtualFileUrlManager())
       it.addEntity(IndexingTestEntity(listOf(url), emptyList(), NonPersistentEntitySource))
     }
 
@@ -77,7 +76,7 @@ class CustomKindFileSetTest {
       assertEquals(WorkspaceFileKind.CUSTOM, fileSet!!.kind)
     }
 
-    WorkspaceModel.getInstance(projectModel.project).update {
+    workspaceModel.update {
       it.removeEntity(it.entities(IndexingTestEntity::class.java).single())
     }
 

platform/projectModel-impl/src/com/intellij/workspaceModel/core/fileIndex/impl/NonExistingWorkspaceRootsRegistry.kt

@@ -14,17 +14,16 @@ import com.intellij.platform.workspace.storage.EntityStorage
 import com.intellij.platform.workspace.storage.WorkspaceEntity
 import com.intellij.platform.workspace.storage.impl.indices.VirtualFileIndex
 import com.intellij.platform.workspace.storage.url.VirtualFileUrl
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.util.containers.MultiMap
 import com.intellij.util.io.URLUtil
 import com.intellij.workspaceModel.core.fileIndex.EntityStorageKind
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.impl.legacyBridge.library.LibraryBridgeImpl
 import com.intellij.workspaceModel.ide.impl.legacyBridge.library.ProjectLibraryTableBridgeImpl.Companion.libraryMap
 import java.util.*
 
 internal class NonExistingWorkspaceRootsRegistry(private val project: Project, private val indexData: WorkspaceFileIndexDataImpl) {
-  private val virtualFileManager = VirtualFileUrlManager.getInstance(project)
+  private val virtualFileManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
+
   /** access guarded by the global read/write locks; todo: replace by MostlySingularMultiMap to reduce memory usage  */
   private val nonExistingFiles = MultiMap.create<VirtualFileUrl, NonExistingFileSetData>()
   

platform/projectModel-impl/src/com/intellij/workspaceModel/core/fileIndex/impl/NonIncrementalContributors.kt

@@ -11,18 +11,17 @@ import com.intellij.openapi.roots.OrderRootType
 import com.intellij.openapi.roots.impl.DirectoryIndexExcludePolicy
 import com.intellij.openapi.roots.impl.RootFileSupplier
 import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.workspace.storage.EntityPointer
 import com.intellij.platform.workspace.storage.EntityStorage
 import com.intellij.platform.workspace.storage.WorkspaceEntity
 import com.intellij.platform.workspace.storage.url.VirtualFileUrl
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.util.asSafely
 import com.intellij.util.concurrency.annotations.RequiresWriteLock
 import com.intellij.workspaceModel.core.fileIndex.EntityStorageKind
 import com.intellij.workspaceModel.core.fileIndex.WorkspaceFileKind
 import com.intellij.workspaceModel.core.fileIndex.WorkspaceFileSet
 import com.intellij.workspaceModel.core.fileIndex.WorkspaceFileSetData
-import com.intellij.workspaceModel.ide.getInstance
 import it.unimi.dsi.fastutil.objects.Object2IntMap
 import it.unimi.dsi.fastutil.objects.Object2IntMaps
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap
@@ -91,7 +90,7 @@ internal class NonIncrementalContributors(private val project: Project,
   }
   
   private fun computeCustomExcludedRoots(): Pair<Object2IntMap<VirtualFile>, Set<VirtualFileUrl>> {
-    val virtualFileUrlManager = VirtualFileUrlManager.getInstance(project)
+    val virtualFileUrlManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
     val excludedFiles = Object2IntOpenHashMap<VirtualFile>()
     val excludedUrls = HashSet<VirtualFileUrl>()
 

platform/projectModel-impl/src/com/intellij/workspaceModel/core/fileIndex/impl/WorkspaceFileIndexImpl.kt

@@ -18,9 +18,9 @@ import com.intellij.openapi.util.LowMemoryWatcher
 import com.intellij.openapi.vfs.*
 import com.intellij.openapi.vfs.newvfs.BulkFileListener
 import com.intellij.openapi.vfs.newvfs.events.VFileEvent
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.backend.workspace.virtualFile
 import com.intellij.platform.workspace.storage.impl.url.VirtualFileUrlManagerImpl
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.util.PathUtil
 import com.intellij.util.Query
@@ -31,7 +31,6 @@ import com.intellij.workspaceModel.core.fileIndex.WorkspaceFileSet
 import com.intellij.workspaceModel.core.fileIndex.WorkspaceFileSetData
 import com.intellij.workspaceModel.core.fileIndex.WorkspaceFileSetWithCustomData
 import com.intellij.workspaceModel.core.fileIndex.impl.WorkspaceFileInternalInfo.NonWorkspace
-import com.intellij.workspaceModel.ide.getInstance
 
 class WorkspaceFileIndexImpl(private val project: Project) : WorkspaceFileIndexEx, Disposable.Default {
   companion object {
@@ -82,7 +81,7 @@ class WorkspaceFileIndexImpl(private val project: Project) : WorkspaceFileIndexE
   override fun isUrlInContent(url: String): ThreeState {
     var currentUrl = url
     val fileManager = VirtualFileManager.getInstance()
-    val urlManager = VirtualFileUrlManager.getInstance(project)
+    val urlManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
     while (currentUrl.isNotEmpty()) {
       val file = fileManager.findFileByUrl(currentUrl)
       if (file != null) {
@@ -173,7 +172,7 @@ class WorkspaceFileIndexImpl(private val project: Project) : WorkspaceFileIndexE
     
     /* there may be other file sets under this directory; their URLs must be registered in VirtualFileUrlManager,
        so it's enough to process VirtualFileUrls only. */
-    val virtualFileUrlManager = VirtualFileUrlManager.getInstance(project) as VirtualFileUrlManagerImpl
+    val virtualFileUrlManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager() as VirtualFileUrlManagerImpl
     val virtualFileUrl = virtualFileUrlManager.findByUri(dir.url) ?: return VirtualFileVisitor.SKIP_CHILDREN
     val processed = virtualFileUrlManager.processChildrenRecursively(virtualFileUrl) { childUrl ->
       val childFile = childUrl.virtualFile ?: return@processChildrenRecursively TreeNodeProcessingResult.SKIP_CHILDREN

platform/projectModel-impl/src/com/intellij/workspaceModel/ide/JpsProjectConfigLocationUtil.kt

@@ -3,9 +3,9 @@ package com.intellij.workspaceModel.ide
 
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VfsUtilCore
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.workspace.jps.JpsProjectConfigLocation
 import com.intellij.platform.workspace.storage.impl.url.toVirtualFileUrl
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.project.isDirectoryBased
 import com.intellij.project.stateStore
 
@@ -13,9 +13,9 @@ import com.intellij.project.stateStore
  * Returns `null` for the default project
  */
 fun getJpsProjectConfigLocation(project: Project): JpsProjectConfigLocation? {
+  val virtualFileUrlManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
   return if (project.isDirectoryBased) {
     project.basePath?.let {
-      val virtualFileUrlManager = VirtualFileUrlManager.getInstance(project)
       val ideaFolder = project.stateStore.directoryStorePath!!.toVirtualFileUrl(virtualFileUrlManager)
       val baseUrl = VfsUtilCore.pathToUrl(it)
       JpsProjectConfigLocation.DirectoryBased(virtualFileUrlManager.getOrCreateFromUri(baseUrl), ideaFolder)
@@ -23,7 +23,6 @@ fun getJpsProjectConfigLocation(project: Project): JpsProjectConfigLocation? {
   }
   else {
     project.projectFilePath?.let {
-      val virtualFileUrlManager = VirtualFileUrlManager.getInstance(project)
       val projectFileUrl = VfsUtilCore.pathToUrl(it)
       val iprFile = virtualFileUrlManager.getOrCreateFromUri(projectFileUrl)
       JpsProjectConfigLocation.FileBased(iprFile, iprFile.parent!!)

platform/projectModel-impl/src/com/intellij/workspaceModel/ide/VirtualFileUrlManagerUtil.kt

@@ -5,7 +5,6 @@ package com.intellij.workspaceModel.ide
 
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.components.service
-import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.platform.workspace.storage.url.VirtualFileUrl
 import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
@@ -14,10 +13,10 @@ import org.jetbrains.jps.util.JpsPathUtil
 import java.nio.file.Path
 
 /**
- * Returns instance of [VirtualFileUrlManager] which should be used to create [VirtualFileUrl] instances to be stored in 
+ * Returns instance of [VirtualFileUrlManager] which should be used to create [VirtualFileUrl] instances to be stored in
  * [WorkspaceModel][com.intellij.platform.backend.workspace.WorkspaceModel] entities.
  */
-fun VirtualFileUrlManager.Companion.getInstance(project: Project): VirtualFileUrlManager = project.service()
+//fun VirtualFileUrlManager.Companion.getInstance(project: Project): VirtualFileUrlManager = project.service()
 
 /**
  * Returns instance of [VirtualFileUrlManager] which should be used to create [VirtualFileUrl] instances to be stored in entities added in

platform/projectModel-impl/src/com/intellij/workspaceModel/ide/impl/GlobalWorkspaceModel.kt

@@ -27,7 +27,6 @@ import com.intellij.util.concurrency.ThreadingAssertions
 import com.intellij.util.concurrency.annotations.RequiresWriteLock
 import com.intellij.workspaceModel.ide.JpsGlobalModelSynchronizer
 import com.intellij.workspaceModel.ide.getGlobalInstance
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.impl.legacyBridge.library.LegacyCustomLibraryEntitySource
 import com.intellij.workspaceModel.ide.impl.legacyBridge.library.ProjectLibraryTableBridgeImpl.Companion.libraryMap
 import com.intellij.workspaceModel.ide.impl.legacyBridge.library.ProjectLibraryTableBridgeImpl.Companion.mutableLibraryMap
@@ -187,7 +186,7 @@ class GlobalWorkspaceModel : Disposable {
 
     val workspaceModel = WorkspaceModel.getInstance(targetProject)
     val entitiesCopyAtBuilder = copyEntitiesToEmptyStorage(entityStorage.current,
-                                                           VirtualFileUrlManager.getInstance(targetProject))
+                                                           workspaceModel.getVirtualFileUrlManager())
     workspaceModel.updateProjectModel("Sync global entities with project: ${targetProject.name}") { builder ->
       builder.replaceBySource(globalEntitiesFilter, entitiesCopyAtBuilder)
     }
@@ -197,7 +196,8 @@ class GlobalWorkspaceModel : Disposable {
                                  targetBuilder: MutableEntityStorage) = applyStateToProjectBuilderTimeMs.addMeasuredTimeMillis {
     LOG.info("Sync global entities with mutable entity storage")
     targetBuilder.replaceBySource(globalEntitiesFilter,
-                                  copyEntitiesToEmptyStorage(entityStorage.current, VirtualFileUrlManager.getInstance(project)))
+                                  copyEntitiesToEmptyStorage(entityStorage.current,
+                                                             WorkspaceModel.getInstance(project).getVirtualFileUrlManager()))
   }
 
   @RequiresWriteLock

platform/projectModel-impl/src/com/intellij/workspaceModel/ide/impl/VirtualFileUrlsLazyInitializer.kt

@@ -4,14 +4,15 @@ package com.intellij.workspaceModel.ide.impl
 import com.intellij.openapi.progress.blockingContext
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.startup.ProjectActivity
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
-import com.intellij.workspaceModel.ide.getInstance
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 
-internal class VirtualFileUrlsLazyInitializer: ProjectActivity {
+internal class VirtualFileUrlsLazyInitializer : ProjectActivity {
   override suspend fun execute(project: Project) {
-    val urls = (VirtualFileUrlManager.getInstance(project) as? IdeVirtualFileUrlManagerImpl)?.getCachedVirtualFileUrls() ?: return
+    val workspaceModel = WorkspaceModel.getInstance(project)
+    val urls = (workspaceModel.getVirtualFileUrlManager() as? IdeVirtualFileUrlManagerImpl)?.getCachedVirtualFileUrls()
+               ?: return
     withContext(Dispatchers.IO) {
       blockingContext {
         urls.forEach { (it as? VirtualFileUrlBridge)?.isValid }

platform/projectModel-impl/src/com/intellij/workspaceModel/ide/impl/WorkspaceModelImpl.kt

@@ -20,6 +20,7 @@ import com.intellij.platform.workspace.storage.impl.VersionedEntityStorageImpl
 import com.intellij.platform.workspace.storage.impl.assertConsistency
 import com.intellij.platform.workspace.storage.instrumentation.EntityStorageInstrumentationApi
 import com.intellij.platform.workspace.storage.instrumentation.MutableEntityStorageInstrumentation
+import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.serviceContainer.AlreadyDisposedException
 import com.intellij.workspaceModel.core.fileIndex.EntityStorageKind
 import com.intellij.workspaceModel.core.fileIndex.WorkspaceFileIndex
@@ -45,6 +46,8 @@ open class WorkspaceModelImpl(private val project: Project, private val cs: Coro
   final override val entityStorage: VersionedEntityStorageImpl
   private val unloadedEntitiesStorage: VersionedEntityStorageImpl
 
+  private val virtualFileManager: VirtualFileUrlManager = IdeVirtualFileUrlManagerImpl()
+
   private val updatesFlow = MutableSharedFlow<VersionedStorageChange>()
 
   /**
@@ -115,6 +118,8 @@ open class WorkspaceModelImpl(private val project: Project, private val cs: Coro
   override val currentSnapshotOfUnloadedEntities: ImmutableEntityStorage
     get() = unloadedEntitiesStorage.current
 
+  override fun getVirtualFileUrlManager(): VirtualFileUrlManager = virtualFileManager
+
   /**
    * Used only in Rider IDE
    */

platform/projectModel-impl/src/com/intellij/workspaceModel/ide/impl/legacyBridge/library/LibraryBridgeImpl.kt

@@ -30,7 +30,6 @@ import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.util.EventDispatcher
 import com.intellij.util.containers.ConcurrentFactoryMap
 import com.intellij.workspaceModel.ide.getGlobalInstance
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.impl.GlobalWorkspaceModel
 import com.intellij.workspaceModel.ide.impl.legacyBridge.library.ProjectLibraryTableBridgeImpl.Companion.findLibraryEntity
 import com.intellij.workspaceModel.ide.impl.legacyBridge.library.ProjectLibraryTableBridgeImpl.Companion.libraryMap
@@ -112,7 +111,10 @@ class LibraryBridgeImpl(
   }
 
   override fun getModifiableModel(builder: MutableEntityStorage): LibraryEx.ModifiableModelEx {
-    val virtualFileUrlManager = if (project == null) VirtualFileUrlManager.getGlobalInstance() else VirtualFileUrlManager.getInstance(project)
+    val virtualFileUrlManager = if (project == null)
+      VirtualFileUrlManager.getGlobalInstance()
+    else
+      WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
     return LibraryModifiableModelBridgeImpl(this, librarySnapshot, builder, targetBuilder, virtualFileUrlManager, false)
   }
 

platform/projectModel-impl/src/com/intellij/workspaceModel/ide/impl/legacyBridge/module/ModifiableModuleModelBridgeImpl.kt

@@ -20,13 +20,11 @@ import com.intellij.platform.workspace.jps.JpsMetrics
 import com.intellij.platform.workspace.jps.entities.*
 import com.intellij.platform.workspace.jps.serialization.impl.ModulePath
 import com.intellij.platform.workspace.storage.MutableEntityStorage
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.projectModel.ProjectModelBundle
 import com.intellij.util.PathUtil
 import com.intellij.util.containers.BidirectionalMap
 import com.intellij.util.io.systemIndependentPath
 import com.intellij.workspaceModel.ide.NonPersistentEntitySource
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.impl.LegacyBridgeJpsEntitySourceFactory
 import com.intellij.workspaceModel.ide.impl.legacyBridge.LegacyBridgeModifiableBase
 import com.intellij.workspaceModel.ide.impl.legacyBridge.module.ModuleManagerBridgeImpl.Companion.mutableModuleMap
@@ -91,7 +89,7 @@ internal class ModifiableModuleModelBridgeImpl(
     }
 
     val parentPath = PathUtil.getParentPath(canonicalPath)
-    val baseModuleDir = VirtualFileUrlManager.getInstance(project).getOrCreateFromUri(VfsUtilCore.pathToUrl(parentPath))
+    val baseModuleDir = WorkspaceModel.getInstance(project).getVirtualFileUrlManager().getOrCreateFromUri(VfsUtilCore.pathToUrl(parentPath))
     val entitySource = LegacyBridgeJpsEntitySourceFactory.createEntitySourceForModule(
       project = project,
       baseModuleDir = baseModuleDir,

platform/projectModel-impl/src/com/intellij/workspaceModel/ide/impl/legacyBridge/module/roots/ModifiableContentEntryBridge.kt

@@ -8,6 +8,7 @@ import com.intellij.openapi.diagnostic.debug
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.roots.*
 import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.backend.workspace.toVirtualFileUrl
 import com.intellij.platform.workspace.jps.entities.ContentRootEntity
 import com.intellij.platform.workspace.jps.entities.ExcludeUrlEntity
@@ -16,10 +17,8 @@ import com.intellij.platform.workspace.jps.entities.modifyEntity
 import com.intellij.platform.workspace.storage.EntitySource
 import com.intellij.platform.workspace.storage.MutableEntityStorage
 import com.intellij.platform.workspace.storage.url.VirtualFileUrl
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.psi.util.CachedValueProvider
 import com.intellij.util.CachedValueImpl
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.isEqualOrParentOf
 import org.jetbrains.jps.model.JpsElement
 import org.jetbrains.jps.model.java.JavaResourceRootProperties
@@ -37,7 +36,7 @@ internal class ModifiableContentEntryBridge(
     private val LOG = logger<ModifiableContentEntryBridge>()
   }
 
-  private val virtualFileManager = VirtualFileUrlManager.getInstance(modifiableRootModel.project)
+  private val virtualFileManager = WorkspaceModel.getInstance(modifiableRootModel.project).getVirtualFileUrlManager()
 
   private val currentContentEntry = CachedValueImpl {
     val contentEntry = modifiableRootModel.currentModel.contentEntries.firstOrNull { it.url == contentEntryUrl.url } as? ContentEntryBridge
@@ -170,7 +169,7 @@ internal class ModifiableContentEntryBridge(
     if (!excludedUrls.contains(virtualFileUrl)) return false
 
     val contentRootEntity = currentContentEntry.value.entity
-    val (new, toRemove) = contentRootEntity.excludedUrls.partition {excludedUrl -> excludedUrl.url != virtualFileUrl  }
+    val (new, toRemove) = contentRootEntity.excludedUrls.partition { excludedUrl -> excludedUrl.url != virtualFileUrl }
     updateContentEntry {
       this.excludedUrls = new
     }

platform/projectModel-impl/src/com/intellij/workspaceModel/ide/impl/legacyBridge/module/roots/ModifiableRootModelBridgeImpl.kt

@@ -34,7 +34,6 @@ import com.intellij.platform.workspace.storage.instrumentation.MutableEntityStor
 import com.intellij.platform.workspace.storage.url.VirtualFileUrl
 import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.util.ArrayUtilRt
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.impl.legacyBridge.LegacyBridgeModifiableBase
 import com.intellij.workspaceModel.ide.impl.legacyBridge.library.LibraryBridge
 import com.intellij.workspaceModel.ide.impl.legacyBridge.library.LibraryBridgeImpl
@@ -85,7 +84,7 @@ class ModifiableRootModelBridgeImpl(
 
   private val extensionsDisposable = Disposer.newDisposable()
 
-  private val virtualFileManager: VirtualFileUrlManager = VirtualFileUrlManager.getInstance(project)
+  private val virtualFileManager: VirtualFileUrlManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
 
   private val extensionsDelegate = lazy {
     RootModelBridgeImpl.loadExtensions(storage = entityStorageOnDiff, module = module, diff = diff, writable = true,

platform/projectModel-impl/src/com/intellij/workspaceModel/ide/impl/legacyBridge/module/roots/OrderRootsCacheBridge.kt

@@ -8,10 +8,9 @@ import com.intellij.openapi.roots.OrderRootType
 import com.intellij.openapi.roots.impl.OrderRootsCache
 import com.intellij.openapi.vfs.VfsUtilCore
 import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.util.ArrayUtil
 import com.intellij.util.ConcurrencyUtil
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.impl.VirtualFileUrlBridge
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ConcurrentMap
@@ -19,7 +18,7 @@ import java.util.concurrent.atomic.AtomicReference
 import java.util.function.Supplier
 
 class OrderRootsCacheBridge(val project: Project, parentDisposable: Disposable) : OrderRootsCache(parentDisposable) {
-  private val virtualFileUrlManager = VirtualFileUrlManager.getInstance(project)
+  private val virtualFileUrlManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
   private val myRootUrls = AtomicReference<ConcurrentMap<CacheKey, Array<String>>>()
   private val myRootVirtualFiles = AtomicReference<ConcurrentMap<CacheKey, Array<VirtualFile>>>()
 

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/EntitiesOrphanageTest.kt

@@ -35,7 +35,7 @@ class EntitiesOrphanageTest {
   val projectModel: ProjectModelExtension = ProjectModelExtension()
 
   private val virtualFileManager: VirtualFileUrlManager
-    get() = VirtualFileUrlManager.getInstance(projectModel.project)
+    get() = WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager()
 
   @BeforeEach
   fun setUp() {

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/FacetModelBridgeTest.kt

@@ -54,7 +54,7 @@ class FacetModelBridgeTest {
   val disposableRule = DisposableRule()
 
   private val virtualFileManager: VirtualFileUrlManager
-    get() = VirtualFileUrlManager.getInstance(projectModel.project)
+    get() = WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager()
 
   @Before
   fun registerFacetType() {

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/ImlReplaceBySourceTest.kt

@@ -3,6 +3,7 @@ package com.intellij.workspaceModel.ide
 
 import com.intellij.java.workspace.entities.JavaSourceRootPropertiesEntity
 import com.intellij.openapi.application.ex.PathManagerEx
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.workspace.jps.JpsProjectConfigLocation
 import com.intellij.platform.workspace.jps.JpsProjectFileEntitySource
 import com.intellij.platform.workspace.jps.entities.ModuleEntity
@@ -38,7 +39,7 @@ class ImlReplaceBySourceTest {
 
   @Before
   fun setUp() {
-    virtualFileManager = VirtualFileUrlManager.getInstance(projectModel.project)
+    virtualFileManager = WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager()
   }
 
   @Test

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/ImlSerializationTest.kt

@@ -2,6 +2,7 @@
 package com.intellij.workspaceModel.ide
 
 import com.intellij.openapi.application.ex.PathManagerEx
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.workspace.storage.EntitySource
 import com.intellij.platform.workspace.storage.ExternalMappingKey
 import com.intellij.platform.workspace.storage.MutableEntityStorage
@@ -32,7 +33,7 @@ class ImlSerializationTest {
 
   @Before
   fun setUp() {
-    virtualFileManager = VirtualFileUrlManager.getInstance(projectModel.project)
+    virtualFileManager = WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager()
   }
 
   @Test

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/JpsProjectLoadingListenerTest.kt

@@ -8,6 +8,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.project.ProjectManager
 import com.intellij.openapi.project.ProjectManagerListener
 import com.intellij.openapi.util.Disposer
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.workspace.storage.EntityStorageSerializer
 import com.intellij.platform.workspace.storage.impl.serialization.EntityStorageSerializerImpl
 import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
@@ -43,7 +44,7 @@ class JpsProjectLoadingListenerTest {
   @Before
   fun setUp() {
     WorkspaceModelCacheImpl.forceEnableCaching(disposableRule.disposable)
-    virtualFileManager = VirtualFileUrlManager.getInstance(projectModel.project)
+    virtualFileManager = WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager()
     serializer = EntityStorageSerializerImpl(WorkspaceModelCacheSerializer.PluginAwareEntityTypesResolver, virtualFileManager)
   }
 

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/JpsProjectUrlRelativizerTest.kt

@@ -7,6 +7,7 @@ import com.intellij.facet.mock.registerFacetType
 import com.intellij.java.workspace.entities.*
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.registry.Registry
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.workspace.jps.entities.ContentRootEntity
 import com.intellij.platform.workspace.jps.entities.ExcludeUrlEntity
 import com.intellij.platform.workspace.jps.entities.SourceRootEntity
@@ -58,7 +59,7 @@ class JpsProjectUrlRelativizerTest {
     Registry.get("ide.workspace.model.store.relative.paths.in.cache").setValue(true)
 
     WorkspaceModelCacheImpl.forceEnableCaching(disposableRule.disposable)
-    virtualFileManager = VirtualFileUrlManager.getInstance(projectModel.project)
+    virtualFileManager = WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager()
     registerFacetType(MockFacetType(), disposableRule.disposable)
     registerFacetType(AnotherMockFacetType(), disposableRule.disposable)
 

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/ModuleBridgesTest.kt

@@ -78,7 +78,7 @@ class ModuleBridgesTest {
   @Before
   fun prepareProject() {
     project = projectModel.project
-    virtualFileManager = VirtualFileUrlManager.getInstance(project)
+    virtualFileManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
   }
 
   @Test

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/ModuleTestPropertiesTest.kt

@@ -14,7 +14,6 @@ import com.intellij.workspaceModel.ide.legacyBridge.ModuleBridge
 import com.intellij.platform.workspace.jps.entities.ModuleId
 import com.intellij.platform.workspace.jps.entities.TestModulePropertiesEntity
 import com.intellij.platform.workspace.jps.entities.modifyEntity
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import org.junit.ClassRule
 import org.junit.Rule
 import org.junit.Test
@@ -71,7 +70,7 @@ class ModuleTestPropertiesTest {
 
     val projectPath = File(PathManagerEx.getCommunityHomePath(),
                            "platform/workspace/jps/tests/testData/serialization/moduleTestProperties")
-    val virtualFileUrlManager = VirtualFileUrlManager.getInstance(projectModel.project)
+    val virtualFileUrlManager = WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager()
     val storage = copyAndLoadProject(projectPath, virtualFileUrlManager).storage
 
     val mainModuleEntity = storage.resolve(ModuleId(mainModuleName))

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/ReplaceBySourceTest.kt

@@ -2,16 +2,17 @@
 package com.intellij.workspaceModel.ide
 
 import com.intellij.openapi.util.NlsSafe
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.workspace.jps.JpsFileEntitySource
 import com.intellij.platform.workspace.jps.JpsProjectFileEntitySource
 import com.intellij.platform.workspace.jps.entities.ContentRootEntity
 import com.intellij.platform.workspace.jps.entities.ModuleEntity
 import com.intellij.platform.workspace.jps.entities.SourceRootEntity
+import com.intellij.platform.workspace.storage.MutableEntityStorage
+import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.testFramework.ApplicationRule
 import com.intellij.testFramework.rules.ProjectModelRule
 import com.intellij.workspaceModel.ide.impl.jps.serialization.toConfigLocation
-import com.intellij.platform.workspace.storage.MutableEntityStorage
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import org.junit.*
 
 class ReplaceBySourceTest {
@@ -23,7 +24,7 @@ class ReplaceBySourceTest {
 
   @Before
   fun setUp() {
-    virtualFileManager = VirtualFileUrlManager.getInstance(projectModel.project)
+    virtualFileManager = WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager()
   }
 
   @Test

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/VirtualFileUrlManagerTest.kt

@@ -1,6 +1,7 @@
 // Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package com.intellij.workspaceModel.ide
 
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.testFramework.ApplicationRule
 import com.intellij.testFramework.rules.ProjectModelRule
@@ -16,7 +17,7 @@ class VirtualFileUrlManagerTest {
 
   @Before
   fun setUp() {
-    virtualFileManager = VirtualFileUrlManager.getInstance(projectModel.project)
+    virtualFileManager = WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager()
   }
 
   @Test

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/WorkspaceCacheTest.kt

@@ -7,6 +7,7 @@ import com.intellij.openapi.application.ex.PathManagerEx
 import com.intellij.openapi.module.ModuleManager
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Disposer
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.backend.workspace.WorkspaceModelCache
 import com.intellij.platform.workspace.storage.EntityStorageSerializer
 import com.intellij.platform.workspace.storage.impl.serialization.EntityStorageSerializerImpl
@@ -42,7 +43,7 @@ class WorkspaceCacheTest {
   @Before
   fun setUp() {
     WorkspaceModelCacheImpl.forceEnableCaching(disposableRule.disposable)
-    virtualFileManager = VirtualFileUrlManager.getInstance(projectModel.project)
+    virtualFileManager = WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager()
     serializer = EntityStorageSerializerImpl(WorkspaceModelCacheSerializer.PluginAwareEntityTypesResolver, virtualFileManager)
   }
 

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/WorkspaceModelBenchmarksPerformanceTest.kt

@@ -304,7 +304,7 @@ class WorkspaceModelBenchmarksPerformanceTest {
 
   @Test
   fun `10_000 orphan content roots to modules`(testInfo: TestInfo) {
-    val manager = VirtualFileUrlManager.getInstance(projectModel.project)
+    val manager = WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager()
     val newFolder = tempFolder.newRandomDirectory()
 
     PlatformTestUtil.startPerformanceTest(testInfo.displayName, 100500) {
@@ -341,7 +341,7 @@ class WorkspaceModelBenchmarksPerformanceTest {
   @Test
   fun `10_000 orphan source roots to modules`(testInfo: TestInfo) {
     val newFolder = VfsUtilCore.pathToUrl(tempFolder.newRandomDirectory().toString())
-    val manager = VirtualFileUrlManager.getInstance(projectModel.project)
+    val manager = WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager()
 
     PlatformTestUtil.startPerformanceTest(testInfo.displayName, 100500) {
       runWriteActionAndWait {
@@ -388,7 +388,7 @@ class WorkspaceModelBenchmarksPerformanceTest {
   @Test
   fun `10_000 orphan source roots to many content roots to modules`(testInfo: TestInfo) {
     val newFolder = tempFolder.newRandomDirectory()
-    val manager = VirtualFileUrlManager.getInstance(projectModel.project)
+    val manager = WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager()
 
     PlatformTestUtil.startPerformanceTest(testInfo.displayName, 100500) {
       runWriteActionAndWait {

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/WorkspaceModelPerformanceTest.kt

@@ -12,15 +12,14 @@ import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.backend.workspace.toVirtualFileUrl
 import com.intellij.platform.workspace.jps.entities.*
+import com.intellij.platform.workspace.storage.MutableEntityStorage
+import com.intellij.platform.workspace.storage.url.VirtualFileUrl
 import com.intellij.testFramework.PlatformTestUtil
 import com.intellij.testFramework.UsefulTestCase
 import com.intellij.testFramework.junit5.RunInEdt
 import com.intellij.testFramework.junit5.TestApplication
 import com.intellij.testFramework.rules.ClassLevelProjectModelExtension
 import com.intellij.testFramework.workspaceModel.updateProjectModel
-import com.intellij.platform.workspace.storage.MutableEntityStorage
-import com.intellij.platform.workspace.storage.url.VirtualFileUrl
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import org.jetbrains.jps.model.serialization.module.JpsModuleRootModelSerializer
 import org.junit.jupiter.api.*
 import org.junit.jupiter.api.Assertions.assertTrue
@@ -40,8 +39,9 @@ class WorkspaceModelPerformanceTest {
     @BeforeAll
     @JvmStatic
     fun initProject() {
+      val workspaceModel = WorkspaceModel.getInstance(ourProjectModel.project)
       val fsRoot = VirtualFileManager.getInstance().findFileByUrl("temp:///")!!.toVirtualFileUrl(
-        VirtualFileUrlManager.getInstance(ourProjectModel.project))
+        workspaceModel.getVirtualFileUrlManager())
       ourProjectRoot = fsRoot.append(WorkspaceModelPerformanceTest::class.java.simpleName)
       val builder = MutableEntityStorage.create()
       for (i in 1..100) {
@@ -77,7 +77,7 @@ class WorkspaceModelPerformanceTest {
       }
 
       runWriteActionAndWait {
-        WorkspaceModel.getInstance(ourProjectModel.project).updateProjectModel {
+        workspaceModel.updateProjectModel {
           it.applyChangesFrom(builder)
         }
       }

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/impl/jps/serialization/DelayedProjectSynchronizerTest.kt

@@ -34,7 +34,6 @@ import com.intellij.testFramework.OpenProjectTaskBuilder
 import com.intellij.testFramework.PlatformTestUtil
 import com.intellij.testFramework.rules.ProjectModelRule
 import com.intellij.testFramework.rules.TempDirectory
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.getJpsProjectConfigLocation
 import com.intellij.workspaceModel.ide.impl.JpsProjectUrlRelativizer
 import com.intellij.workspaceModel.ide.impl.WorkspaceModelCacheImpl
@@ -69,7 +68,7 @@ class DelayedProjectSynchronizerTest {
   @Before
   fun setUp() {
     WorkspaceModelCacheImpl.forceEnableCaching(disposableRule.disposable)
-    virtualFileManager = VirtualFileUrlManager.getInstance(projectModel.project)
+    virtualFileManager = WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager()
     registerFacetType(MockFacetType(), disposableRule.disposable)
     registerFacetType(AnotherMockFacetType(), disposableRule.disposable)
   }
@@ -93,11 +92,12 @@ class DelayedProjectSynchronizerTest {
   }
 
   private fun checkSerializersConsistency(project: Project) {
-    val storage = WorkspaceModel.getInstance(project).currentSnapshot
+    val workspaceModel = WorkspaceModel.getInstance(project)
+    val storage = workspaceModel.currentSnapshot
     val serializers = JpsProjectModelSynchronizer.getInstance(project).getSerializers()
-    val unloadedEntitiesStorage = WorkspaceModel.getInstance(project).internal.currentSnapshotOfUnloadedEntities
+    val unloadedEntitiesStorage = workspaceModel.internal.currentSnapshotOfUnloadedEntities
     serializers.checkConsistency(getJpsProjectConfigLocation(project)!!, storage, unloadedEntitiesStorage,
-                                 VirtualFileUrlManager.getInstance(project))
+                                 workspaceModel.getVirtualFileUrlManager())
   }
 
   @Test

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/impl/jps/serialization/JpsGlobalEntitiesSyncTest.kt

@@ -18,7 +18,6 @@ import com.intellij.testFramework.DisposableRule
 import com.intellij.testFramework.PlatformTestUtil
 import com.intellij.testFramework.UsefulTestCase
 import com.intellij.workspaceModel.ide.getGlobalInstance
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.impl.GlobalWorkspaceModel
 import com.intellij.workspaceModel.ide.impl.WorkspaceModelImpl
 import com.intellij.workspaceModel.ide.impl.legacyBridge.library.GlobalLibraryTableBridgeImpl
@@ -92,7 +91,7 @@ class JpsGlobalEntitiesSyncTest {
       // Check global entities in sync after adding entity via project storage
       ApplicationManager.getApplication().invokeAndWait {
         runWriteAction {
-          val virtualFileManager = VirtualFileUrlManager.getInstance(project)
+          val virtualFileManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
           WorkspaceModel.getInstance(project).updateProjectModel("Test update") { builder ->
             val projectSdkEntity = SdkEntity("oracle-1.8", "JavaSDK",
                                              listOf(SdkRoot(virtualFileManager.getOrCreateFromUri("/Library/Java/JavaVirtualMachines/oracle-1.8/Contents/Home!/java.base"), SdkRootTypeId("sourcePath"))),
@@ -124,7 +123,7 @@ class JpsGlobalEntitiesSyncTest {
 
     loadedProjects.forEach { loadedProject ->
       val projectWorkspaceModel = WorkspaceModel.getInstance(loadedProject)
-      val projectVirtualFileUrlManager = VirtualFileUrlManager.getInstance(loadedProject)
+      val projectVirtualFileUrlManager = projectWorkspaceModel.getVirtualFileUrlManager()
       projectWorkspaceModel as WorkspaceModelImpl
       val projectSdkEntities = projectWorkspaceModel.currentSnapshot.entities(SdkEntity::class.java).toList()
       UsefulTestCase.assertSameElements(sdkInfos, projectSdkEntities.map { SdkTestInfo(it.name, it.version!!, it.type) })
@@ -173,8 +172,9 @@ class JpsGlobalEntitiesSyncTest {
       val project = loadedProjects.first()
       ApplicationManager.getApplication().invokeAndWait {
         runWriteAction {
-          val virtualFileManager = VirtualFileUrlManager.getInstance(project)
-          WorkspaceModel.getInstance(project).updateProjectModel("Test update") { builder ->
+          val workspaceModel = WorkspaceModel.getInstance(project)
+          val virtualFileManager = workspaceModel.getVirtualFileUrlManager()
+          workspaceModel.updateProjectModel("Test update") { builder ->
             val libraryEntity = builder.entities(LibraryEntity::class.java).first { it.name == "com.google.plugin" }
             val libraryNameToRemove = libraryEntity.name
             builder.removeEntity(libraryEntity)
@@ -213,7 +213,7 @@ class JpsGlobalEntitiesSyncTest {
 
     loadedProjects.forEach { loadedProject ->
       val projectWorkspaceModel = WorkspaceModel.getInstance(loadedProject)
-      val projectVirtualFileUrlManager = VirtualFileUrlManager.getInstance(loadedProject)
+      val projectVirtualFileUrlManager = projectWorkspaceModel.getVirtualFileUrlManager()
       projectWorkspaceModel as WorkspaceModelImpl
       val projectLibraryEntities = projectWorkspaceModel.currentSnapshot.entities(LibraryEntity::class.java).toList()
       UsefulTestCase.assertSameElements(projectLibrariesNames + globalLibrariesNames, projectLibraryEntities.map { it.name })

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/impl/jps/serialization/JpsIncorrectDataLoading.kt

@@ -2,8 +2,8 @@
 package com.intellij.workspaceModel.ide.impl.jps.serialization
 
 import com.intellij.openapi.application.ex.PathManagerEx
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.testFramework.HeavyPlatformTestCase
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.platform.workspace.storage.EntityStorage
 import com.intellij.platform.workspace.storage.MutableEntityStorage
 import com.intellij.platform.workspace.jps.entities.ModuleEntity
@@ -78,7 +78,7 @@ class JpsIncorrectDataLoading : HeavyPlatformTestCase() {
 
   private fun loadProject(projectFile: File): EntityStorage {
     val storageBuilder = MutableEntityStorage.create()
-    val virtualFileManager: VirtualFileUrlManager = VirtualFileUrlManager.getInstance(project)
+    val virtualFileManager: VirtualFileUrlManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
     loadProject(projectFile.asConfigLocation(virtualFileManager), storageBuilder, storageBuilder, virtualFileManager,
                 errorReporter = errorCollector)
     return storageBuilder.toSnapshot()

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/impl/jps/serialization/JpsProjectEntitiesLoaderTest.kt

@@ -9,6 +9,7 @@ import com.intellij.openapi.module.Module
 import com.intellij.openapi.module.ModuleManager
 import com.intellij.openapi.roots.ModuleRootManager
 import com.intellij.openapi.roots.ModuleSourceOrderEntry
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.workspace.jps.entities.*
 import com.intellij.platform.workspace.storage.EntityStorage
 import com.intellij.platform.workspace.storage.MutableEntityStorage
@@ -18,7 +19,6 @@ import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.project.stateStore
 import com.intellij.testFramework.HeavyPlatformTestCase
 import com.intellij.util.io.write
-import com.intellij.workspaceModel.ide.getInstance
 import org.jetbrains.jps.model.serialization.module.JpsModuleRootModelSerializer
 import org.jetbrains.jps.util.JpsPathUtil
 import org.junit.Test
@@ -71,7 +71,7 @@ class JpsProjectEntitiesLoaderTest : HeavyPlatformTestCase() {
   }
 
   private fun checkSampleProjectConfiguration(storage: EntityStorage, projectDir: File) {
-    val projectUrl = projectDir.toVirtualFileUrl(VirtualFileUrlManager.getInstance(project))
+    val projectUrl = projectDir.toVirtualFileUrl(WorkspaceModel.getInstance(project).getVirtualFileUrlManager())
     val modules = storage.entities(ModuleEntity::class.java).sortedBy { it.name }.toList()
     assertEquals(3, modules.size)
 
@@ -245,7 +245,7 @@ class JpsProjectEntitiesLoaderTest : HeavyPlatformTestCase() {
 
   private fun loadProject(projectFile: File): EntityStorage {
     val storageBuilder = MutableEntityStorage.create()
-    val virtualFileManager: VirtualFileUrlManager = VirtualFileUrlManager.getInstance(project)
+    val virtualFileManager: VirtualFileUrlManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
     loadProject(projectFile.asConfigLocation(virtualFileManager), storageBuilder, storageBuilder, virtualFileManager)
     return storageBuilder.toSnapshot()
   }

platform/workspace/jps/tests/testSrc/com/intellij/workspaceModel/ide/impl/jps/serialization/JpsProjectSaveAllEntitiesTest.kt

@@ -3,16 +3,16 @@ package com.intellij.workspaceModel.ide.impl.jps.serialization
 import com.intellij.openapi.application.ex.PathManagerEx
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.openapi.util.io.systemIndependentPath
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.workspace.jps.JpsEntitySourceFactory
 import com.intellij.platform.workspace.jps.entities.LibraryEntity
 import com.intellij.platform.workspace.jps.entities.LibraryRoot
 import com.intellij.platform.workspace.jps.entities.LibraryRootTypeId
 import com.intellij.platform.workspace.jps.entities.LibraryTableId
-import com.intellij.testFramework.ApplicationRule
-import com.intellij.testFramework.rules.ProjectModelRule
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.platform.workspace.storage.MutableEntityStorage
 import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
+import com.intellij.testFramework.ApplicationRule
+import com.intellij.testFramework.rules.ProjectModelRule
 import org.junit.Before
 import org.junit.ClassRule
 import org.junit.Rule
@@ -28,7 +28,7 @@ class JpsProjectSaveAllEntitiesTest {
 
   @Before
   fun setUp() {
-    virtualFileManager = VirtualFileUrlManager.getInstance(projectModel.project)
+    virtualFileManager = WorkspaceModel.getInstance(projectModel.project).getVirtualFileUrlManager()
   }
 
   @Test

platform/workspace/storage/src/com/intellij/platform/workspace/storage/url/VirtualFileUrlManager.kt

@@ -5,7 +5,7 @@ import org.jetbrains.annotations.ApiStatus
 
 /**
  * Storage for URLs (in the Virtual File System format) of files that are referenced from workspace model entities. 
- * Use `VirtualFileUrlManager.getInstance(project)` extension function to get instance of this interface inside IDE.
+ * Use `WorkspaceModel.getVirtualFileUrlManager()` extension function to get instance of this interface inside IDE.
  *
  * In order to obtain a [VirtualFileUrl] instance for a [VirtualFile][com.intellij.openapi.vfs.VirtualFile], use 
  * `virtualFile.toVirtualFileUrl(virtualFileUrlManager)` extension function.

plugins/kotlin/base/scripting/src/org/jetbrains/kotlin/idea/core/script/ucache/kotlinScriptEntities.kt

@@ -11,10 +11,8 @@ import com.intellij.platform.backend.workspace.toVirtualFileUrl
 import com.intellij.platform.backend.workspace.virtualFile
 import com.intellij.platform.workspace.storage.EntityStorage
 import com.intellij.platform.workspace.storage.MutableEntityStorage
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.testFramework.LightVirtualFile
 import com.intellij.util.applyIf
-import com.intellij.workspaceModel.ide.getInstance
 import org.jetbrains.kotlin.idea.core.script.ScriptConfigurationManager
 import org.jetbrains.kotlin.idea.core.script.dependencies.ScriptAdditionalIdeaDependenciesProvider
 import java.nio.file.Path
@@ -38,9 +36,10 @@ fun KotlinScriptEntity.listDependencies(project: Project, rootTypeId: KotlinScri
 }
 
 fun VirtualFile.findDependentScripts(project: Project): List<KotlinScriptEntity>? {
-    val storage = WorkspaceModel.getInstance(project).currentSnapshot
+    val workspaceModel = WorkspaceModel.getInstance(project)
+    val storage = workspaceModel.currentSnapshot
     val index = storage.getVirtualFileUrlIndex()
-    val fileUrlManager = VirtualFileUrlManager.getInstance(project)
+    val fileUrlManager = workspaceModel.getVirtualFileUrlManager()
 
     var currentFile: VirtualFile? = this
     while (currentFile != null) {
@@ -250,7 +249,7 @@ private fun MutableEntityStorage.addNewScriptEntity(
     libraryRefs: Set<KotlinScriptLibraryId>,
     project: Project
 ): KotlinScriptEntity {
-    val fileUrlManager = VirtualFileUrlManager.getInstance(project)
+    val fileUrlManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
     val scriptSource = KotlinScriptEntitySource(scriptFile.toVirtualFileUrl(fileUrlManager))
     val scriptEntity = KotlinScriptEntity(scriptFile.path, libraryRefs, scriptSource)
     return addEntity(scriptEntity)
@@ -357,7 +356,7 @@ private fun Project.createLibraryEntity(
     rootTypeId: KotlinScriptLibraryRootTypeId,
 ): KotlinScriptLibraryEntity {
 
-    val fileUrlManager = VirtualFileUrlManager.getInstance(this)
+    val fileUrlManager = WorkspaceModel.getInstance(this).getVirtualFileUrlManager()
     val fileUrl = dependency.toVirtualFileUrl(fileUrlManager)
     val libraryEntitySource = KotlinScriptLibraryEntitySource(fileUrl)
     val libraryRoots = mutableListOf(KotlinScriptLibraryRoot(fileUrl, rootTypeId))

plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenShadePluginConfigurator.kt

@@ -8,12 +8,11 @@ import com.intellij.openapi.util.Key
 import com.intellij.openapi.util.registry.Registry
 import com.intellij.openapi.util.text.StringUtil
 import com.intellij.openapi.vfs.LocalFileSystem
+import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.ide.progress.withBackgroundProgress
 import com.intellij.platform.util.progress.reportRawProgress
 import com.intellij.platform.workspace.jps.entities.*
 import com.intellij.platform.workspace.storage.MutableEntityStorage
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.impl.LegacyBridgeJpsEntitySourceFactory
 import org.jetbrains.idea.maven.buildtool.MavenEventHandler
 import org.jetbrains.idea.maven.importing.workspaceModel.WorkspaceModuleImporter
@@ -76,7 +75,7 @@ internal class MavenShadePluginConfigurator : MavenWorkspaceConfigurator {
     val mavenId = dependencyMavenProject.mavenId
     val fileName = "${mavenId.artifactId}-${mavenId.version}.jar"
     val jarPath = Path.of(dependencyMavenProject.buildDirectory, fileName).pathString
-    val jarUrl = VirtualFileUrlManager.getInstance(project).getOrCreateFromUri("jar://$jarPath!/")
+    val jarUrl = WorkspaceModel.getInstance(project).getVirtualFileUrlManager().getOrCreateFromUri("jar://$jarPath!/")
 
     addLibraryEntity(
       builder,

plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/workspaceModel/ImporterModifiableArtifactModel.kt

@@ -18,9 +18,7 @@ import com.intellij.platform.backend.workspace.WorkspaceModel
 import com.intellij.platform.backend.workspace.virtualFile
 import com.intellij.platform.workspace.storage.MutableEntityStorage
 import com.intellij.platform.workspace.storage.url.VirtualFileUrl
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.util.text.UniqueNameGenerator
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.impl.LegacyBridgeJpsEntitySourceFactory
 import org.jetbrains.jps.util.JpsPathUtil
 import kotlin.collections.set
@@ -64,7 +62,9 @@ internal class ImporterModifiableArtifact(private val project: Project,
   }
 
   override fun setOutputPath(outputPath: String?) {
-    val outputUrl = outputPath?.let { VirtualFileUrlManager.getInstance(project).getOrCreateFromUri(VfsUtilCore.pathToUrl(it)) }
+    val outputUrl = outputPath?.let {
+      WorkspaceModel.getInstance(project).getVirtualFileUrlManager().getOrCreateFromUri(VfsUtilCore.pathToUrl(it))
+    }
     this.outputUrl = outputUrl!!
   }
 
@@ -133,7 +133,7 @@ internal class ImporterModifiableArtifactModel(private val project: Project,
     val uniqueName = generateUniqueName(name)
 
     val outputPath = ArtifactUtil.getDefaultArtifactOutputPath(uniqueName, project)
-    val fileManager = VirtualFileUrlManager.getInstance(project)
+    val fileManager = WorkspaceModel.getInstance(project).getVirtualFileUrlManager()
     val outputUrl = outputPath?.let { fileManager.getOrCreateFromUri(VfsUtilCore.pathToUrl(it)) }
 
     val artifact = ImporterModifiableArtifact(project, uniqueName, artifactType, outputUrl!!, rootElement, externalSource)

plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/workspaceModel/WorkspaceProjectImporter.kt

@@ -35,9 +35,7 @@ import com.intellij.platform.workspace.storage.EntitySource
 import com.intellij.platform.workspace.storage.EntityStorage
 import com.intellij.platform.workspace.storage.MutableEntityStorage
 import com.intellij.platform.workspace.storage.WorkspaceEntity
-import com.intellij.platform.workspace.storage.url.VirtualFileUrlManager
 import com.intellij.util.ExceptionUtil
-import com.intellij.workspaceModel.ide.getInstance
 import com.intellij.workspaceModel.ide.impl.legacyBridge.module.findModule
 import org.jetbrains.annotations.ApiStatus.Internal
 import org.jetbrains.annotations.TestOnly
@@ -77,7 +75,7 @@ internal class WorkspaceProjectImporter(
   private val myModifiableModelsProvider: IdeModifiableModelsProvider,
   private val myProject: Project
 ) : MavenProjectImporter {
-  private val virtualFileUrlManager = VirtualFileUrlManager.getInstance(myProject)
+  private val virtualFileUrlManager = WorkspaceModel.getInstance(myProject).getVirtualFileUrlManager()
   private val createdModulesList = java.util.ArrayList<Module>()
 
   override fun importProject(): List<MavenProjectsProcessorTask> {
@@ -577,8 +575,9 @@ internal class WorkspaceProjectImporter(
 
       val mavenManager = MavenProjectsManager.getInstance(project)
       val projectsTree = mavenManager.projectsTree
+      val workspaceModel = WorkspaceModel.getInstance(project)
       val importer = WorkspaceFolderImporter(builder,
-                                             VirtualFileUrlManager.getInstance(project),
+                                             workspaceModel.getVirtualFileUrlManager(),
                                              mavenManager.importingSettings,
                                              folderImportingContext)