Minor: get rid of warnings: KotlinJavaScriptLibraryManager, KotlinJavaScriptMetaFileSystem

idea/idea-js/src/org/jetbrains/kotlin/idea/js/KotlinJavaScriptLibraryManager.kt

@@ -37,7 +37,6 @@ import org.jetbrains.kotlin.idea.framework.KotlinJavaScriptLibraryDetectionUtil
 import org.jetbrains.kotlin.idea.project.ProjectStructureUtil.isJsKotlinModule
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils
 import java.util.concurrent.atomic.AtomicBoolean
-import kotlin.platform.platformStatic
 
 public class KotlinJavaScriptLibraryManager private constructor(private var myProject: Project?) : ProjectComponent, ModuleRootListener {
     private val myMuted = AtomicBoolean(false)
@@ -46,7 +45,7 @@ public class KotlinJavaScriptLibraryManager private constructor(private var myPr
 
     override fun projectOpened() {
         val project = myProject!!
-        project.getMessageBus().connect(project).subscribe(ProjectTopics.PROJECT_ROOTS, this)
+        project.messageBus.connect(project).subscribe(ProjectTopics.PROJECT_ROOTS, this)
         DumbService.getInstance(project).smartInvokeLater() { updateProjectLibrary() }
     }
 
@@ -68,10 +67,10 @@ public class KotlinJavaScriptLibraryManager private constructor(private var myPr
 
         ApplicationManager.getApplication().invokeLater(Runnable {
                 DumbService.getInstance(myProject!!).runWhenSmart() { updateProjectLibrary() }
-        }, ModalityState.NON_MODAL, myProject!!.getDisposed())
+        }, ModalityState.NON_MODAL, myProject!!.disposed)
     }
 
-    TestOnly
+    @TestOnly
     public fun syncUpdateProjectLibrary(): Unit = updateProjectLibrary(true)
 
     /**
@@ -79,11 +78,11 @@ public class KotlinJavaScriptLibraryManager private constructor(private var myPr
      */
     private fun updateProjectLibrary(synchronously: Boolean = false) {
         val project = myProject
-        if (project == null || project.isDisposed()) return
+        if (project == null || project.isDisposed) return
 
         ApplicationManager.getApplication().assertReadAccessAllowed()
 
-        for (module in ModuleManager.getInstance(project).getModules()) {
+        for (module in ModuleManager.getInstance(project).modules) {
             if (!isModuleApplicable(module)) continue
 
             if (!isJsKotlinModule(module)) {
@@ -99,19 +98,19 @@ public class KotlinJavaScriptLibraryManager private constructor(private var myPr
                         var addSources = false
                         for (clsRootFile in library.getFiles(OrderRootType.CLASSES)) {
                             val path = PathUtil.getLocalPath(clsRootFile)
-                            assert(path != null, "expected not-null path for ${clsRootFile.getName()}")
+                            assert(path != null) { "expected not-null path for ${clsRootFile.name}" }
 
                             val metadataList = KotlinJavascriptMetadataUtils.loadMetadata(path!!)
                             if (metadataList.filter { !it.isAbiVersionCompatible }.isNotEmpty()) continue
 
-                            val classRoot = KotlinJavaScriptMetaFileSystem.getInstance().refreshAndFindFileByPath(path + "!/")
+                            val classRoot = KotlinJavaScriptMetaFileSystem.getInstance().refreshAndFindFileByPath("$path!/")
                             classRoot?.let {
-                                clsRootUrls.add(it.getUrl())
+                                clsRootUrls.add(it.url)
                                 addSources = true
                             }
                         }
                         if (addSources) {
-                            srcRootUrls.addAll(library.getFiles(OrderRootType.SOURCES).map { it.getUrl() })
+                            srcRootUrls.addAll(library.getFiles(OrderRootType.SOURCES).map { it.url })
                         }
                     }
                     true
@@ -130,11 +129,11 @@ public class KotlinJavaScriptLibraryManager private constructor(private var myPr
         if (synchronously) {
             //for test only
             val application = ApplicationManager.getApplication()
-            if (!application.isUnitTestMode()) {
+            if (!application.isUnitTestMode) {
                 throw IllegalStateException("Synchronous library update may be done only in test mode")
             }
 
-            val token = application.acquireWriteActionLock(javaClass<KotlinJavaScriptLibraryManager>())
+            val token = application.acquireWriteActionLock(KotlinJavaScriptLibraryManager::class.java)
             try {
                 applyChangeImpl(module, changesToApply, libraryName)
             }
@@ -145,15 +144,16 @@ public class KotlinJavaScriptLibraryManager private constructor(private var myPr
         else {
             val commit = Runnable { applyChangeImpl(module, changesToApply, libraryName) }
             val commitInWriteAction = Runnable { ApplicationManager.getApplication().runWriteAction(commit) }
-            ApplicationManager.getApplication().invokeLater(commitInWriteAction, myProject!!.getDisposed())
+            ApplicationManager.getApplication().invokeLater(commitInWriteAction, myProject!!.disposed)
         }
     }
 
-    synchronized private fun applyChangeImpl(module: Module, changesToApply: ChangesToApply, libraryName: String) {
+    @Synchronized
-        if (module.isDisposed()) return
+    private fun applyChangeImpl(module: Module, changesToApply: ChangesToApply, libraryName: String) {
+        if (module.isDisposed) return
 
-        val model = ModuleRootManager.getInstance(module).getModifiableModel()
+        val model = ModuleRootManager.getInstance(module).modifiableModel
-        val libraryTableModel = model.getModuleLibraryTable().getModifiableModel()
+        val libraryTableModel = model.moduleLibraryTable.modifiableModel
 
         var library = findLibraryByName(libraryTableModel, libraryName)
 
@@ -172,7 +172,7 @@ public class KotlinJavaScriptLibraryManager private constructor(private var myPr
             return
         }
 
-        val libraryModel = library.getModifiableModel()
+        val libraryModel = library.modifiableModel
 
         val existingClsUrls = library.getUrls(OrderRootType.CLASSES).toSet()
         val existingSrcUrls = library.getUrls(OrderRootType.SOURCES).toSet()
@@ -204,13 +204,13 @@ public class KotlinJavaScriptLibraryManager private constructor(private var myPr
         }
     }
 
-    private fun isModuleApplicable(module: Module) = ModuleTypeId.JAVA_MODULE == ModuleType.get(module).getId()
+    private fun isModuleApplicable(module: Module) = ModuleTypeId.JAVA_MODULE == ModuleType.get(module).id
 
     private fun findLibraryByName(libraryTableModel: LibraryTable.ModifiableModel, libraryName: String) =
-            libraryTableModel.getLibraries().firstOrNull { libraryName == it.getName() }
+            libraryTableModel.libraries.firstOrNull { libraryName == it.name }
 
     private fun findLibraryByName(module: Module, libraryName: String) =
-            OrderEntryUtil.findLibraryOrderEntry(ModuleRootManager.getInstance(module), libraryName)?.getLibrary()
+            OrderEntryUtil.findLibraryOrderEntry(ModuleRootManager.getInstance(module), libraryName)?.library
 
     private class ChangesToApply(val clsUrlsToAdd: List<String> = listOf(), val srcUrlsToAdd: List<String> = listOf())
 
@@ -218,8 +218,8 @@ public class KotlinJavaScriptLibraryManager private constructor(private var myPr
 
         public val LIBRARY_NAME: String = "<Kotlin JavaScript library>"
 
-        platformStatic
+        @JvmStatic
         public fun getInstance(project: Project): KotlinJavaScriptLibraryManager =
-            project.getComponent(javaClass<KotlinJavaScriptLibraryManager>())!!
+            project.getComponent(KotlinJavaScriptLibraryManager::class.java)!!
     }
 }

idea/idea-js/src/org/jetbrains/kotlin/idea/js/KotlinJavaScriptMetaFileSystem.kt

@@ -23,11 +23,10 @@ import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.openapi.vfs.newvfs.ArchiveFileSystem
 import com.intellij.openapi.vfs.newvfs.VfsImplUtil
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils
-import kotlin.platform.platformStatic
 
 public class KotlinJavaScriptMetaFileSystem : ArchiveFileSystem() {
     companion object {
-        platformStatic
+        @JvmStatic
         public fun getInstance(): KotlinJavaScriptMetaFileSystem = VirtualFileManager.getInstance().getFileSystem(KotlinJavascriptMetadataUtils.VFS_PROTOCOL) as KotlinJavaScriptMetaFileSystem
     }
 
@@ -37,13 +36,13 @@ public class KotlinJavaScriptMetaFileSystem : ArchiveFileSystem() {
 
     override fun extractRootPath(path: String): String {
         val jarSeparatorIndex = path.indexOf(JarFileSystem.JAR_SEPARATOR)
-        assert(jarSeparatorIndex >= 0) { "Path passed to KotlinJavascriptMetaFileSystem must have separator '!/': " + path }
+        assert(jarSeparatorIndex >= 0) { "Path passed to KotlinJavascriptMetaFileSystem must have separator '!/': $path" }
         return path.substring(0, jarSeparatorIndex + JarFileSystem.JAR_SEPARATOR.length())
     }
 
     override fun getHandler(entryFile: VirtualFile): KotlinJavaScriptHandler {
-        val pathToRoot = extractLocalPath(this.extractRootPath(entryFile.getPath()))
+        val pathToRoot = extractLocalPath(this.extractRootPath(entryFile.path))
-        return VfsImplUtil.getHandler<KotlinJavaScriptHandler>(this, pathToRoot + ARCHIVE_SUFFIX) {
+        return VfsImplUtil.getHandler<KotlinJavaScriptHandler>(this, "$pathToRoot$ARCHIVE_SUFFIX") {
             KotlinJavaScriptHandler(it.substringBeforeLast(ARCHIVE_SUFFIX))
         }
     }