[statistics] IDEA-326820 Enable counter usage collectors to be regular Kotlin object

GitOrigin-RevId: cb7d91441a3455c8f1f47f32423e81e92ec1b0d4

java/java-impl-refactorings/src/com/intellij/refactoring/introduceParameter/IntroduceParameterUsagesCollector.kt

@@ -5,22 +5,20 @@ import com.intellij.internal.statistic.eventLog.EventLogGroup
 import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 
-class IntroduceParameterUsagesCollector : CounterUsagesCollector() {
+object IntroduceParameterUsagesCollector : CounterUsagesCollector() {
   override fun getGroup(): EventLogGroup = GROUP
 
-  companion object {
-    private val GROUP = EventLogGroup("introduce.parameter.inplace", 2)
+  private val GROUP = EventLogGroup("introduce.parameter.inplace", 2)
 
-    @JvmField
-    val delegate = EventFields.Boolean("delegate")
+  @JvmField
+  val delegate = EventFields.Boolean("delegate")
 
-    @JvmField
-    val replaceAll = EventFields.Boolean("replaceAllOccurrences")
+  @JvmField
+  val replaceAll = EventFields.Boolean("replaceAllOccurrences")
 
-    @JvmField
-    val settingsOnPerform = GROUP.registerVarargEvent("settingsOnHide", delegate)
+  @JvmField
+  val settingsOnPerform = GROUP.registerVarargEvent("settingsOnHide", delegate)
 
-    @JvmField
-    val started = GROUP.registerVarargEvent("started", replaceAll)
-  }
+  @JvmField
+  val started = GROUP.registerVarargEvent("started", replaceAll)
 }

platform/lang-impl/src/com/intellij/codeInsight/hints/codeVision/CodeVisionFusCollector.kt

@@ -4,23 +4,20 @@ package com.intellij.codeInsight.hints.codeVision
 import com.intellij.internal.statistic.eventLog.EventLogGroup
 import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
-import org.jetbrains.annotations.ApiStatus.Internal
+import org.jetbrains.annotations.ApiStatus
 
-@Internal
-class CodeVisionFusCollector: CounterUsagesCollector() {
-  companion object {
-    private val GROUP = EventLogGroup("daemon.code.vision", 2)
+@ApiStatus.Internal
+object CodeVisionFusCollector : CounterUsagesCollector() {
+  private val GROUP = EventLogGroup("daemon.code.vision", 2)
 
+  val CODE_VISION_FINISHED = GROUP.registerEvent(
+    "finished",
+    EventFields.DurationMs,
+    EventFields.Class("provider_class"),
+    EventFields.Language
+  )
 
-    val CODE_VISION_FINISHED = GROUP.registerEvent(
-      "finished",
-      EventFields.DurationMs,
-      EventFields.Class("provider_class"),
-      EventFields.Language
-    )
-
-    val ANNOTATION_LOADED = GROUP.registerEvent("vcs.annotation.loaded", EventFields.DurationMs)
-  }
+  val ANNOTATION_LOADED = GROUP.registerEvent("vcs.annotation.loaded", EventFields.DurationMs)
 
   override fun getGroup(): EventLogGroup = GROUP
 }

platform/lang-impl/src/com/intellij/codeInsight/hints/declarative/impl/InlayActionHandlerUsagesCollector.kt

@@ -7,19 +7,16 @@ import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 import com.intellij.internal.statistic.utils.getPluginInfo
 
-
-internal class InlayActionHandlerUsagesCollector : CounterUsagesCollector() {
+internal object InlayActionHandlerUsagesCollector : CounterUsagesCollector() {
   override fun getGroup(): EventLogGroup = GROUP
 
-  companion object {
-    private val GROUP = EventLogGroup("inlay.action.handler", 1)
-    private val HANDLER_FIELD = EventFields.StringValidatedByCustomRule("id", PluginInfoValidationRule::class.java)
-    private val CLICK_HANDLER_EVENT = GROUP.registerEvent("click.handled",
-                                                          HANDLER_FIELD,
-                                                          EventFields.PluginInfo)
+  private val GROUP = EventLogGroup("inlay.action.handler", 1)
+  private val HANDLER_FIELD = EventFields.StringValidatedByCustomRule("id", PluginInfoValidationRule::class.java)
+  private val CLICK_HANDLER_EVENT = GROUP.registerEvent("click.handled",
+                                                        HANDLER_FIELD,
+                                                        EventFields.PluginInfo)
 
-    fun clickHandled(handlerId: String, handlerClass: Class<*>) {
-      CLICK_HANDLER_EVENT.log(handlerId, getPluginInfo(handlerClass))
-    }
+  fun clickHandled(handlerId: String, handlerClass: Class<*>) {
+    CLICK_HANDLER_EVENT.log(handlerId, getPluginInfo(handlerClass))
   }
 }

platform/lang-impl/src/com/intellij/refactoring/move/MoveUsagesCollector.kt

@@ -8,20 +8,15 @@ import com.intellij.internal.statistic.eventLog.events.EventId2
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 import com.intellij.lang.Language
 
-class MoveUsagesCollector : CounterUsagesCollector() {
-  companion object {
-    private val GROUP = EventLogGroup("move.refactoring", 2)
+object MoveUsagesCollector : CounterUsagesCollector() {
+  private val GROUP = EventLogGroup("move.refactoring", 2)
 
-    @JvmField
-    val MOVE_FILES_OR_DIRECTORIES: EventId = GROUP.registerEvent("move.files.or.directories")
+  @JvmField
+  val MOVE_FILES_OR_DIRECTORIES: EventId = GROUP.registerEvent("move.files.or.directories")
 
-    @JvmField
-    val HANDLER_INVOKED: EventId2<Language?, Class<*>?> = GROUP.registerEvent("handler.invoked", EventFields.Language,
-                                                                              EventFields.Class("handler"))
+  @JvmField
+  val HANDLER_INVOKED: EventId2<Language?, Class<*>?> = GROUP.registerEvent("handler.invoked", EventFields.Language,
+                                                                            EventFields.Class("handler"))
 
-  }
-
-  override fun getGroup(): EventLogGroup {
-    return GROUP
-  }
+  override fun getGroup(): EventLogGroup = GROUP
 }

platform/lang-impl/src/com/intellij/refactoring/suggested/SuggestedRefactoringFeatureUsage.kt

@@ -5,67 +5,63 @@ import com.intellij.internal.statistic.eventLog.EventLogGroup
 import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 
+internal object SuggestedRefactoringFeatureUsage : CounterUsagesCollector() {
+  private val GROUP = EventLogGroup("suggested.refactorings", 2)
 
-internal class SuggestedRefactoringFeatureUsage : CounterUsagesCollector() {
+  private var lastFeatureUsageIdLogged: Int? = null
 
-  companion object {
-    private val GROUP = EventLogGroup("suggested.refactorings", 2)
+  private const val RENAME = "rename."
+  private const val CHANGE_SIGNATURE = "changeSignature."
+  private const val SUGGESTED = "suggested"
+  const val POPUP_SHOWN: String = "popup.shown"
+  const val POPUP_CANCELED: String = "popup.canceled"
+  const val PERFORMED: String = "performed"
 
-    private var lastFeatureUsageIdLogged: Int? = null
+  private val PLACE = EventFields.ActionPlace
+  private val ID = EventFields.Int("id")
+  private val LANGUAGE = EventFields.Language
+  private val CLASS = EventFields.Class("declaration_type")
 
-    private const val RENAME = "rename."
-    private const val CHANGE_SIGNATURE = "changeSignature."
-    private const val SUGGESTED = "suggested"
-    const val POPUP_SHOWN: String = "popup.shown"
-    const val POPUP_CANCELED: String = "popup.canceled"
-    const val PERFORMED: String = "performed"
+  private val RENAME_SUGGESTED = GROUP.registerVarargEvent(RENAME + SUGGESTED, PLACE, ID, LANGUAGE, CLASS)
+  private val RENAME_POPUP_SHOWN = GROUP.registerVarargEvent(RENAME + POPUP_SHOWN, PLACE, ID, LANGUAGE, CLASS)
+  private val RENAME_POPUP_CANCELED = GROUP.registerVarargEvent(RENAME + POPUP_CANCELED, PLACE, ID, LANGUAGE, CLASS)
+  private val RENAME_PERFORMED = GROUP.registerVarargEvent(RENAME + PERFORMED, PLACE, ID, LANGUAGE, CLASS)
 
-    private val PLACE = EventFields.ActionPlace
-    private val ID = EventFields.Int("id")
-    private val LANGUAGE = EventFields.Language
-    private val CLASS = EventFields.Class("declaration_type")
-
-    private val RENAME_SUGGESTED = GROUP.registerVarargEvent(RENAME + SUGGESTED, PLACE, ID, LANGUAGE, CLASS)
-    private val RENAME_POPUP_SHOWN = GROUP.registerVarargEvent(RENAME + POPUP_SHOWN, PLACE, ID, LANGUAGE, CLASS)
-    private val RENAME_POPUP_CANCELED = GROUP.registerVarargEvent(RENAME + POPUP_CANCELED, PLACE, ID, LANGUAGE, CLASS)
-    private val RENAME_PERFORMED = GROUP.registerVarargEvent(RENAME + PERFORMED, PLACE, ID, LANGUAGE, CLASS)
-
-    private val CHANGE_SIGNATURE_SUGGESTED = GROUP.registerVarargEvent(CHANGE_SIGNATURE + SUGGESTED, PLACE, ID, LANGUAGE, CLASS)
-    private val CHANGE_SIGNATURE_POPUP_SHOWN = GROUP.registerVarargEvent(CHANGE_SIGNATURE + POPUP_SHOWN, PLACE, ID, LANGUAGE, CLASS)
-    private val CHANGE_SIGNATURE_POPUP_CANCELED = GROUP.registerVarargEvent(CHANGE_SIGNATURE + POPUP_CANCELED, PLACE, ID, LANGUAGE, CLASS)
-    private val CHANGE_SIGNATURE_PERFORMED = GROUP.registerVarargEvent(CHANGE_SIGNATURE + PERFORMED, PLACE, ID, LANGUAGE, CLASS)
+  private val CHANGE_SIGNATURE_SUGGESTED = GROUP.registerVarargEvent(CHANGE_SIGNATURE + SUGGESTED, PLACE, ID, LANGUAGE, CLASS)
+  private val CHANGE_SIGNATURE_POPUP_SHOWN = GROUP.registerVarargEvent(CHANGE_SIGNATURE + POPUP_SHOWN, PLACE, ID, LANGUAGE, CLASS)
+  private val CHANGE_SIGNATURE_POPUP_CANCELED = GROUP.registerVarargEvent(CHANGE_SIGNATURE + POPUP_CANCELED, PLACE, ID, LANGUAGE, CLASS)
+  private val CHANGE_SIGNATURE_PERFORMED = GROUP.registerVarargEvent(CHANGE_SIGNATURE + PERFORMED, PLACE, ID, LANGUAGE, CLASS)
 
 
-    private val eventsMap by lazy {
-      listOf(RENAME_SUGGESTED, RENAME_POPUP_SHOWN,
-             RENAME_POPUP_CANCELED, RENAME_PERFORMED,
-             CHANGE_SIGNATURE_SUGGESTED, CHANGE_SIGNATURE_POPUP_SHOWN,
-             CHANGE_SIGNATURE_POPUP_CANCELED, CHANGE_SIGNATURE_PERFORMED).associateBy { it.eventId }
+  private val eventsMap by lazy {
+    listOf(RENAME_SUGGESTED, RENAME_POPUP_SHOWN,
+           RENAME_POPUP_CANCELED, RENAME_PERFORMED,
+           CHANGE_SIGNATURE_SUGGESTED, CHANGE_SIGNATURE_POPUP_SHOWN,
+           CHANGE_SIGNATURE_POPUP_CANCELED, CHANGE_SIGNATURE_PERFORMED).associateBy { it.eventId }
+  }
+
+  fun logEvent(
+    eventIdSuffix: String,
+    refactoringData: SuggestedRefactoringData,
+    state: SuggestedRefactoringState,
+    actionPlace: String?
+  ) {
+    val eventIdPrefix = when (refactoringData) {
+      is SuggestedRenameData -> RENAME
+      is SuggestedChangeSignatureData -> CHANGE_SIGNATURE
     }
+    val event = eventsMap[eventIdPrefix + eventIdSuffix]
+    event?.log(refactoringData.declaration.project,
+               PLACE.with(actionPlace),
+               ID.with(state.featureUsageId),
+               LANGUAGE.with(refactoringData.declaration.language),
+               CLASS.with(refactoringData.declaration.javaClass))
+  }
 
-    fun logEvent(
-      eventIdSuffix: String,
-      refactoringData: SuggestedRefactoringData,
-      state: SuggestedRefactoringState,
-      actionPlace: String?
-    ) {
-      val eventIdPrefix = when (refactoringData) {
-        is SuggestedRenameData -> RENAME
-        is SuggestedChangeSignatureData -> CHANGE_SIGNATURE
-      }
-      val event = eventsMap[eventIdPrefix + eventIdSuffix]
-      event?.log(refactoringData.declaration.project,
-                 PLACE.with(actionPlace),
-                 ID.with(state.featureUsageId),
-                 LANGUAGE.with(refactoringData.declaration.language),
-                 CLASS.with(refactoringData.declaration.javaClass))
-    }
-
-    fun refactoringSuggested(refactoringData: SuggestedRefactoringData, state: SuggestedRefactoringState) {
-      if (state.featureUsageId != lastFeatureUsageIdLogged) {
-        lastFeatureUsageIdLogged = state.featureUsageId
-        logEvent(SUGGESTED, refactoringData, state, null)
-      }
+  fun refactoringSuggested(refactoringData: SuggestedRefactoringData, state: SuggestedRefactoringState) {
+    if (state.featureUsageId != lastFeatureUsageIdLogged) {
+      lastFeatureUsageIdLogged = state.featureUsageId
+      logEvent(SUGGESTED, refactoringData, state, null)
     }
   }
 

platform/lang-impl/src/com/intellij/refactoring/ui/RefactoringDialogUsageCollector.kt

@@ -6,27 +6,22 @@ import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 import com.intellij.openapi.project.Project
 
-class RefactoringDialogUsageCollector : CounterUsagesCollector() {
-  companion object {
-    private val GROUP = EventLogGroup("refactoring.dialog", 3)
+object RefactoringDialogUsageCollector : CounterUsagesCollector() {
+  private val GROUP = EventLogGroup("refactoring.dialog", 3)
 
-    private val SELECTED = EventFields.Boolean("selected")
+  private val SELECTED = EventFields.Boolean("selected")
+  private val CLASS_NAME = EventFields.Class("class_name")
+  private val OPEN_IN_EDITOR_SAVED = GROUP.registerVarargEvent("open.in.editor.saved", SELECTED, CLASS_NAME, EventFields.PluginInfo)
+  private val OPEN_IN_EDITOR_SHOWN = GROUP.registerVarargEvent("open.in.editor.shown", SELECTED, CLASS_NAME, EventFields.PluginInfo)
 
-    private val CLASS_NAME = EventFields.Class("class_name")
+  @JvmStatic
+  fun logOpenInEditorSaved(project: Project, selected: Boolean, clazz: Class<*>) {
+    OPEN_IN_EDITOR_SAVED.log(project, SELECTED.with(selected), CLASS_NAME.with(clazz))
+  }
 
-    private val OPEN_IN_EDITOR_SAVED = GROUP.registerVarargEvent("open.in.editor.saved", SELECTED, CLASS_NAME, EventFields.PluginInfo)
-
-    private val OPEN_IN_EDITOR_SHOWN = GROUP.registerVarargEvent("open.in.editor.shown", SELECTED, CLASS_NAME, EventFields.PluginInfo)
-
-    @JvmStatic
-    fun logOpenInEditorSaved(project: Project, selected: Boolean, clazz: Class<*>) {
-      OPEN_IN_EDITOR_SAVED.log(project, SELECTED.with(selected), CLASS_NAME.with(clazz))
-    }
-
-    @JvmStatic
-    fun logOpenInEditorShown(project: Project, selected: Boolean, clazz: Class<*>) {
-      OPEN_IN_EDITOR_SHOWN.log(project, SELECTED.with(selected), CLASS_NAME.with(clazz))
-    }
+  @JvmStatic
+  fun logOpenInEditorShown(project: Project, selected: Boolean, clazz: Class<*>) {
+    OPEN_IN_EDITOR_SHOWN.log(project, SELECTED.with(selected), CLASS_NAME.with(clazz))
   }
 
   override fun getGroup(): EventLogGroup {

platform/lang-impl/src/com/intellij/task/impl/ProjectTaskManagerStatisticsCollector.kt

@@ -7,32 +7,34 @@ import com.intellij.internal.statistic.eventLog.EventLogGroup
 import com.intellij.internal.statistic.eventLog.events.*
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 
-class ProjectTaskManagerStatisticsCollector : CounterUsagesCollector() {
-  companion object {
-    val GROUP: EventLogGroup = EventLogGroup("build", 7)
+object ProjectTaskManagerStatisticsCollector : CounterUsagesCollector() {
+  val GROUP: EventLogGroup = EventLogGroup("build", 7)
 
-    @JvmField
-    val TASK_RUNNER: StringListEventField = EventFields.StringListValidatedByCustomRule("task_runner_class", ClassNameRuleValidator::class.java)
+  @JvmField
+  val TASK_RUNNER: StringListEventField = EventFields.StringListValidatedByCustomRule("task_runner_class",
+                                                                                      ClassNameRuleValidator::class.java)
 
-    @JvmField
-    val MODULES: IntEventField = EventFields.Int("modules")
+  @JvmField
+  val MODULES: IntEventField = EventFields.Int("modules")
 
-    @JvmField
-    val INCREMENTAL: BooleanEventField = EventFields.Boolean("incremental")
+  @JvmField
+  val INCREMENTAL: BooleanEventField = EventFields.Boolean("incremental")
 
-    @JvmField
-    val BUILD_ORIGINATOR: StringEventField = EventFields.StringValidatedByCustomRule("build_originator", ClassNameRuleValidator::class.java)
+  @JvmField
+  val BUILD_ORIGINATOR: StringEventField = EventFields.StringValidatedByCustomRule("build_originator", ClassNameRuleValidator::class.java)
 
-    @JvmField
-    val HAS_ERRORS: BooleanEventField = EventFields.Boolean("has_errors")
+  @JvmField
+  val HAS_ERRORS: BooleanEventField = EventFields.Boolean("has_errors")
 
-    @JvmField
-    val BUILD_ACTIVITY: IdeActivityDefinition = GROUP.registerIdeActivity(null,
-                                                                          startEventAdditionalFields = arrayOf(TASK_RUNNER, EventFields.PluginInfo, MODULES, INCREMENTAL, BUILD_ORIGINATOR),
-                                                                          finishEventAdditionalFields = arrayOf(TASK_RUNNER, MODULES, INCREMENTAL, BUILD_ORIGINATOR, HAS_ERRORS))
-  }
+  @JvmField
+  val BUILD_ACTIVITY: IdeActivityDefinition = GROUP.registerIdeActivity(null,
+                                                                        startEventAdditionalFields = arrayOf(TASK_RUNNER,
+                                                                                                             EventFields.PluginInfo,
+                                                                                                             MODULES, INCREMENTAL,
+                                                                                                             BUILD_ORIGINATOR),
+                                                                        finishEventAdditionalFields = arrayOf(TASK_RUNNER, MODULES,
+                                                                                                              INCREMENTAL, BUILD_ORIGINATOR,
+                                                                                                              HAS_ERRORS))
 
-  override fun getGroup(): EventLogGroup {
-    return GROUP
-  }
+  override fun getGroup(): EventLogGroup = GROUP
 }

platform/new-ui-onboarding/src/com/intellij/platform/ide/newUiOnboarding/NewUiOnboardingStatistics.kt

@@ -10,7 +10,7 @@ import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesColle
 import com.intellij.internal.statistic.utils.getPluginInfo
 import com.intellij.openapi.project.Project
 
-internal class NewUiOnboardingStatistics : CounterUsagesCollector() {
+internal object NewUiOnboardingStatistics : CounterUsagesCollector() {
   override fun getGroup(): EventLogGroup = GROUP
 
   enum class OnboardingStartingPlace {
@@ -21,63 +21,61 @@ internal class NewUiOnboardingStatistics : CounterUsagesCollector() {
     SKIP_ALL, ESCAPE_PRESSED, PROJECT_CLOSED
   }
 
-  companion object {
-    private val GROUP: EventLogGroup = EventLogGroup("new.ui.onboarding", 3)
+  private val GROUP: EventLogGroup = EventLogGroup("new.ui.onboarding", 3)
 
-    private val stepIdField = EventFields.StringValidatedByCustomRule<NewUiOnboardingStepIdRule>("step_id")
-    private val durationField = EventFields.DurationMs
-    private val lastStepDurationField = EventFields.Long("last_step_duration_ms")
-    private val stopReasonField = EventFields.Enum<OnboardingStopReason>("reason")
-    private val startingPlaceField = EventFields.Enum<OnboardingStartingPlace>("starting_place")
+  private val stepIdField = EventFields.StringValidatedByCustomRule<NewUiOnboardingStepIdRule>("step_id")
+  private val durationField = EventFields.DurationMs
+  private val lastStepDurationField = EventFields.Long("last_step_duration_ms")
+  private val stopReasonField = EventFields.Enum<OnboardingStopReason>("reason")
+  private val startingPlaceField = EventFields.Enum<OnboardingStartingPlace>("starting_place")
 
-    private val welcomeDialogShownEvent = GROUP.registerEvent("welcome.dialog.shown")
-    private val welcomeDialogSkipEvent = GROUP.registerEvent("welcome.dialog.skip.clicked")
-    private val onboardingStartedEvent = GROUP.registerEvent("started", startingPlaceField)
-    private val onboardingStoppedEvent = GROUP.registerVarargEvent("stopped", stepIdField, stopReasonField,
-                                                                   durationField, lastStepDurationField)
-    private val onboardingFinishedEvent = GROUP.registerEvent("finished", durationField)
-    private val stepStartedEvent = GROUP.registerEvent("step.started", stepIdField)
-    private val stepFinishedEvent = GROUP.registerEvent("step.finished", stepIdField, durationField)
-    private val linkClickedEvent = GROUP.registerEvent("link.clicked", stepIdField)
+  private val welcomeDialogShownEvent = GROUP.registerEvent("welcome.dialog.shown")
+  private val welcomeDialogSkipEvent = GROUP.registerEvent("welcome.dialog.skip.clicked")
+  private val onboardingStartedEvent = GROUP.registerEvent("started", startingPlaceField)
+  private val onboardingStoppedEvent = GROUP.registerVarargEvent("stopped", stepIdField, stopReasonField,
+                                                                 durationField, lastStepDurationField)
+  private val onboardingFinishedEvent = GROUP.registerEvent("finished", durationField)
+  private val stepStartedEvent = GROUP.registerEvent("step.started", stepIdField)
+  private val stepFinishedEvent = GROUP.registerEvent("step.finished", stepIdField, durationField)
+  private val linkClickedEvent = GROUP.registerEvent("link.clicked", stepIdField)
 
-    fun logWelcomeDialogShown(project: Project) {
-      welcomeDialogShownEvent.log(project)
-    }
-
-    fun logWelcomeDialogSkipPressed(project: Project) {
-      welcomeDialogSkipEvent.log(project)
-    }
-
-    fun logOnboardingStarted(project: Project, place: OnboardingStartingPlace) {
-      onboardingStartedEvent.log(project, place)
-    }
-
-    fun logOnboardingStopped(project: Project, stepId: String, reason: OnboardingStopReason, startMillis: Long, lastStepStartMillis: Long) {
-      onboardingStoppedEvent.log(project,
-                                 stepIdField with stepId,
-                                 stopReasonField with reason,
-                                 durationField with getDuration(startMillis),
-                                 lastStepDurationField with getDuration(lastStepStartMillis))
-    }
-
-    fun logOnboardingFinished(project: Project, startMillis: Long) {
-      onboardingFinishedEvent.log(project, getDuration(startMillis))
-    }
-
-    fun logStepStarted(project: Project, stepId: String) {
-      stepStartedEvent.log(project, stepId)
-    }
-
-    fun logStepFinished(project: Project, stepId: String, startMillis: Long) {
-      stepFinishedEvent.log(project, stepId, getDuration(startMillis))
-    }
-
-    fun logLinkClicked(project: Project, stepId: String) {
-      linkClickedEvent.log(project, stepId)
-    }
-
-    private fun getDuration(startMillis: Long): Long = System.currentTimeMillis() - startMillis
+  fun logWelcomeDialogShown(project: Project) {
+    welcomeDialogShownEvent.log(project)
   }
+
+  fun logWelcomeDialogSkipPressed(project: Project) {
+    welcomeDialogSkipEvent.log(project)
+  }
+
+  fun logOnboardingStarted(project: Project, place: OnboardingStartingPlace) {
+    onboardingStartedEvent.log(project, place)
+  }
+
+  fun logOnboardingStopped(project: Project, stepId: String, reason: OnboardingStopReason, startMillis: Long, lastStepStartMillis: Long) {
+    onboardingStoppedEvent.log(project,
+                               stepIdField with stepId,
+                               stopReasonField with reason,
+                               durationField with getDuration(startMillis),
+                               lastStepDurationField with getDuration(lastStepStartMillis))
+  }
+
+  fun logOnboardingFinished(project: Project, startMillis: Long) {
+    onboardingFinishedEvent.log(project, getDuration(startMillis))
+  }
+
+  fun logStepStarted(project: Project, stepId: String) {
+    stepStartedEvent.log(project, stepId)
+  }
+
+  fun logStepFinished(project: Project, stepId: String, startMillis: Long) {
+    stepFinishedEvent.log(project, stepId, getDuration(startMillis))
+  }
+
+  fun logLinkClicked(project: Project, stepId: String) {
+    linkClickedEvent.log(project, stepId)
+  }
+
+  private fun getDuration(startMillis: Long): Long = System.currentTimeMillis() - startMillis
 }
 
 internal class NewUiOnboardingStepIdRule : CustomValidationRule() {

platform/platform-impl/src/com/intellij/application/options/colors/ReaderModeStatsCollector.kt

@@ -4,21 +4,22 @@ package com.intellij.application.options.colors
 import com.intellij.internal.statistic.eventLog.EventLogGroup
 import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
+import org.jetbrains.annotations.ApiStatus
 
-class ReaderModeStatsCollector : CounterUsagesCollector() {
+@ApiStatus.Internal
+object ReaderModeStatsCollector : CounterUsagesCollector() {
   override fun getGroup(): EventLogGroup = GROUP
 
-  companion object {
-    private val GROUP = EventLogGroup("reader.mode", 2)
-    private val seeAlsoNavigation = GROUP.registerEvent("see.also.navigation")
-    private val switchedEvent = GROUP.registerEvent("widget.switched", EventFields.Enabled)
+  private val GROUP = EventLogGroup("reader.mode", 2)
+  private val seeAlsoNavigation = GROUP.registerEvent("see.also.navigation")
+  private val switchedEvent = GROUP.registerEvent("widget.switched", EventFields.Enabled)
 
-    @JvmStatic
-    fun logSeeAlsoNavigation(): Unit = seeAlsoNavigation.log()
+  @JvmStatic
+  fun logSeeAlsoNavigation() {
+    seeAlsoNavigation.log()
+  }
 
-    @JvmStatic
-    fun readerModeSwitched(enabled: Boolean) {
-      switchedEvent.log(enabled)
-    }
+  fun readerModeSwitched(enabled: Boolean) {
+    switchedEvent.log(enabled)
   }
 }

platform/platform-impl/src/com/intellij/codeInsight/inline/completion/InlineCompletionHandler.kt

@@ -32,7 +32,6 @@ import java.util.concurrent.atomic.AtomicBoolean
 @ApiStatus.Experimental
 class InlineCompletionHandler(private val scope: CoroutineScope) : CodeInsightActionHandler {
   private var runningJob: Job? = null
-  private val tracker = InlineCompletionUsageTracker()
 
   private fun getProvider(event: InlineCompletionEvent): InlineCompletionProvider? {
     return InlineCompletionProvider.extensions().firstOrNull { it.isEnabled(event) }?.also {
@@ -104,7 +103,7 @@ class InlineCompletionHandler(private val scope: CoroutineScope) : CodeInsightAc
   }
 
   private suspend fun invokeDebounced(event: InlineCompletionEvent, request: InlineCompletionRequest) {
-    request.editor.register(tracker.track(scope, request))
+    request.editor.register(InlineCompletionUsageTracker.track(scope, request))
 
     val provider = getProvider(event) ?: return
 

platform/platform-impl/src/com/intellij/codeInsight/inline/completion/listeners/InlineCompletionUsageTracker.kt

@@ -1,24 +1,26 @@
 // Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.codeInsight.inline.completion.listeners
 
-import com.intellij.codeInsight.inline.completion.*
+import com.intellij.codeInsight.inline.completion.InlineCompletionRequest
 import com.intellij.internal.statistic.eventLog.EventLogGroup
-import com.intellij.internal.statistic.eventLog.events.*
+import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.eventLog.events.EventFields.Enum
 import com.intellij.internal.statistic.eventLog.events.EventFields.Int
 import com.intellij.internal.statistic.eventLog.events.EventFields.Long
+import com.intellij.internal.statistic.eventLog.events.EventPair
+import com.intellij.internal.statistic.eventLog.events.VarargEventId
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 import com.intellij.openapi.application.EDT
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiDocumentManager
 import com.intellij.psi.util.PsiUtilCore
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 import org.jetbrains.annotations.ApiStatus
 
-
 @ApiStatus.Experimental
-class InlineCompletionUsageTracker : CounterUsagesCollector() {
-
+object InlineCompletionUsageTracker : CounterUsagesCollector() {
   override fun getGroup() = GROUP
 
   fun track(scope: CoroutineScope, request: InlineCompletionRequest): InlineCompletionListener = Tracker(scope, request)
@@ -78,23 +80,21 @@ class InlineCompletionUsageTracker : CounterUsagesCollector() {
 
   }
 
-  companion object {
-    private val GROUP: EventLogGroup = EventLogGroup("inline.completion", 2)
-    private const val SHOWN_EVENT_ID = "inline.shown"
+  private val GROUP: EventLogGroup = EventLogGroup("inline.completion", 2)
+  private const val SHOWN_EVENT_ID = "inline.shown"
 
-    // Suggestions
-    private enum class Decision { ACCEPT, REJECT }
-    private val SUGGESTION_LENGTH = Int("suggestion_length")
-    private val TIME_TO_SHOW = Long("time_to_show")
-    private val DECISION = Enum<Decision>("decision")
+  // Suggestions
+  private enum class Decision { ACCEPT, REJECT }
+  private val SUGGESTION_LENGTH = Int("suggestion_length")
+  private val TIME_TO_SHOW = Long("time_to_show")
+  private val DECISION = Enum<Decision>("decision")
 
-    private val SHOWN: VarargEventId = GROUP.registerVarargEvent(
-      SHOWN_EVENT_ID,
-      EventFields.Language,
-      EventFields.CurrentFile,
-      SUGGESTION_LENGTH,
-      TIME_TO_SHOW,
-      DECISION,
-    )
-  }
+  private val SHOWN: VarargEventId = GROUP.registerVarargEvent(
+    SHOWN_EVENT_ID,
+    EventFields.Language,
+    EventFields.CurrentFile,
+    SUGGESTION_LENGTH,
+    TIME_TO_SHOW,
+    DECISION,
+  )
 }

platform/platform-impl/src/com/intellij/ide/IdeEventQueue.kt

@@ -10,7 +10,7 @@ import com.intellij.concurrency.resetThreadContext
 import com.intellij.diagnostic.EventWatcher
 import com.intellij.diagnostic.LoadingState
 import com.intellij.diagnostic.PerformanceWatcher
-import com.intellij.ide.MnemonicUsageCollector.Companion.logMnemonicUsed
+import com.intellij.ide.MnemonicUsageCollector.logMnemonicUsed
 import com.intellij.ide.actions.MaximizeActiveDialogAction
 import com.intellij.ide.dnd.DnDManager
 import com.intellij.ide.dnd.DnDManagerImpl

platform/platform-impl/src/com/intellij/ide/MnemonicUsageCollector.kt

@@ -9,35 +9,33 @@ import com.intellij.openapi.util.SystemInfoRt
 import java.awt.event.InputEvent
 import java.awt.event.KeyEvent
 
-class MnemonicUsageCollector: CounterUsagesCollector() {
+object MnemonicUsageCollector : CounterUsagesCollector() {
   override fun getGroup(): EventLogGroup = GROUP
 
-  companion object {
-    private val GROUP = EventLogGroup("ui.mnemonic", 2)
-    private val MNEMONIC_USED = GROUP.registerEvent("mnemonic.used",
-                                                    EventFields.String("type", listOf("mac.alt.based", "regular", "mac.regular")))
+  private val GROUP = EventLogGroup("ui.mnemonic", 2)
+  private val MNEMONIC_USED = GROUP.registerEvent("mnemonic.used",
+                                                  EventFields.String("type", listOf("mac.alt.based", "regular", "mac.regular")))
 
-    @JvmStatic
-    fun logMnemonicUsed(ke: KeyEvent?) {
-      if (ke == null) return
-      val code = ke.keyCode
-      if (KeyEvent.VK_0 <= code && code <= KeyEvent.VK_Z) {
-        val modifiers = ke.modifiersEx
-        var type: String? = null
-        if (modifiers == InputEvent.ALT_DOWN_MASK) {
-          if (IdeKeyEventDispatcher.hasMnemonicInWindow(ke.component, ke)) {
-            type = if (SystemInfoRt.isMac) "mac.alt.based" else "regular"
-          }
+  @JvmStatic
+  fun logMnemonicUsed(ke: KeyEvent?) {
+    if (ke == null) return
+    val code = ke.keyCode
+    if (KeyEvent.VK_0 <= code && code <= KeyEvent.VK_Z) {
+      val modifiers = ke.modifiersEx
+      var type: String? = null
+      if (modifiers == InputEvent.ALT_DOWN_MASK) {
+        if (IdeKeyEventDispatcher.hasMnemonicInWindow(ke.component, ke)) {
+          type = if (SystemInfoRt.isMac) "mac.alt.based" else "regular"
         }
-        else if (SystemInfoRt.isMac && modifiers == InputEvent.ALT_DOWN_MASK or InputEvent.CTRL_DOWN_MASK) {
-            if (IdeKeyEventDispatcher.hasMnemonicInWindow(ke.component, ke)) {
-              type = "mac.regular"
-            }
-          }
-          if (type != null) {
-            MNEMONIC_USED.log(type)
-          }
+      }
+      else if (SystemInfoRt.isMac && modifiers == InputEvent.ALT_DOWN_MASK or InputEvent.CTRL_DOWN_MASK) {
+        if (IdeKeyEventDispatcher.hasMnemonicInWindow(ke.component, ke)) {
+          type = "mac.regular"
         }
+      }
+      if (type != null) {
+        MNEMONIC_USED.log(type)
+      }
     }
   }
 }

platform/platform-impl/src/com/intellij/ide/plugins/PluginManagerMain.java

@@ -354,7 +354,7 @@ public final class PluginManagerMain {
 
     var updateSettings = UpdateSettings.getInstance();
     if (updateSettings.isThirdPartyPluginsAllowed()) {
-      PluginManagerUsageCollector.Companion.thirdPartyAcceptanceCheck(DialogAcceptanceResultEnum.AUTO_ACCEPTED);
+      PluginManagerUsageCollector.thirdPartyAcceptanceCheck(DialogAcceptanceResultEnum.AUTO_ACCEPTED);
       return true;
     }
 
@@ -373,11 +373,11 @@ public final class PluginManagerMain {
     var noText = CommonBundle.getCancelButtonText();
     if (Messages.showYesNoDialog(message, title, yesText, noText, Messages.getWarningIcon()) == Messages.YES) {
       updateSettings.setThirdPartyPluginsAllowed(true);
-      PluginManagerUsageCollector.Companion.thirdPartyAcceptanceCheck(DialogAcceptanceResultEnum.ACCEPTED);
+      PluginManagerUsageCollector.thirdPartyAcceptanceCheck(DialogAcceptanceResultEnum.ACCEPTED);
       return true;
     }
     else {
-      PluginManagerUsageCollector.Companion.thirdPartyAcceptanceCheck(DialogAcceptanceResultEnum.DECLINED);
+      PluginManagerUsageCollector.thirdPartyAcceptanceCheck(DialogAcceptanceResultEnum.DECLINED);
       return false;
     }
   }

platform/platform-impl/src/com/intellij/ide/plugins/marketplace/statistics/PluginManagerUsageCollector.kt

@@ -20,99 +20,99 @@ import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.extensions.PluginId
 import com.intellij.openapi.project.Project
 
-internal class PluginManagerUsageCollector : CounterUsagesCollector() {
+internal object PluginManagerUsageCollector : CounterUsagesCollector() {
   override fun getGroup(): EventLogGroup = EVENT_GROUP
 
-  companion object {
-    private val EVENT_GROUP = EventLogGroup("plugin.manager", 6)
-    private val PLUGINS_GROUP_TYPE = EventFields.Enum<PluginsGroupType>("group")
-    private val ENABLE_DISABLE_ACTION = EventFields.Enum<PluginEnabledState>("enabled_state")
-    private val ACCEPTANCE_RESULT = EventFields.Enum<DialogAcceptanceResultEnum>("acceptance_result")
-    private val PLUGIN_SOURCE = EventFields.Enum<InstallationSourceEnum>("source")
-    private val PREVIOUS_VERSION = PluginVersionEventField("previous_version")
-    private val SIGNATURE_CHECK_RESULT = EventFields.Enum<SignatureVerificationResult>("signature_check_result")
+  private val EVENT_GROUP = EventLogGroup("plugin.manager", 6)
+  private val PLUGINS_GROUP_TYPE = EventFields.Enum<PluginsGroupType>("group")
+  private val ENABLE_DISABLE_ACTION = EventFields.Enum<PluginEnabledState>("enabled_state")
+  private val ACCEPTANCE_RESULT = EventFields.Enum<DialogAcceptanceResultEnum>("acceptance_result")
+  private val PLUGIN_SOURCE = EventFields.Enum<InstallationSourceEnum>("source")
+  private val PREVIOUS_VERSION = PluginVersionEventField("previous_version")
+  private val SIGNATURE_CHECK_RESULT = EventFields.Enum<SignatureVerificationResult>("signature_check_result")
 
-    private val PLUGIN_CARD_OPENED = EVENT_GROUP.registerEvent(
-      "plugin.search.card.opened", EventFields.PluginInfo, PLUGINS_GROUP_TYPE, EventFields.Int("index")
-    )
-    private val THIRD_PARTY_ACCEPTANCE_CHECK = EVENT_GROUP.registerEvent("plugin.install.third.party.check", ACCEPTANCE_RESULT)
-    private val PLUGIN_SIGNATURE_WARNING = EVENT_GROUP.registerEvent(
-      "plugin.signature.warning.shown", EventFields.PluginInfo, ACCEPTANCE_RESULT
-    )
-    private val PLUGIN_SIGNATURE_CHECK_RESULT = EVENT_GROUP.registerEvent(
-      "plugin.signature.check.result", EventFields.PluginInfo, SIGNATURE_CHECK_RESULT
-    )
-    private val PLUGIN_STATE_CHANGED = EVENT_GROUP.registerEvent(
-      "plugin.state.changed", EventFields.PluginInfo, ENABLE_DISABLE_ACTION
-    )
-    private val PLUGIN_INSTALLATION_STARTED = EVENT_GROUP.registerEvent(
-      "plugin.installation.started", PLUGIN_SOURCE, EventFields.PluginInfo, PREVIOUS_VERSION
-    )
-    private val PLUGIN_INSTALLATION_FINISHED = EVENT_GROUP.registerEvent("plugin.installation.finished", EventFields.PluginInfo)
-    private val PLUGIN_REMOVED = EVENT_GROUP.registerEvent("plugin.was.removed", EventFields.PluginInfo)
+  private val PLUGIN_CARD_OPENED = EVENT_GROUP.registerEvent(
+    "plugin.search.card.opened", EventFields.PluginInfo, PLUGINS_GROUP_TYPE, EventFields.Int("index")
+  )
+  private val THIRD_PARTY_ACCEPTANCE_CHECK = EVENT_GROUP.registerEvent("plugin.install.third.party.check", ACCEPTANCE_RESULT)
+  private val PLUGIN_SIGNATURE_WARNING = EVENT_GROUP.registerEvent(
+    "plugin.signature.warning.shown", EventFields.PluginInfo, ACCEPTANCE_RESULT
+  )
+  private val PLUGIN_SIGNATURE_CHECK_RESULT = EVENT_GROUP.registerEvent(
+    "plugin.signature.check.result", EventFields.PluginInfo, SIGNATURE_CHECK_RESULT
+  )
+  private val PLUGIN_STATE_CHANGED = EVENT_GROUP.registerEvent(
+    "plugin.state.changed", EventFields.PluginInfo, ENABLE_DISABLE_ACTION
+  )
+  private val PLUGIN_INSTALLATION_STARTED = EVENT_GROUP.registerEvent(
+    "plugin.installation.started", PLUGIN_SOURCE, EventFields.PluginInfo, PREVIOUS_VERSION
+  )
+  private val PLUGIN_INSTALLATION_FINISHED = EVENT_GROUP.registerEvent("plugin.installation.finished", EventFields.PluginInfo)
+  private val PLUGIN_REMOVED = EVENT_GROUP.registerEvent("plugin.was.removed", EventFields.PluginInfo)
 
-    @JvmStatic
-    fun pluginCardOpened(descriptor: IdeaPluginDescriptor, group: PluginsGroup?): Unit? = group?.let {
-      PLUGIN_CARD_OPENED.log(getPluginInfoByDescriptor(descriptor), it.type, it.getPluginIndex(descriptor.pluginId))
-    }
-
-    fun thirdPartyAcceptanceCheck(result: DialogAcceptanceResultEnum) {
-      THIRD_PARTY_ACCEPTANCE_CHECK.getIfInitializedOrNull()?.log(result)
-    }
-
-    @JvmStatic
-    fun pluginsStateChanged(
-      descriptors: Collection<IdeaPluginDescriptor>,
-      enable: Boolean,
-      project: Project? = null,
-    ) {
-      PLUGIN_STATE_CHANGED.getIfInitializedOrNull()?.let { event ->
-        descriptors.forEach { descriptor ->
-          event.log(
-            project,
-            getPluginInfoByDescriptor(descriptor),
-            PluginEnabledState.getState(enable),
-          )
-        }
-      }
-    }
-
-    @JvmStatic
-    fun pluginRemoved(pluginId: PluginId): Unit? = PLUGIN_REMOVED.getIfInitializedOrNull()?.log(getPluginInfoById(pluginId))
-
-    @JvmStatic
-    fun pluginInstallationStarted(
-      descriptor: IdeaPluginDescriptor,
-      source: InstallationSourceEnum,
-      previousVersion: String? = null
-    ) {
-      val pluginInfo = getPluginInfoByDescriptor(descriptor)
-      PLUGIN_INSTALLATION_STARTED.getIfInitializedOrNull()?.log(source, pluginInfo, if (pluginInfo.isSafeToReport()) previousVersion else null)
-    }
-
-    @JvmStatic
-    fun pluginInstallationFinished(descriptor: IdeaPluginDescriptor): Unit? = getPluginInfoByDescriptor(descriptor).let {
-      PLUGIN_INSTALLATION_FINISHED.getIfInitializedOrNull()?.log(it)
-    }
-
-    fun signatureCheckResult(descriptor: IdeaPluginDescriptor, result: SignatureVerificationResult): Unit? =
-      PLUGIN_SIGNATURE_CHECK_RESULT.getIfInitializedOrNull()?.log(getPluginInfoByDescriptor(descriptor), result)
-
-    fun signatureWarningShown(descriptor: IdeaPluginDescriptor, result: DialogAcceptanceResultEnum): Unit? =
-      PLUGIN_SIGNATURE_WARNING.getIfInitializedOrNull()?.log(getPluginInfoByDescriptor(descriptor), result)
+  @JvmStatic
+  fun pluginCardOpened(descriptor: IdeaPluginDescriptor, group: PluginsGroup?): Unit? = group?.let {
+    PLUGIN_CARD_OPENED.log(getPluginInfoByDescriptor(descriptor), it.type, it.getPluginIndex(descriptor.pluginId))
   }
 
-  private data class PluginVersionEventField(override val name: String): PrimitiveEventField<String?>() {
-    override val validationRule: List<String>
-      get() = listOf("{util#plugin_version}")
+  @JvmStatic
+  fun thirdPartyAcceptanceCheck(result: DialogAcceptanceResultEnum) {
+    THIRD_PARTY_ACCEPTANCE_CHECK.getIfInitializedOrNull()?.log(result)
+  }
 
-    override fun addData(fuData: FeatureUsageData, value: String?) {
-      if (!value.isNullOrEmpty()) {
-        fuData.addData(name, value)
+  @JvmStatic
+  fun pluginsStateChanged(
+    descriptors: Collection<IdeaPluginDescriptor>,
+    enable: Boolean,
+    project: Project? = null,
+  ) {
+    PLUGIN_STATE_CHANGED.getIfInitializedOrNull()?.let { event ->
+      descriptors.forEach { descriptor ->
+        event.log(
+          project,
+          getPluginInfoByDescriptor(descriptor),
+          PluginEnabledState.getState(enable),
+        )
       }
     }
   }
+
+  @JvmStatic
+  fun pluginRemoved(pluginId: PluginId): Unit? = PLUGIN_REMOVED.getIfInitializedOrNull()?.log(getPluginInfoById(pluginId))
+
+  @JvmStatic
+  fun pluginInstallationStarted(
+    descriptor: IdeaPluginDescriptor,
+    source: InstallationSourceEnum,
+    previousVersion: String? = null
+  ) {
+    val pluginInfo = getPluginInfoByDescriptor(descriptor)
+    PLUGIN_INSTALLATION_STARTED.getIfInitializedOrNull()?.log(source, pluginInfo,
+                                                              if (pluginInfo.isSafeToReport()) previousVersion else null)
+  }
+
+  @JvmStatic
+  fun pluginInstallationFinished(descriptor: IdeaPluginDescriptor): Unit? = getPluginInfoByDescriptor(descriptor).let {
+    PLUGIN_INSTALLATION_FINISHED.getIfInitializedOrNull()?.log(it)
+  }
+
+  fun signatureCheckResult(descriptor: IdeaPluginDescriptor, result: SignatureVerificationResult): Unit? =
+    PLUGIN_SIGNATURE_CHECK_RESULT.getIfInitializedOrNull()?.log(getPluginInfoByDescriptor(descriptor), result)
+
+  fun signatureWarningShown(descriptor: IdeaPluginDescriptor, result: DialogAcceptanceResultEnum): Unit? =
+    PLUGIN_SIGNATURE_WARNING.getIfInitializedOrNull()?.log(getPluginInfoByDescriptor(descriptor), result)
+}
+
+private data class PluginVersionEventField(override val name: String) : PrimitiveEventField<String?>() {
+  override val validationRule: List<String>
+    get() = listOf("{util#plugin_version}")
+
+  override fun addData(fuData: FeatureUsageData, value: String?) {
+    if (!value.isNullOrEmpty()) {
+      fuData.addData(name, value)
+    }
+  }
 }
 
 // We don't want to log actions when app did not initialize yet (e.g. migration process)
-private fun <T: BaseEventId> T.getIfInitializedOrNull(): T? = if (ApplicationManager.getApplication() == null) null else this
+private fun <T : BaseEventId> T.getIfInitializedOrNull(): T? = if (ApplicationManager.getApplication() == null) null else this

platform/platform-impl/src/com/intellij/ide/projectWizard/NewProjectWizardCollector.kt

@@ -23,58 +23,56 @@ import java.lang.Integer.min
 import com.intellij.ide.projectWizard.NewProjectWizardCollector.Base.logAddSampleCodeChanged as logAddSampleCodeChangedImpl
 
 @ApiStatus.Internal
-class NewProjectWizardCollector : CounterUsagesCollector() {
+object NewProjectWizardCollector : CounterUsagesCollector() {
 
   override fun getGroup(): EventLogGroup = GROUP
 
-  companion object {
+  val GROUP: EventLogGroup = EventLogGroup("new.project.wizard.interactions", 24)
 
-    val GROUP: EventLogGroup = EventLogGroup("new.project.wizard.interactions", 24)
+  private val LANGUAGES = listOf(
+    NewProjectWizardConstants.Language.JAVA, NewProjectWizardConstants.Language.KOTLIN,
+    NewProjectWizardConstants.Language.GROOVY, NewProjectWizardConstants.Language.JAVASCRIPT,
+    NewProjectWizardConstants.Language.HTML, NewProjectWizardConstants.Language.PYTHON,
+    NewProjectWizardConstants.Language.PHP, NewProjectWizardConstants.Language.RUBY,
+    NewProjectWizardConstants.Language.GO, NewProjectWizardConstants.Language.SCALA,
+    NewProjectWizardConstants.Language.RUST, NewProjectWizardConstants.OTHER
+  )
 
-    private val LANGUAGES = listOf(
-      NewProjectWizardConstants.Language.JAVA, NewProjectWizardConstants.Language.KOTLIN,
-      NewProjectWizardConstants.Language.GROOVY, NewProjectWizardConstants.Language.JAVASCRIPT,
-      NewProjectWizardConstants.Language.HTML, NewProjectWizardConstants.Language.PYTHON,
-      NewProjectWizardConstants.Language.PHP, NewProjectWizardConstants.Language.RUBY,
-      NewProjectWizardConstants.Language.GO, NewProjectWizardConstants.Language.SCALA,
-      NewProjectWizardConstants.Language.RUST, NewProjectWizardConstants.OTHER
-    )
+  private val BUILD_SYSTEMS = listOf(
+    NewProjectWizardConstants.BuildSystem.INTELLIJ, NewProjectWizardConstants.BuildSystem.GRADLE,
+    NewProjectWizardConstants.BuildSystem.MAVEN, NewProjectWizardConstants.BuildSystem.SBT,
+    NewProjectWizardConstants.OTHER
+  )
 
-    private val BUILD_SYSTEMS = listOf(
-      NewProjectWizardConstants.BuildSystem.INTELLIJ, NewProjectWizardConstants.BuildSystem.GRADLE,
-      NewProjectWizardConstants.BuildSystem.MAVEN, NewProjectWizardConstants.BuildSystem.SBT,
-      NewProjectWizardConstants.OTHER
-    )
+  private val GROOVY_SDKS = listOf(
+    NewProjectWizardConstants.GroovySdk.MAVEN, NewProjectWizardConstants.GroovySdk.LOCAL,
+    NewProjectWizardConstants.GroovySdk.NONE
+  )
 
-    private val GROOVY_SDKS = listOf(
-      NewProjectWizardConstants.GroovySdk.MAVEN, NewProjectWizardConstants.GroovySdk.LOCAL,
-      NewProjectWizardConstants.GroovySdk.NONE
-    )
+  private val sessionIdField = EventFields.Int("wizard_session_id")
+  private val screenNumField = EventFields.Int("screen")
+  private val typedCharField = IntEventField("typed_chars")
+  private val hitField = IntEventField("hits")
+  private val generatorTypeField = GeneratorEventField("generator")
+  private val languageField = EventFields.String("language", LANGUAGES)
+  private val gitField = EventFields.Boolean("git")
+  private val isSucceededField = EventFields.Boolean("project_created")
+  private val inputMaskField = EventFields.Long("input_mask")
+  private val addSampleCodeField = EventFields.Boolean("add_sample_code")
+  private val addSampleOnboardingTipsField = EventFields.Boolean("add_sample_onboarding_tips")
+  private val buildSystemField = EventFields.String("build_system", BUILD_SYSTEMS)
+  private val buildSystemSdkField = EventFields.Int("build_system_sdk_version")
+  private val buildSystemParentField = EventFields.Boolean("build_system_parent")
+  private val groovyVersionField = EventFields.Version
+  private val groovySourceTypeField = EventFields.String("groovy_sdk_type", GROOVY_SDKS)
+  private val useCompactProjectStructureField = EventFields.Boolean("use_compact_project_structure")
+  private val pluginField = EventFields.String("plugin_selected", LANGUAGES)
 
-    private val sessionIdField = EventFields.Int("wizard_session_id")
-    private val screenNumField = EventFields.Int("screen")
-    private val typedCharField = IntEventField("typed_chars")
-    private val hitField = IntEventField("hits")
-    private val generatorTypeField = GeneratorEventField("generator")
-    private val languageField = EventFields.String("language", LANGUAGES)
-    private val gitField = EventFields.Boolean("git")
-    private val isSucceededField = EventFields.Boolean("project_created")
-    private val inputMaskField = EventFields.Long("input_mask")
-    private val addSampleCodeField = EventFields.Boolean("add_sample_code")
-    private val addSampleOnboardingTipsField = EventFields.Boolean("add_sample_onboarding_tips")
-    private val buildSystemField = EventFields.String("build_system", BUILD_SYSTEMS)
-    private val buildSystemSdkField = EventFields.Int("build_system_sdk_version")
-    private val buildSystemParentField = EventFields.Boolean("build_system_parent")
-    private val groovyVersionField = EventFields.Version
-    private val groovySourceTypeField = EventFields.String("groovy_sdk_type", GROOVY_SDKS)
-    private val useCompactProjectStructureField = EventFields.Boolean("use_compact_project_structure")
-    private val pluginField = EventFields.String("plugin_selected", LANGUAGES)
+  private val baseFields = arrayOf(sessionIdField, screenNumField)
+  private val languageFields = arrayOf(*baseFields, languageField)
+  val buildSystemFields: Array<PrimitiveEventField<out Any?>> = arrayOf(*languageFields, buildSystemField)
 
-    private val baseFields = arrayOf(sessionIdField, screenNumField)
-    private val languageFields = arrayOf(*baseFields, languageField)
-    val buildSystemFields: Array<PrimitiveEventField<out Any?>> = arrayOf(*languageFields, buildSystemField)
-
-    // @formatter:off
+  // @formatter:off
     private val open = GROUP.registerVarargEvent("wizard.dialog.open", *baseFields)
     private val finish = GROUP.registerVarargEvent("wizard.dialog.finish",*baseFields, isSucceededField, EventFields.DurationMs)
     private val next = GROUP.registerVarargEvent("navigate.next", *baseFields, inputMaskField)
@@ -118,81 +116,80 @@ class NewProjectWizardCollector : CounterUsagesCollector() {
     private val useCompactProjectStructureChangedEvent = GROUP.registerVarargEvent("build.system.use.compact.project.structure.changed", *buildSystemFields, useCompactProjectStructureField)
     // @formatter:on
 
-    @JvmStatic
-    fun logOpen(context: WizardContext): Unit =
-      open.logBaseEvent(context)
+  @JvmStatic
+  fun logOpen(context: WizardContext): Unit =
+    open.logBaseEvent(context)
 
-    @JvmStatic
-    fun logFinish(context: WizardContext, success: Boolean, duration: Long): Unit =
-      finish.logBaseEvent(context, isSucceededField with success, EventFields.DurationMs with duration)
+  @JvmStatic
+  fun logFinish(context: WizardContext, success: Boolean, duration: Long): Unit =
+    finish.logBaseEvent(context, isSucceededField with success, EventFields.DurationMs with duration)
 
-    @JvmStatic
-    fun logNext(context: WizardContext, inputMask: Long = -1): Unit =
-      next.logBaseEvent(context, inputMaskField with inputMask)
+  @JvmStatic
+  fun logNext(context: WizardContext, inputMask: Long = -1): Unit =
+    next.logBaseEvent(context, inputMaskField with inputMask)
 
-    @JvmStatic
-    fun logPrev(context: WizardContext, inputMask: Long = -1): Unit =
-      prev.logBaseEvent(context, inputMaskField with inputMask)
+  @JvmStatic
+  fun logPrev(context: WizardContext, inputMask: Long = -1): Unit =
+    prev.logBaseEvent(context, inputMaskField with inputMask)
 
-    @JvmStatic
-    fun logProjectCreated(newProject: Project?, context: WizardContext): Unit =
-      projectCreated.logBaseEvent(newProject, context)
+  @JvmStatic
+  fun logProjectCreated(newProject: Project?, context: WizardContext): Unit =
+    projectCreated.logBaseEvent(newProject, context)
 
-    @JvmStatic
-    fun logSearchChanged(context: WizardContext, chars: Int, results: Int): Unit =
-      search.logBaseEvent(context, typedCharField with min(chars, 10), hitField with results)
+  @JvmStatic
+  fun logSearchChanged(context: WizardContext, chars: Int, results: Int): Unit =
+    search.logBaseEvent(context, typedCharField with min(chars, 10), hitField with results)
 
-    @JvmStatic
-    fun logGeneratorSelected(context: WizardContext): Unit =
-      generatorSelected.logBaseEvent(context, generatorTypeField with context.generator)
+  @JvmStatic
+  fun logGeneratorSelected(context: WizardContext): Unit =
+    generatorSelected.logBaseEvent(context, generatorTypeField with context.generator)
 
-    @JvmStatic
-    fun logGeneratorFinished(context: WizardContext): Unit =
-      generatorFinished.logBaseEvent(context, generatorTypeField with context.generator)
+  @JvmStatic
+  fun logGeneratorFinished(context: WizardContext): Unit =
+    generatorFinished.logBaseEvent(context, generatorTypeField with context.generator)
 
-    @JvmStatic
-    fun logCustomTemplateSelected(context: WizardContext): Unit =
-      templateSelected.logBaseEvent(context)
+  @JvmStatic
+  fun logCustomTemplateSelected(context: WizardContext): Unit =
+    templateSelected.logBaseEvent(context)
 
-    @JvmStatic
-    fun logHelpNavigation(context: WizardContext): Unit =
-      helpNavigation.logBaseEvent(context)
+  @JvmStatic
+  fun logHelpNavigation(context: WizardContext): Unit =
+    helpNavigation.logBaseEvent(context)
 
-    private fun VarargEventId.logBaseEvent(context: WizardContext, vararg arguments: EventPair<*>) =
-      logBaseEvent(context.project, context, *arguments)
+  private fun VarargEventId.logBaseEvent(context: WizardContext, vararg arguments: EventPair<*>) =
+    logBaseEvent(context.project, context, *arguments)
 
-    private fun VarargEventId.logBaseEvent(project: Project?, context: WizardContext, vararg arguments: EventPair<*>) =
-      log(project, sessionIdField with context.sessionId.id, screenNumField with context.screen, *arguments)
+  private fun VarargEventId.logBaseEvent(project: Project?, context: WizardContext, vararg arguments: EventPair<*>) =
+    log(project, sessionIdField with context.sessionId.id, screenNumField with context.screen, *arguments)
 
-    private fun VarargEventId.logLanguageEvent(step: NewProjectWizardStep, vararg arguments: EventPair<*>) =
-      logBaseEvent(step.context, languageField with step.language, *arguments)
+  private fun VarargEventId.logLanguageEvent(step: NewProjectWizardStep, vararg arguments: EventPair<*>) =
+    logBaseEvent(step.context, languageField with step.language, *arguments)
 
-    fun VarargEventId.logBuildSystemEvent(step: NewProjectWizardStep, vararg arguments: EventPair<*>): Unit =
-      logLanguageEvent(step, buildSystemField with step.buildSystem, *arguments)
+  fun VarargEventId.logBuildSystemEvent(step: NewProjectWizardStep, vararg arguments: EventPair<*>): Unit =
+    logLanguageEvent(step, buildSystemField with step.buildSystem, *arguments)
 
-    private val Sdk?.featureVersion: Int
-      get() {
-        val sdk = this ?: return -1
-        val versionString = sdk.versionString
-        val version = JavaVersion.tryParse(versionString) ?: return -1
-        return version.feature
-      }
+  private val Sdk?.featureVersion: Int
+    get() {
+      val sdk = this ?: return -1
+      val versionString = sdk.versionString
+      val version = JavaVersion.tryParse(versionString) ?: return -1
+      return version.feature
+    }
 
-    private val WizardContext.generator: ModuleBuilder?
-      get() = projectBuilder as? ModuleBuilder
+  private val WizardContext.generator: ModuleBuilder?
+    get() = projectBuilder as? ModuleBuilder
 
-    private val NewProjectWizardStep.generator: ModuleBuilder?
-      get() = context.generator
+  private val NewProjectWizardStep.generator: ModuleBuilder?
+    get() = context.generator
 
-    private val NewProjectWizardStep.language: String
-      get() = (this as? LanguageNewProjectWizardData)?.language
-              ?: data.getUserData(LanguageNewProjectWizardData.KEY)?.language
-              ?: NewProjectWizardConstants.OTHER
+  private val NewProjectWizardStep.language: String
+    get() = (this as? LanguageNewProjectWizardData)?.language
+            ?: data.getUserData(LanguageNewProjectWizardData.KEY)?.language
+            ?: NewProjectWizardConstants.OTHER
 
-    private val NewProjectWizardStep.buildSystem: String
-      get() = (this as? BuildSystemNewProjectWizardData)?.buildSystem
-              ?: NewProjectWizardConstants.OTHER
-  }
+  private val NewProjectWizardStep.buildSystem: String
+    get() = (this as? BuildSystemNewProjectWizardData)?.buildSystem
+            ?: NewProjectWizardConstants.OTHER
 
   object Base {
 

platform/platform-impl/src/com/intellij/internal/statistic/collectors/fus/ui/GotItUsageCollector.kt

@@ -78,7 +78,7 @@ class GotItUsageCollector private constructor() {
   }
 }
 
-class GotItUsageCollectorGroup : CounterUsagesCollector() {
+object GotItUsageCollectorGroup : CounterUsagesCollector() {
   override fun getGroup(): EventLogGroup = GROUP
 
   enum class CloseType(private val text: String) {
@@ -92,17 +92,17 @@ class GotItUsageCollectorGroup : CounterUsagesCollector() {
     override fun toString(): String = text
   }
 
-  companion object {
-    private val GROUP = EventLogGroup("got.it.tooltip", 2)
+  private val GROUP = EventLogGroup("got.it.tooltip", 2)
 
-    internal val showEvent: EventId2<String?, Int> = GROUP.registerEvent("show",
-                                                                         EventFields.StringValidatedByCustomRule("id_prefix", GotItIDValidator::class.java),
-                                                                         EventFields.Int("count"))
+  internal val showEvent: EventId2<String?, Int> = GROUP.registerEvent("show",
+                                                                       EventFields.StringValidatedByCustomRule("id_prefix",
+                                                                                                               GotItIDValidator::class.java),
+                                                                       EventFields.Int("count"))
 
-    internal val closeEvent: EventId2<String?, CloseType> = GROUP.registerEvent("close",
-                                                                                EventFields.StringValidatedByCustomRule("id_prefix", GotItIDValidator::class.java),
-                                                                                EventFields.Enum<CloseType>("type"))
-  }
+  internal val closeEvent: EventId2<String?, CloseType> = GROUP.registerEvent("close",
+                                                                              EventFields.StringValidatedByCustomRule("id_prefix",
+                                                                                                                      GotItIDValidator::class.java),
+                                                                              EventFields.Enum<CloseType>("type"))
 }
 
 class GotItIDValidator : CustomValidationRule() {

platform/platform-impl/src/com/intellij/notification/impl/NotificationsEventLogGroup.kt

@@ -13,75 +13,74 @@ import com.intellij.notification.NotificationDisplayType
 import com.intellij.notification.impl.NotificationCollector.*
 import java.util.stream.Collectors
 
-class NotificationsEventLogGroup : CounterUsagesCollector() {
+object NotificationsEventLogGroup : CounterUsagesCollector() {
   override fun getGroup(): EventLogGroup = GROUP
 
-  companion object {
-    @JvmField
-    val GROUP: EventLogGroup = EventLogGroup("notifications", 67)
+  @JvmField
+  val GROUP: EventLogGroup = EventLogGroup("notifications", 67)
 
-    @JvmField
-    val DISPLAY_TYPE: EnumEventField<NotificationDisplayType> = Enum("display_type", NotificationDisplayType::class.java)
+  @JvmField
+  val DISPLAY_TYPE: EnumEventField<NotificationDisplayType> = Enum("display_type", NotificationDisplayType::class.java)
 
-    @JvmField
-    val SEVERITY: EnumEventField<NotificationSeverity> = Enum("severity", NotificationSeverity::class.java)
+  @JvmField
+  val SEVERITY: EnumEventField<NotificationSeverity> = Enum("severity", NotificationSeverity::class.java)
 
-    @JvmField
-    val IS_EXPANDABLE: BooleanEventField = Boolean("is_expandable")
+  @JvmField
+  val IS_EXPANDABLE: BooleanEventField = Boolean("is_expandable")
 
-    @JvmField
-    val ID: StringEventField = StringValidatedByInlineRegexp("id", "\\d+.\\d+")
+  @JvmField
+  val ID: StringEventField = StringValidatedByInlineRegexp("id", "\\d+.\\d+")
 
-    @JvmField
-    val NOTIFICATION_ID: NotificationIdField = NotificationIdField()
+  @JvmField
+  val NOTIFICATION_ID: NotificationIdField = NotificationIdField()
 
-    @JvmField
-    val ADDITIONAL: ObjectEventField = ObjectEventField("additional", NOTIFICATION_ID)
+  @JvmField
+  val ADDITIONAL: ObjectEventField = ObjectEventField("additional", NOTIFICATION_ID)
 
-    @JvmField
-    val NOTIFICATION_GROUP_ID: StringEventField = StringValidatedByCustomRule("notification_group", NotificationGroupValidator::class.java)
+  @JvmField
+  val NOTIFICATION_GROUP_ID: StringEventField = StringValidatedByCustomRule("notification_group", NotificationGroupValidator::class.java)
 
-    @JvmField
-    val NOTIFICATION_PLACE: EnumEventField<NotificationPlace> = Enum("notification_place", NotificationPlace::class.java)
+  @JvmField
+  val NOTIFICATION_PLACE: EnumEventField<NotificationPlace> = Enum("notification_place", NotificationPlace::class.java)
 
-    @JvmField
-    val SHOWN: VarargEventId = registerNotificationEvent("shown", DISPLAY_TYPE, SEVERITY, IS_EXPANDABLE)
+  @JvmField
+  val SHOWN: VarargEventId = registerNotificationEvent("shown", DISPLAY_TYPE, SEVERITY, IS_EXPANDABLE)
 
-    @JvmField
-    val LOGGED: VarargEventId = registerNotificationEvent("logged", SEVERITY)
+  @JvmField
+  val LOGGED: VarargEventId = registerNotificationEvent("logged", SEVERITY)
 
-    @JvmField
-    val CLOSED_BY_USER: VarargEventId = registerNotificationEvent("closed.by.user")
+  @JvmField
+  val CLOSED_BY_USER: VarargEventId = registerNotificationEvent("closed.by.user")
 
-    @JvmField
-    val ACTION_INVOKED: VarargEventId = registerNotificationEvent("action.invoked", ActionsEventLogGroup.ACTION_CLASS,
-                                                                  ActionsEventLogGroup.ACTION_ID, ActionsEventLogGroup.ACTION_PARENT, NOTIFICATION_PLACE)
+  @JvmField
+  val ACTION_INVOKED: VarargEventId = registerNotificationEvent("action.invoked", ActionsEventLogGroup.ACTION_CLASS,
+                                                                ActionsEventLogGroup.ACTION_ID, ActionsEventLogGroup.ACTION_PARENT,
+                                                                NOTIFICATION_PLACE)
 
-    @JvmField
-    val HYPERLINK_CLICKED: VarargEventId = registerNotificationEvent("hyperlink.clicked")
+  @JvmField
+  val HYPERLINK_CLICKED: VarargEventId = registerNotificationEvent("hyperlink.clicked")
 
-    @JvmField
-    val EVENT_LOG_BALLOON_SHOWN: VarargEventId = registerNotificationEvent("event.log.balloon.shown")
+  @JvmField
+  val EVENT_LOG_BALLOON_SHOWN: VarargEventId = registerNotificationEvent("event.log.balloon.shown")
 
-    @JvmField
-    val SETTINGS_CLICKED: VarargEventId = registerNotificationEvent("settings.clicked")
+  @JvmField
+  val SETTINGS_CLICKED: VarargEventId = registerNotificationEvent("settings.clicked")
 
-    @JvmField
-    val BALLOON_EXPANDED: VarargEventId = registerNotificationEvent("balloon.expanded")
+  @JvmField
+  val BALLOON_EXPANDED: VarargEventId = registerNotificationEvent("balloon.expanded")
 
-    @JvmField
-    val BALLOON_COLLAPSED: VarargEventId = registerNotificationEvent("balloon.collapsed")
+  @JvmField
+  val BALLOON_COLLAPSED: VarargEventId = registerNotificationEvent("balloon.collapsed")
 
-    private fun registerNotificationEvent(eventId: String, vararg extraFields: EventField<*>): VarargEventId {
-      return GROUP.registerVarargEvent(
-        eventId,
-        ID,
-        ADDITIONAL,
-        NOTIFICATION_GROUP_ID,
-        EventFields.PluginInfo,
-        *extraFields
-      )
-    }
+  private fun registerNotificationEvent(eventId: String, vararg extraFields: EventField<*>): VarargEventId {
+    return GROUP.registerVarargEvent(
+      eventId,
+      ID,
+      ADDITIONAL,
+      NOTIFICATION_GROUP_ID,
+      EventFields.PluginInfo,
+      *extraFields
+    )
   }
 
   class NotificationIdField : StringEventField("display_id") {

platform/platform-impl/src/com/intellij/openapi/application/ImportOldConfigsUsagesCollector.kt

@@ -10,15 +10,13 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import javax.swing.JRadioButton
 
-internal class ImportOldConfigsUsagesCollector : CounterUsagesCollector() {
-  companion object {
-    private val EVENT_GROUP = EventLogGroup("import.old.config", 4)
-    private val IMPORT_DIALOG_SHOWN_EVENT = EVENT_GROUP.registerEvent("import.dialog.shown",
-                                                                      Enum("selected", ImportOldConfigType::class.java),
-                                                                      Boolean("config_folder_exists"))
-    private val INITIAL_IMPORT_SCENARIO = EVENT_GROUP.registerEvent("import.initially",
-                                                                    Enum("initial_import_scenario", ImportOldConfigsState.InitialImportScenario::class.java))
-  }
+internal object ImportOldConfigsUsagesCollector : CounterUsagesCollector() {
+  private val EVENT_GROUP = EventLogGroup("import.old.config", 4)
+  private val IMPORT_DIALOG_SHOWN_EVENT = EVENT_GROUP.registerEvent("import.dialog.shown",
+                                                                    Enum("selected", ImportOldConfigType::class.java),
+                                                                    Boolean("config_folder_exists"))
+  private val INITIAL_IMPORT_SCENARIO = EVENT_GROUP.registerEvent("import.initially",
+                                                                  Enum("initial_import_scenario", ImportOldConfigsState.InitialImportScenario::class.java))
 
   override fun getGroup(): EventLogGroup = EVENT_GROUP
 

platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/EditorWindow.kt

@@ -23,8 +23,8 @@ import com.intellij.openapi.fileEditor.TextEditor
 import com.intellij.openapi.keymap.KeymapUtil
 import com.intellij.openapi.options.advanced.AdvancedSettings
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.project.README_OPENED_ON_START_TS
-import com.intellij.openapi.project.logReadmeClosedIn
+import com.intellij.openapi.project.ReadmeShownUsageCollector.README_OPENED_ON_START_TS
+import com.intellij.openapi.project.ReadmeShownUsageCollector.logReadmeClosedIn
 import com.intellij.openapi.ui.AbstractPainter
 import com.intellij.openapi.ui.Splitter
 import com.intellij.openapi.util.*

platform/platform-impl/src/com/intellij/openapi/project/ReadmeShownUsageCollector.kt

@@ -7,15 +7,15 @@ import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesColle
 import com.intellij.openapi.util.Key
 import java.time.Instant
 
-internal class ReadmeShownUsageCollector : CounterUsagesCollector() {
+internal object ReadmeShownUsageCollector : CounterUsagesCollector() {
   override fun getGroup(): EventLogGroup = GROUP
-}
 
-private val GROUP: EventLogGroup = EventLogGroup("readme.on.start", 1)
-private val README_CLOSED_EVENT = GROUP.registerEvent("readme.closed", EventFields.DurationMs)
+  private val GROUP: EventLogGroup = EventLogGroup("readme.on.start", 1)
+  private val README_CLOSED_EVENT = GROUP.registerEvent("readme.closed", EventFields.DurationMs)
 
-internal val README_OPENED_ON_START_TS: Key<Instant> = Key.create("readme.shown.timestamp")
+  internal val README_OPENED_ON_START_TS: Key<Instant> = Key.create("readme.shown.timestamp")
 
-internal fun logReadmeClosedIn(durationMs: Long) {
-  README_CLOSED_EVENT.log(durationMs)
+  internal fun logReadmeClosedIn(durationMs: Long) {
+    README_CLOSED_EVENT.log(durationMs)
+  }
 }

platform/platform-impl/src/com/intellij/openapi/project/impl/ProjectFrameAllocator.kt

@@ -34,6 +34,7 @@ import com.intellij.openapi.fileEditor.impl.text.AsyncEditorLoader
 import com.intellij.openapi.options.advanced.AdvancedSettings
 import com.intellij.openapi.progress.blockingContext
 import com.intellij.openapi.project.*
+import com.intellij.openapi.project.ReadmeShownUsageCollector.README_OPENED_ON_START_TS
 import com.intellij.openapi.ui.Messages
 import com.intellij.openapi.util.SystemInfoRt
 import com.intellij.openapi.wm.ToolWindowManager

platform/platform-impl/src/com/intellij/openapi/wm/impl/welcomeScreen/TreeWelcomeScreenLeftPanel.kt

@@ -8,7 +8,7 @@ import com.intellij.openapi.wm.WelcomeScreenLeftPanel
 import com.intellij.openapi.wm.WelcomeScreenTab
 import com.intellij.openapi.wm.ex.IdeFocusTraversalPolicy
 import com.intellij.openapi.wm.impl.welcomeScreen.TabbedWelcomeScreen.DefaultWelcomeScreenTab
-import com.intellij.openapi.wm.impl.welcomeScreen.WelcomeScreenEventCollector.Companion.logWelcomeScreenShown
+import com.intellij.openapi.wm.impl.welcomeScreen.WelcomeScreenEventCollector.logWelcomeScreenShown
 import com.intellij.ui.UIBundle
 import com.intellij.ui.render.RenderingUtil
 import com.intellij.ui.tree.ui.Control

platform/platform-impl/src/com/intellij/openapi/wm/impl/welcomeScreen/WelcomeScreenEventCollector.kt

@@ -4,75 +4,71 @@ package com.intellij.openapi.wm.impl.welcomeScreen
 import com.intellij.internal.statistic.eventLog.EventLogGroup
 import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.eventLog.events.EventId
-import com.intellij.internal.statistic.eventLog.events.EventPair
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 import com.intellij.openapi.application.ConfigImportHelper
 import com.intellij.openapi.keymap.Keymap
 import com.intellij.openapi.wm.WelcomeScreenTab
 import javax.swing.UIManager
 
-class WelcomeScreenEventCollector : CounterUsagesCollector() {
+object WelcomeScreenEventCollector : CounterUsagesCollector() {
   internal enum class TabType { TabNavProject, TabNavCustomize, TabNavPlugins, TabNavTutorials, TabNavOther }
 
   override fun getGroup(): EventLogGroup = GROUP
 
-  companion object {
+  private val GROUP = EventLogGroup("welcomescreen.interaction", 3)
 
-    private val GROUP = EventLogGroup("welcomescreen.interaction", 3)
+  private val shown = GROUP.registerEvent("screen.shown", EventFields.Boolean("first_start"), EventFields.Boolean("config_imported"))
 
-    private val shown = GROUP.registerEvent("screen.shown", EventFields.Boolean("first_start"), EventFields.Boolean("config_imported"))
+  private val hide = GROUP.registerEvent("screen.hidden")
+  private val tabSelected = GROUP.registerEvent("screen.tab.selected", EventFields.Enum("tab_type", TabType::class.java))
 
-    private val hide = GROUP.registerEvent("screen.hidden")
-    private val tabSelected = GROUP.registerEvent("screen.tab.selected", EventFields.Enum("tab_type", TabType::class.java))
+  private val projectSearchUsed = GROUP.registerEvent("project.search")
 
-    private val projectSearchUsed = GROUP.registerEvent("project.search")
+  private val lafChanged = GROUP.registerEvent("laf.changed", EventFields.StringValidatedByEnum("theme_name", "look_and_feel"),
+                                               EventFields.Boolean("sync_os"))
 
-    private val lafChanged = GROUP.registerEvent("laf.changed", EventFields.StringValidatedByEnum("theme_name", "look_and_feel"),
-                                                 EventFields.Boolean("sync_os"))
+  private val OLD_FONT_SIZE = EventFields.Int("old_font_size")
+  private val NEW_FONT_SIZE = EventFields.Int("new_font_size")
+  private val OLD_FONT_SIZE_2D = EventFields.Float("old_font_size_2d")
+  private val NEW_FONT_SIZE_2D = EventFields.Float("new_font_size_2d")
+  private val ideFontChanged = GROUP.registerVarargEvent("ide.font.changed",
+                                                         OLD_FONT_SIZE, NEW_FONT_SIZE, OLD_FONT_SIZE_2D, NEW_FONT_SIZE_2D)
+  private val editorFontChanged = GROUP.registerVarargEvent("editor.font.changed",
+                                                            OLD_FONT_SIZE, NEW_FONT_SIZE, OLD_FONT_SIZE_2D, NEW_FONT_SIZE_2D)
+  private val colorBlindnessChanged = GROUP.registerEvent("color.blindness.changed", EventFields.Boolean("enabled"))
+  private val keymapChanged = GROUP.registerEvent("keymap.changed", EventFields.StringValidatedByEnum("keymap_name", "keymaps"))
+  private val pluginsModified = GROUP.registerEvent("plugins.modified")
 
-    private val OLD_FONT_SIZE = EventFields.Int("old_font_size")
-    private val NEW_FONT_SIZE = EventFields.Int("new_font_size")
-    private val OLD_FONT_SIZE_2D = EventFields.Float("old_font_size_2d")
-    private val NEW_FONT_SIZE_2D = EventFields.Float("new_font_size_2d")
-    private val ideFontChanged = GROUP.registerVarargEvent("ide.font.changed",
-                                                           OLD_FONT_SIZE, NEW_FONT_SIZE, OLD_FONT_SIZE_2D, NEW_FONT_SIZE_2D)
-    private val editorFontChanged = GROUP.registerVarargEvent("editor.font.changed",
-                                                              OLD_FONT_SIZE, NEW_FONT_SIZE, OLD_FONT_SIZE_2D, NEW_FONT_SIZE_2D)
-    private val colorBlindnessChanged = GROUP.registerEvent("color.blindness.changed", EventFields.Boolean("enabled"))
-    private val keymapChanged = GROUP.registerEvent("keymap.changed", EventFields.StringValidatedByEnum("keymap_name", "keymaps"))
-    private val pluginsModified = GROUP.registerEvent("plugins.modified")
+  internal val debuggerTabProcessesSearchUsed: EventId = GROUP.registerEvent("debugger.processes.search")
+  internal val debuggerAttachUsed: EventId = GROUP.registerEvent("debugger.attach")
 
-    internal val debuggerTabProcessesSearchUsed: EventId = GROUP.registerEvent("debugger.processes.search")
-    internal val debuggerAttachUsed: EventId = GROUP.registerEvent("debugger.attach")
+  @JvmStatic
+  fun logWelcomeScreenShown(): Unit = shown.log(ConfigImportHelper.isFirstSession(), ConfigImportHelper.isConfigImported())
 
-    @JvmStatic
-    fun logWelcomeScreenShown(): Unit = shown.log(ConfigImportHelper.isFirstSession(), ConfigImportHelper.isConfigImported())
+  @JvmStatic
+  fun logWelcomeScreenHide(): Unit = hide.log()
 
-    @JvmStatic
-    fun logWelcomeScreenHide(): Unit = hide.log()
+  @JvmStatic
+  fun logTabSelected(selectedTab: WelcomeScreenTab): Unit = tabSelected.log(
+    (selectedTab as? TabbedWelcomeScreen.DefaultWelcomeScreenTab)?.type ?: TabType.TabNavOther)
 
-    @JvmStatic
-    fun logTabSelected(selectedTab: WelcomeScreenTab): Unit = tabSelected.log(
-      (selectedTab as? TabbedWelcomeScreen.DefaultWelcomeScreenTab)?.type ?: TabType.TabNavOther)
+  @JvmStatic
+  fun logProjectSearchUsed(): Unit = projectSearchUsed.log()
 
-    @JvmStatic
-    fun logProjectSearchUsed(): Unit = projectSearchUsed.log()
+  fun logLafChanged(laf: UIManager.LookAndFeelInfo, osSync: Boolean): Unit = lafChanged.log(laf.name, osSync)
 
-    fun logLafChanged(laf: UIManager.LookAndFeelInfo, osSync: Boolean): Unit = lafChanged.log(laf.name, osSync)
+  fun logIdeFontChanged(oldSize: Float, newSize: Float): Unit = ideFontChanged.log(
+    OLD_FONT_SIZE.with((oldSize + 0.5).toInt()), NEW_FONT_SIZE.with((newSize + 0.5).toInt()),
+    OLD_FONT_SIZE_2D.with(oldSize), NEW_FONT_SIZE_2D.with(newSize))
 
-    fun logIdeFontChanged(oldSize: Float, newSize: Float): Unit = ideFontChanged.log(
-      OLD_FONT_SIZE.with((oldSize + 0.5).toInt()), NEW_FONT_SIZE.with((newSize + 0.5).toInt()),
-      OLD_FONT_SIZE_2D.with(oldSize), NEW_FONT_SIZE_2D.with(newSize))
+  fun logEditorFontChanged(oldSize: Float, newSize: Float): Unit = editorFontChanged.log(
+    OLD_FONT_SIZE.with((oldSize + 0.5).toInt()), NEW_FONT_SIZE.with((newSize + 0.5).toInt()),
+    OLD_FONT_SIZE_2D.with(oldSize), NEW_FONT_SIZE_2D.with(newSize))
 
-    fun logEditorFontChanged(oldSize: Float, newSize: Float): Unit = editorFontChanged.log(
-      OLD_FONT_SIZE.with((oldSize + 0.5).toInt()), NEW_FONT_SIZE.with((newSize + 0.5).toInt()),
-      OLD_FONT_SIZE_2D.with(oldSize), NEW_FONT_SIZE_2D.with(newSize))
+  fun logColorBlindnessChanged(enabled: Boolean): Unit = colorBlindnessChanged.log(enabled)
 
-    fun logColorBlindnessChanged(enabled: Boolean): Unit = colorBlindnessChanged.log(enabled)
+  fun logKeymapChanged(keymap: Keymap): Unit = keymapChanged.log(keymap.name)
 
-    fun logKeymapChanged(keymap: Keymap): Unit = keymapChanged.log(keymap.name)
-
-    @JvmStatic
-    fun logPluginsModified(): Unit = pluginsModified.log()
-  }
+  @JvmStatic
+  fun logPluginsModified(): Unit = pluginsModified.log()
 }

platform/platform-impl/src/com/intellij/openapi/wm/impl/welcomeScreen/cloneableProjects/WelcomeScreenCloneCollector.kt

@@ -5,33 +5,31 @@ import com.intellij.internal.statistic.eventLog.EventLogGroup
 import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 
-internal class WelcomeScreenCloneCollector : CounterUsagesCollector() {
+internal object WelcomeScreenCloneCollector : CounterUsagesCollector() {
   override fun getGroup(): EventLogGroup {
     return GROUP
   }
 
-  companion object {
-    private val GROUP = EventLogGroup("welcome_screen.clone", 1)
+  private val GROUP = EventLogGroup("welcome_screen.clone", 1)
 
-    private val CLONE_ADDED_FROM_WELCOME_SCREEN = GROUP.registerEvent("added", EventFields.Int("cloneable_projects"))
-    private val CLONE_CANCELED_FROM_WELCOME_SCREEN = GROUP.registerEvent("canceled")
-    private val CLONE_SUCCESS_FROM_WELCOME_SCREEN = GROUP.registerEvent("success")
-    private val CLONE_FAILED_FROM_WELCOME_SCREEN = GROUP.registerEvent("failed")
+  private val CLONE_ADDED_FROM_WELCOME_SCREEN = GROUP.registerEvent("added", EventFields.Int("cloneable_projects"))
+  private val CLONE_CANCELED_FROM_WELCOME_SCREEN = GROUP.registerEvent("canceled")
+  private val CLONE_SUCCESS_FROM_WELCOME_SCREEN = GROUP.registerEvent("success")
+  private val CLONE_FAILED_FROM_WELCOME_SCREEN = GROUP.registerEvent("failed")
 
-    fun cloneAdded(cloneableProjects: Int) {
-      CLONE_ADDED_FROM_WELCOME_SCREEN.log(cloneableProjects)
-    }
+  fun cloneAdded(cloneableProjects: Int) {
+    CLONE_ADDED_FROM_WELCOME_SCREEN.log(cloneableProjects)
+  }
 
-    fun cloneSuccess() {
-      CLONE_SUCCESS_FROM_WELCOME_SCREEN.log()
-    }
+  fun cloneSuccess() {
+    CLONE_SUCCESS_FROM_WELCOME_SCREEN.log()
+  }
 
-    fun cloneFailed() {
-      CLONE_FAILED_FROM_WELCOME_SCREEN.log()
-    }
+  fun cloneFailed() {
+    CLONE_FAILED_FROM_WELCOME_SCREEN.log()
+  }
 
-    fun cloneCanceled() {
-      CLONE_CANCELED_FROM_WELCOME_SCREEN.log()
-    }
+  fun cloneCanceled() {
+    CLONE_CANCELED_FROM_WELCOME_SCREEN.log()
   }
 }

platform/platform-impl/src/com/intellij/openapi/wm/impl/welcomeScreen/statistics/WelcomeScreenCounterUsageCollector.kt

@@ -7,17 +7,15 @@ import com.intellij.internal.statistic.eventLog.events.EventFields.Int
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 import com.intellij.internal.statistic.utils.StatisticsUtil
 
-class WelcomeScreenCounterUsageCollector : CounterUsagesCollector() {
-  companion object {
-    private val GROUP = EventLogGroup("welcome.screen", 1)
-    private val RECENT_PATHS_COUNT: EventField<Int> = Int("recent_paths_count")
-    private val WELCOME_SCREEN_SHOWN = GROUP.registerEvent("projects.tab.created", RECENT_PATHS_COUNT)
+internal object WelcomeScreenCounterUsageCollector : CounterUsagesCollector() {
+  private val GROUP = EventLogGroup("welcome.screen", 1)
+  private val RECENT_PATHS_COUNT: EventField<Int> = Int("recent_paths_count")
+  private val WELCOME_SCREEN_SHOWN = GROUP.registerEvent("projects.tab.created", RECENT_PATHS_COUNT)
 
-    private val BOUNDS = intArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30, 50)
+  private val BOUNDS = intArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30, 50)
 
-    fun reportWelcomeScreenShowed(recentPathsCount: Int) {
-      WELCOME_SCREEN_SHOWN.log(StatisticsUtil.roundToUpperBound(recentPathsCount, BOUNDS))
-    }
+  fun reportWelcomeScreenShowed(recentPathsCount: Int) {
+    WELCOME_SCREEN_SHOWN.log(StatisticsUtil.roundToUpperBound(recentPathsCount, BOUNDS))
   }
 
   override fun getGroup(): EventLogGroup {

platform/refactoring/src/com/intellij/refactoring/RefactoringUsageCollector.kt

@@ -2,35 +2,36 @@
 package com.intellij.refactoring
 
 import com.intellij.internal.statistic.eventLog.EventLogGroup
-import com.intellij.internal.statistic.eventLog.events.*
+import com.intellij.internal.statistic.eventLog.events.BooleanEventField
+import com.intellij.internal.statistic.eventLog.events.ClassEventField
+import com.intellij.internal.statistic.eventLog.events.EventFields
+import com.intellij.internal.statistic.eventLog.events.VarargEventId
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 
-class RefactoringUsageCollector : CounterUsagesCollector() {
-  companion object {
-    private val GROUP = EventLogGroup("refactoring", 4)
+object RefactoringUsageCollector : CounterUsagesCollector() {
+  private val GROUP = EventLogGroup("refactoring", 4)
 
-    @JvmField
-    val HANDLER: ClassEventField = EventFields.Class("handler")
+  @JvmField
+  val HANDLER: ClassEventField = EventFields.Class("handler")
 
-    @JvmField
-    val ELEMENT: ClassEventField = EventFields.Class("element")
+  @JvmField
+  val ELEMENT: ClassEventField = EventFields.Class("element")
 
-    @JvmField
-    val PROCESSOR: ClassEventField = EventFields.Class("processor")
+  @JvmField
+  val PROCESSOR: ClassEventField = EventFields.Class("processor")
 
-    @JvmField
-    val CANCELLED: BooleanEventField = EventFields.Boolean("cancelled")
+  @JvmField
+  val CANCELLED: BooleanEventField = EventFields.Boolean("cancelled")
 
-    @JvmField
-    val HANDLER_INVOKED: VarargEventId = GROUP.registerVarargEvent("handler.invoked", EventFields.Language, HANDLER, ELEMENT)
+  @JvmField
+  val HANDLER_INVOKED: VarargEventId = GROUP.registerVarargEvent("handler.invoked", EventFields.Language, HANDLER, ELEMENT)
 
-    @JvmField
-    val USAGES_SEARCHED = GROUP.registerEvent("usages.searched", PROCESSOR, CANCELLED, EventFields.DurationMs)
+  @JvmField
+  val USAGES_SEARCHED = GROUP.registerEvent("usages.searched", PROCESSOR, CANCELLED, EventFields.DurationMs)
 
-    @JvmField
-    val EXECUTED = GROUP.registerEvent("executed", PROCESSOR, EventFields.DurationMs)
+  @JvmField
+  val EXECUTED = GROUP.registerEvent("executed", PROCESSOR, EventFields.DurationMs)
 
-  }
 
   override fun getGroup(): EventLogGroup {
     return GROUP

platform/refactoring/src/com/intellij/refactoring/rename/RenameUsagesCollector.kt

@@ -5,29 +5,35 @@ import com.intellij.internal.statistic.eventLog.EventLogGroup
 import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 
-class RenameUsagesCollector : CounterUsagesCollector() {
+object RenameUsagesCollector : CounterUsagesCollector() {
   override fun getGroup(): EventLogGroup = GROUP
 
-  companion object {
-    private val GROUP = EventLogGroup("rename.refactoring", 5)
+  private val GROUP = EventLogGroup("rename.refactoring", 5)
 
-    @JvmField val scopeType = EventFields.Enum("scope_type", RenameScopeType::class.java) { it.fusName }
-    @JvmField val searchInComments = EventFields.Boolean("search_in_comments")
-    @JvmField val searchInTextOccurrences = EventFields.Boolean("search_in_text_occurrences")
-    @JvmField val renameProcessor = EventFields.Class("rename_processor")
+  @JvmField
+  val scopeType = EventFields.Enum("scope_type", RenameScopeType::class.java) { it.fusName }
+  @JvmField
+  val searchInComments = EventFields.Boolean("search_in_comments")
+  @JvmField
+  val searchInTextOccurrences = EventFields.Boolean("search_in_text_occurrences")
+  @JvmField
+  val renameProcessor = EventFields.Class("rename_processor")
 
-    @JvmField val started = registerRenameProcessorEvent("started")
-    @JvmField val executed = registerRenameProcessorEvent("executed")
-    
-    private val referenceClass = EventFields.Class("reference_class")
-    @JvmField val referenceProcessed = GROUP.registerEvent("reference.processed", referenceClass)
+  @JvmField
+  val started = registerRenameProcessorEvent("started")
+  @JvmField
+  val executed = registerRenameProcessorEvent("executed")
 
-    private val localSearchInComments = EventFields.Boolean("local_include_comments")
-    @JvmField val localSearchInCommentsEvent = GROUP.registerEvent("local_search_in_comments", localSearchInComments)
+  private val referenceClass = EventFields.Class("reference_class")
+  @JvmField
+  val referenceProcessed = GROUP.registerEvent("reference.processed", referenceClass)
 
-    private fun registerRenameProcessorEvent(eventId: String) =
-      GROUP.registerVarargEvent(eventId, scopeType, searchInComments, searchInTextOccurrences, renameProcessor, EventFields.Language)
-  }
+  private val localSearchInComments = EventFields.Boolean("local_include_comments")
+  @JvmField
+  val localSearchInCommentsEvent = GROUP.registerEvent("local_search_in_comments", localSearchInComments)
+
+  private fun registerRenameProcessorEvent(eventId: String) =
+    GROUP.registerVarargEvent(eventId, scopeType, searchInComments, searchInTextOccurrences, renameProcessor, EventFields.Language)
 }
 
 enum class RenameScopeType(val fusName: String) {

platform/smart-update/src/com/intellij/smartUpdate/SmartUpdateUsagesCollector.kt

@@ -4,20 +4,19 @@ import com.intellij.internal.statistic.eventLog.EventLogGroup
 import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 
-class SmartUpdateUsagesCollector: CounterUsagesCollector() {
-  companion object {
-    private val GROUP = EventLogGroup("smart.update", 1)
-    private val updatedEvent = GROUP.registerEvent("vcs.update", EventFields.DurationMs)
-    private val buildEvent = GROUP.registerEvent("build.project", EventFields.DurationMs, EventFields.Boolean("success"))
+object SmartUpdateUsagesCollector : CounterUsagesCollector() {
+  private val GROUP = EventLogGroup("smart.update", 1)
+  private val updatedEvent = GROUP.registerEvent("vcs.update", EventFields.DurationMs)
+  private val buildEvent = GROUP.registerEvent("build.project", EventFields.DurationMs, EventFields.Boolean("success"))
 
-    fun logUpdate(duration: Long) {
-      updatedEvent.log(duration)
-    }
-
-    fun logBuild(duration: Long, success: Boolean) {
-      buildEvent.log(duration, success)
-    }
+  fun logUpdate(duration: Long) {
+    updatedEvent.log(duration)
   }
+
+  fun logBuild(duration: Long, success: Boolean) {
+    buildEvent.log(duration, success)
+  }
+
   override fun getGroup(): EventLogGroup {
     return GROUP
   }

platform/vcs-impl/src/com/intellij/openapi/vcs/changes/actions/VcsStatisticsCollector.kt

@@ -10,83 +10,72 @@ import com.intellij.openapi.vcs.AbstractVcs
 import com.intellij.openapi.vcs.FilePath
 import com.intellij.openapi.vcs.changes.Change
 
-class VcsStatisticsCollector : CounterUsagesCollector() {
-  companion object {
-    @JvmField
-    val GROUP = EventLogGroup("vcs", 13)
+object VcsStatisticsCollector : CounterUsagesCollector() {
+  val GROUP = EventLogGroup("vcs", 13)
 
-    @JvmField
-    val UPDATE_ACTIVITY = GROUP.registerIdeActivity("update")
+  @JvmField
+  val UPDATE_ACTIVITY = GROUP.registerIdeActivity("update")
+  val FETCH_ACTIVITY = GROUP.registerIdeActivity("fetch")
+  val COMMIT_ACTIVITY = GROUP.registerIdeActivity("commit")
 
-    @JvmField
-    val FETCH_ACTIVITY = GROUP.registerIdeActivity("fetch")
+  private val WAS_UPDATING_BEFORE = EventFields.Boolean("wasUpdatingBefore")
+  private val CHANGES_DELTA = EventFields.Int("changesDelta")
+  private val UNVERSIONED_DELTA = EventFields.Int("unversionedDelta")
+  private val CHANGES_VIEW_REFRESH = GROUP.registerVarargEvent("changes.view.refresh", WAS_UPDATING_BEFORE, CHANGES_DELTA,
+                                                               UNVERSIONED_DELTA)
 
-    @JvmField
-    val COMMIT_ACTIVITY = GROUP.registerIdeActivity("commit")
+  val NON_MODAL_COMMIT_STATE_CHANGED = GROUP.registerEvent("non.modal.commit.state.changed", EventFields.Enabled)
 
-    private val WAS_UPDATING_BEFORE = EventFields.Boolean("wasUpdatingBefore")
-    private val CHANGES_DELTA = EventFields.Int("changesDelta")
-    private val UNVERSIONED_DELTA = EventFields.Int("unversionedDelta")
-    private val CHANGES_VIEW_REFRESH = GROUP.registerVarargEvent("changes.view.refresh", WAS_UPDATING_BEFORE, CHANGES_DELTA,
-                                                                 UNVERSIONED_DELTA)
+  val CLONE = GROUP.registerEvent("clone.invoked", EventFields.Class("clone_dialog_extension"))
+  @JvmField
+  val CLONED_PROJECT_OPENED = GROUP.registerEvent("cloned.project.opened")
 
-    val NON_MODAL_COMMIT_STATE_CHANGED = GROUP.registerEvent("non.modal.commit.state.changed", EventFields.Enabled)
+  private val VCS_FIELD = EventFields.StringValidatedByEnum("vcs", "vcs")
+  private val IS_FULL_REFRESH_FIELD = EventFields.Boolean("is_full_refresh")
+  private val CLM_REFRESH = GROUP.registerIdeActivity(activityName = "clm.refresh",
+                                                      startEventAdditionalFields = arrayOf(VCS_FIELD, IS_FULL_REFRESH_FIELD))
 
-    @JvmField
-    val CLONE = GROUP.registerEvent("clone.invoked", EventFields.Class("clone_dialog_extension"))
+  @JvmStatic
+  fun logRefreshActionPerformed(project: Project,
+                                changesBefore: Collection<Change>,
+                                changesAfter: Collection<Change>,
+                                unversionedBefore: Collection<FilePath>,
+                                unversionedAfter: Collection<FilePath>,
+                                wasUpdatingBefore: Boolean) {
+    val changesDelta = computeDelta(changesBefore, changesAfter)
+    val unversionedDelta = computeDelta(unversionedBefore, unversionedAfter)
 
-    @JvmField
-    val CLONED_PROJECT_OPENED = GROUP.registerEvent("cloned.project.opened")
+    CHANGES_VIEW_REFRESH.log(project,
+                             WAS_UPDATING_BEFORE.with(wasUpdatingBefore),
+                             CHANGES_DELTA.with(changesDelta),
+                             UNVERSIONED_DELTA.with(unversionedDelta))
+  }
 
-    private val VCS_FIELD = EventFields.StringValidatedByEnum("vcs", "vcs")
-    private val IS_FULL_REFRESH_FIELD = EventFields.Boolean("is_full_refresh")
-    private val CLM_REFRESH = GROUP.registerIdeActivity(activityName = "clm.refresh",
-                                                        startEventAdditionalFields = arrayOf(VCS_FIELD, IS_FULL_REFRESH_FIELD))
-
-    @JvmStatic
-    fun logRefreshActionPerformed(project: Project,
-                                  changesBefore: Collection<Change>,
-                                  changesAfter: Collection<Change>,
-                                  unversionedBefore: Collection<FilePath>,
-                                  unversionedAfter: Collection<FilePath>,
-                                  wasUpdatingBefore: Boolean) {
-      val changesDelta = computeDelta(changesBefore, changesAfter)
-      val unversionedDelta = computeDelta(unversionedBefore, unversionedAfter)
-
-      CHANGES_VIEW_REFRESH.log(project,
-                               WAS_UPDATING_BEFORE.with(wasUpdatingBefore),
-                               CHANGES_DELTA.with(changesDelta),
-                               UNVERSIONED_DELTA.with(unversionedDelta))
-    }
-
-    @JvmStatic
-    fun logClmRefresh(project: Project, vcs: AbstractVcs, everythingDirty: Boolean): StructuredIdeActivity {
-      return CLM_REFRESH.started(project) {
-        listOf(VCS_FIELD.with(vcs.name),
-               IS_FULL_REFRESH_FIELD.with(everythingDirty))
-      }
-    }
-
-    private fun <T> computeDelta(before: Collection<T>, after: Collection<T>): Int {
-      val beforeSet = before.toHashSet()
-      val afterSet = after.toHashSet()
-
-      var result = 0
-      for (value in beforeSet) {
-        if (!afterSet.contains(value)) {
-          result++
-        }
-      }
-      for (value in afterSet) {
-        if (!beforeSet.contains(value)) {
-          result++
-        }
-      }
-      return result
+  @JvmStatic
+  fun logClmRefresh(project: Project, vcs: AbstractVcs, everythingDirty: Boolean): StructuredIdeActivity {
+    return CLM_REFRESH.started(project) {
+      listOf(VCS_FIELD.with(vcs.name),
+             IS_FULL_REFRESH_FIELD.with(everythingDirty))
     }
   }
 
-  override fun getGroup(): EventLogGroup {
-    return GROUP
+  private fun <T> computeDelta(before: Collection<T>, after: Collection<T>): Int {
+    val beforeSet = before.toHashSet()
+    val afterSet = after.toHashSet()
+
+    var result = 0
+    for (value in beforeSet) {
+      if (!afterSet.contains(value)) {
+        result++
+      }
+    }
+    for (value in afterSet) {
+      if (!beforeSet.contains(value)) {
+        result++
+      }
+    }
+    return result
   }
+
+  override fun getGroup(): EventLogGroup = GROUP
 }

platform/vcs-impl/src/com/intellij/util/ui/cloneDialog/VcsCloneDialog.kt

@@ -8,7 +8,7 @@ import com.intellij.openapi.ui.ValidationInfo
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.vcs.CheckoutProvider
 import com.intellij.openapi.vcs.VcsBundle
-import com.intellij.openapi.vcs.changes.actions.VcsStatisticsCollector.Companion.CLONE
+import com.intellij.openapi.vcs.changes.actions.VcsStatisticsCollector.CLONE
 import com.intellij.openapi.vcs.ui.VcsCloneComponent
 import com.intellij.openapi.vcs.ui.cloneDialog.VcsCloneDialogComponentStateListener
 import com.intellij.openapi.vcs.ui.cloneDialog.VcsCloneDialogExtension

platform/vcs-impl/src/com/intellij/vcs/commit/AbstractCommitter.kt

@@ -12,7 +12,7 @@ import com.intellij.openapi.util.NlsSafe
 import com.intellij.openapi.vcs.ProjectLevelVcsManager
 import com.intellij.openapi.vcs.VcsBundle.message
 import com.intellij.openapi.vcs.changes.ChangeListManagerImpl
-import com.intellij.openapi.vcs.changes.actions.VcsStatisticsCollector.Companion.COMMIT_ACTIVITY
+import com.intellij.openapi.vcs.changes.actions.VcsStatisticsCollector.COMMIT_ACTIVITY
 import com.intellij.util.concurrency.Semaphore
 import org.jetbrains.annotations.Nls
 

platform/vcs-impl/src/com/intellij/vcs/commit/NonModalCommitUsagesCollector.kt

@@ -5,7 +5,7 @@ import com.intellij.internal.statistic.beans.MetricEvent
 import com.intellij.internal.statistic.beans.addBoolIfDiffers
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vcs.VcsApplicationSettings
-import com.intellij.openapi.vcs.changes.actions.VcsStatisticsCollector.Companion.NON_MODAL_COMMIT_STATE_CHANGED
+import com.intellij.openapi.vcs.changes.actions.VcsStatisticsCollector.NON_MODAL_COMMIT_STATE_CHANGED
 import com.intellij.openapi.vcs.statistics.VcsApplicationOptionsUsagesCollector
 
 private val appSettings get() = VcsApplicationSettings.getInstance()

plugins/editorconfig/src/org/editorconfig/configmanagement/EditorConfigUsagesCollector.kt

@@ -13,7 +13,7 @@ import org.editorconfig.configmanagement.extended.EditorConfigIntellijNameUtil
 import org.editorconfig.configmanagement.extended.EditorConfigPropertyKind
 import org.editorconfig.configmanagement.extended.IntellijPropertyKindMap
 
-class EditorConfigUsagesCollector private constructor() : CounterUsagesCollector() {
+object EditorConfigUsagesCollector : CounterUsagesCollector() {
   private enum class OptionType {
     Standard, IntelliJ, Other
   }
@@ -22,31 +22,29 @@ class EditorConfigUsagesCollector private constructor() : CounterUsagesCollector
     return GROUP
   }
 
-  companion object {
-    private val GROUP = EventLogGroup("editorconfig", 2)
-    private val EDITOR_CONFIG_USED: EventId3<FileType, OptionType, Int> =
-      GROUP.registerEvent("editorconfig.applied", EventFields.FileType,
-                          Enum("property", OptionType::class.java),
-                          EventFields.Count)
+  private val GROUP = EventLogGroup("editorconfig", 2)
+  private val EDITOR_CONFIG_USED: EventId3<FileType, OptionType, Int> =
+    GROUP.registerEvent("editorconfig.applied", EventFields.FileType,
+                        Enum("property", OptionType::class.java),
+                        EventFields.Count)
 
-    fun logEditorConfigUsed(file: PsiFile, properties: ResourceProperties) {
-      properties.properties.keys
-        .groupingBy { getOptionType(it) }
-        .eachCount()
-        .forEach { (optionType, count) -> EDITOR_CONFIG_USED.log(file.project, file.fileType, optionType, count) }
+  fun logEditorConfigUsed(file: PsiFile, properties: ResourceProperties) {
+    properties.properties.keys
+      .groupingBy { getOptionType(it) }
+      .eachCount()
+      .forEach { (optionType, count) -> EDITOR_CONFIG_USED.log(file.project, file.fileType, optionType, count) }
+  }
+
+  private fun getOptionType(optionKey: String): OptionType {
+    val propertyKind = IntellijPropertyKindMap.getPropertyKind(optionKey)
+    return if (propertyKind == EditorConfigPropertyKind.EDITOR_CONFIG_STANDARD) {
+      OptionType.Standard
     }
-
-    private fun getOptionType(optionKey: String): OptionType {
-      val propertyKind = IntellijPropertyKindMap.getPropertyKind(optionKey)
-      return if (propertyKind == EditorConfigPropertyKind.EDITOR_CONFIG_STANDARD) {
-        OptionType.Standard
-      }
-      else if (optionKey.startsWith(EditorConfigIntellijNameUtil.IDE_PREFIX)) {
-        OptionType.IntelliJ
-      }
-      else {
-        OptionType.Other
-      }
+    else if (optionKey.startsWith(EditorConfigIntellijNameUtil.IDE_PREFIX)) {
+      OptionType.IntelliJ
+    }
+    else {
+      OptionType.Other
     }
   }
 }

plugins/git4idea/src/git4idea/GitRefreshUsageCollector.kt

@@ -7,30 +7,28 @@ import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 import com.intellij.openapi.project.Project
 
-class GitRefreshUsageCollector : CounterUsagesCollector() {
+object GitRefreshUsageCollector : CounterUsagesCollector() {
   override fun getGroup(): EventLogGroup = GROUP
 
-  companion object {
-    private val GROUP: EventLogGroup = EventLogGroup("git.status.refresh", 1)
+  private val GROUP: EventLogGroup = EventLogGroup("git.status.refresh", 1)
 
-    private val IS_FULL_REFRESH_FIELD = EventFields.Boolean("is_full_refresh")
-    private val STATUS_REFRESH = GROUP.registerIdeActivity(activityName = "status.refresh",
-                                                           startEventAdditionalFields = arrayOf(IS_FULL_REFRESH_FIELD))
-    private val UNTRACKED_REFRESH = GROUP.registerIdeActivity(activityName = "untracked.refresh",
-                                                              startEventAdditionalFields = arrayOf(IS_FULL_REFRESH_FIELD))
+  private val IS_FULL_REFRESH_FIELD = EventFields.Boolean("is_full_refresh")
+  private val STATUS_REFRESH = GROUP.registerIdeActivity(activityName = "status.refresh",
+                                                         startEventAdditionalFields = arrayOf(IS_FULL_REFRESH_FIELD))
+  private val UNTRACKED_REFRESH = GROUP.registerIdeActivity(activityName = "untracked.refresh",
+                                                            startEventAdditionalFields = arrayOf(IS_FULL_REFRESH_FIELD))
 
-    @JvmStatic
-    fun logStatusRefresh(project: Project, everythingDirty: Boolean): StructuredIdeActivity {
-      return STATUS_REFRESH.started(project) {
-        listOf(IS_FULL_REFRESH_FIELD.with(everythingDirty))
-      }
+  @JvmStatic
+  fun logStatusRefresh(project: Project, everythingDirty: Boolean): StructuredIdeActivity {
+    return STATUS_REFRESH.started(project) {
+      listOf(IS_FULL_REFRESH_FIELD.with(everythingDirty))
     }
+  }
 
-    @JvmStatic
-    fun logUntrackedRefresh(project: Project, everythingDirty: Boolean): StructuredIdeActivity {
-      return UNTRACKED_REFRESH.started(project) {
-        listOf(IS_FULL_REFRESH_FIELD.with(everythingDirty))
-      }
+  @JvmStatic
+  fun logUntrackedRefresh(project: Project, everythingDirty: Boolean): StructuredIdeActivity {
+    return UNTRACKED_REFRESH.started(project) {
+      listOf(IS_FULL_REFRESH_FIELD.with(everythingDirty))
     }
   }
 }

plugins/gradle-maven/src/org/jetbrains/plugins/gradle/integrations/maven/codeInsight/completion/GradleMapStyleInsertHandler.kt

@@ -37,8 +37,8 @@ abstract class GradleMapStyleInsertHandler : InsertHandler<LookupElement> {
       groupId = artifactInfo.groupId,
       artifactId = artifactInfo.artifactId,
       version = artifactInfo.version ?: "",
-      buildSystem = MavenDependencyInsertionCollector.Companion.BuildSystem.GRADLE,
-      dependencyDeclarationNotation = MavenDependencyInsertionCollector.Companion.DependencyDeclarationNotation.GRADLE_MAP_STYLE,
+      buildSystem = MavenDependencyInsertionCollector.BuildSystem.GRADLE,
+      dependencyDeclarationNotation = MavenDependencyInsertionCollector.DependencyDeclarationNotation.GRADLE_MAP_STYLE,
       completionPrefixLength = completionPrefix.length,
       selectedLookupIndex = selectedLookupIndex
     )

plugins/gradle-maven/src/org/jetbrains/plugins/gradle/integrations/maven/codeInsight/completion/GradleStringStyleHandler.kt

@@ -34,8 +34,8 @@ abstract class ReplaceEndInsertHandler : InsertHandler<LookupElement> {
       groupId = artifactInfo.groupId,
       artifactId = artifactInfo.artifactId,
       version = artifactInfo.version ?: "",
-      buildSystem = MavenDependencyInsertionCollector.Companion.BuildSystem.GRADLE,
-      dependencyDeclarationNotation = MavenDependencyInsertionCollector.Companion.DependencyDeclarationNotation.GRADLE_STRING_STYLE,
+      buildSystem = MavenDependencyInsertionCollector.BuildSystem.GRADLE,
+      dependencyDeclarationNotation = MavenDependencyInsertionCollector.DependencyDeclarationNotation.GRADLE_STRING_STYLE,
       completionPrefixLength = completionPrefix.length,
       selectedLookupIndex = selectedLookupIndex
     )

plugins/gradle/java/src/service/project/wizard/statistics/GradleNewProjectWizardCollector.kt

@@ -1,9 +1,9 @@
 // Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package org.jetbrains.plugins.gradle.service.project.wizard.statistics
 
-import com.intellij.ide.projectWizard.NewProjectWizardCollector.Companion.GROUP
-import com.intellij.ide.projectWizard.NewProjectWizardCollector.Companion.buildSystemFields
-import com.intellij.ide.projectWizard.NewProjectWizardCollector.Companion.logBuildSystemEvent
+import com.intellij.ide.projectWizard.NewProjectWizardCollector.GROUP
+import com.intellij.ide.projectWizard.NewProjectWizardCollector.buildSystemFields
+import com.intellij.ide.projectWizard.NewProjectWizardCollector.logBuildSystemEvent
 import com.intellij.ide.wizard.NewProjectWizardStep
 import com.intellij.internal.statistic.eventLog.EventLogGroup
 import com.intellij.internal.statistic.eventLog.events.EventFields

plugins/ide-features-trainer/src/training/onboarding/OnboardingTipsStatistics.kt

@@ -6,24 +6,32 @@ import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 import com.intellij.openapi.project.Project
 
-internal class OnboardingTipsStatistics : CounterUsagesCollector() {
+internal object OnboardingTipsStatistics : CounterUsagesCollector() {
   override fun getGroup() = GROUP
 
-  companion object {
-    private val GROUP = EventLogGroup("onboarding.tips.statistics", 4)
+  private val GROUP = EventLogGroup("onboarding.tips.statistics", 4)
 
-    private val projectsWithTipsField = EventFields.Int("projects_with_tips")
-    private val firstTimeActionUsedField = EventFields.Boolean("first_time_used")
-    private val promotedActionField = EventFields.String("action_id", promotedActions)
+  private val projectsWithTipsField = EventFields.Int("projects_with_tips")
+  private val firstTimeActionUsedField = EventFields.Boolean("first_time_used")
+  private val promotedActionField = EventFields.String("action_id", promotedActions)
 
-    private val onboardingTipsInstalledEvent = GROUP.registerEvent("onboarding.tips.installed", projectsWithTipsField)
-    private val disableOnboardingTipsEvent = GROUP.registerEvent("tips.disabled", projectsWithTipsField)
-    private val hideOnboardingTipsDisableProposalEvent = GROUP.registerEvent("hide.disable.proposal", projectsWithTipsField)
-    private val promotedActionUsedEvent = GROUP.registerEvent("promoted.action.used", promotedActionField, projectsWithTipsField, firstTimeActionUsedField)
+  private val onboardingTipsInstalledEvent = GROUP.registerEvent("onboarding.tips.installed", projectsWithTipsField)
+  private val disableOnboardingTipsEvent = GROUP.registerEvent("tips.disabled", projectsWithTipsField)
+  private val hideOnboardingTipsDisableProposalEvent = GROUP.registerEvent("hide.disable.proposal", projectsWithTipsField)
+  private val promotedActionUsedEvent = GROUP.registerEvent("promoted.action.used", promotedActionField, projectsWithTipsField,
+                                                            firstTimeActionUsedField)
 
-    @JvmStatic fun logOnboardingTipsInstalled(project: Project?, projectsWithTips: Int) = onboardingTipsInstalledEvent.log(project, projectsWithTips)
-    @JvmStatic fun logDisableOnboardingTips(project: Project?, projectsWithTips: Int) = disableOnboardingTipsEvent.log(project, projectsWithTips)
-    @JvmStatic fun logHideOnboardingTipsDisableProposal(project: Project?, projectsWithTips: Int) = hideOnboardingTipsDisableProposalEvent.log(project, projectsWithTips)
-    @JvmStatic fun logPromotedActionUsedEvent(project: Project?, actionId: String, projectsWithTips: Int, firstTimeUsed: Boolean) = promotedActionUsedEvent.log(project, actionId, projectsWithTips, firstTimeUsed)
-  }
+  @JvmStatic
+  fun logOnboardingTipsInstalled(project: Project?, projectsWithTips: Int) = onboardingTipsInstalledEvent.log(project, projectsWithTips)
+  @JvmStatic
+  fun logDisableOnboardingTips(project: Project?, projectsWithTips: Int) = disableOnboardingTipsEvent.log(project, projectsWithTips)
+  @JvmStatic
+  fun logHideOnboardingTipsDisableProposal(project: Project?, projectsWithTips: Int) = hideOnboardingTipsDisableProposalEvent.log(project,
+                                                                                                                                  projectsWithTips)
+
+  @JvmStatic
+  fun logPromotedActionUsedEvent(project: Project?,
+                                 actionId: String,
+                                 projectsWithTips: Int,
+                                 firstTimeUsed: Boolean) = promotedActionUsedEvent.log(project, actionId, projectsWithTips, firstTimeUsed)
 }

plugins/kotlin/base/statistics/src/org/jetbrains/kotlin/idea/statistics/WizardStatsService.kt

@@ -16,411 +16,409 @@ interface WizardStats {
     fun toPairs(): ArrayList<EventPair<*>>
 }
 
-class WizardStatsService : CounterUsagesCollector() {
+object WizardStatsService : CounterUsagesCollector() {
     override fun getGroup(): EventLogGroup = GROUP
 
-    companion object {
+    // Collector ID
+    private val GROUP = EventLogGroup("kotlin.ide.new.project", 11)
 
-        // Collector ID
-        private val GROUP = EventLogGroup("kotlin.ide.new.project", 11)
+    // Whitelisted values for the events fields
+    private val allowedProjectTemplates = listOf(
+        // Modules
+        "JVM_|_IDEA",
+        "JS_|_IDEA",
+        // Java and Gradle groups
+        "Kotlin/JVM",
+        // Gradle group
+        "Kotlin/JS",
+        "Kotlin/JS_for_browser",
+        "Kotlin/JS_for_Node.js",
+        "Kotlin/Multiplatform_as_framework",
+        "Kotlin/Multiplatform",
+        // Kotlin group
+        "backendApplication",
+        "consoleApplication",
+        "multiplatformMobileApplication",
+        "multiplatformMobileLibrary",
+        "multiplatformApplication",
+        "multiplatformLibrary",
+        "nativeApplication",
+        "frontendApplication",
+        "fullStackWebApplication",
+        "nodejsApplication",
+        "reactApplication",
+        "simpleWasmApplication",
+        "none",
+        // AppCode KMM
+        "multiplatformMobileApplicationUsingAppleGradlePlugin",
+        "multiplatformMobileApplicationUsingHybridProject",
+    )
+    private val allowedModuleTemplates = listOf(
+        "consoleJvmApp",
+        "ktorServer",
+        "mobileMppModule",
+        "nativeConsoleApp",
+        "reactJsClient",
+        "simpleJsClient",
+        "simpleNodeJs",
+        "simpleWasmClient",
+        "none",
+    )
 
-        // Whitelisted values for the events fields
-        private val allowedProjectTemplates = listOf( // Modules
-            "JVM_|_IDEA",
-            "JS_|_IDEA",
-            // Java and Gradle groups
-            "Kotlin/JVM",
-            // Gradle group
-            "Kotlin/JS",
-            "Kotlin/JS_for_browser",
-            "Kotlin/JS_for_Node.js",
-            "Kotlin/Multiplatform_as_framework",
-            "Kotlin/Multiplatform",
-            // Kotlin group
-            "backendApplication",
-            "consoleApplication",
-            "multiplatformMobileApplication",
-            "multiplatformMobileLibrary",
-            "multiplatformApplication",
-            "multiplatformLibrary",
-            "nativeApplication",
-            "frontendApplication",
-            "fullStackWebApplication",
-            "nodejsApplication",
-            "reactApplication",
-            "simpleWasmApplication",
-            "none",
-            // AppCode KMM
-            "multiplatformMobileApplicationUsingAppleGradlePlugin",
-            "multiplatformMobileApplicationUsingHybridProject",
-        )
-        private val allowedModuleTemplates = listOf(
-            "consoleJvmApp",
-            "ktorServer",
-            "mobileMppModule",
-            "nativeConsoleApp",
-            "reactJsClient",
-            "simpleJsClient",
-            "simpleNodeJs",
-            "simpleWasmClient",
-            "none",
-        )
+    private val allowedWizardsGroups = listOf("Java", "Kotlin", "Gradle")
+    private val allowedBuildSystems = listOf(
+        "gradleKotlin",
+        "gradleGroovy",
+        "jps",
+        "maven"
+    )
 
-        private val allowedWizardsGroups = listOf("Java", "Kotlin", "Gradle")
-        private val allowedBuildSystems = listOf(
-            "gradleKotlin",
-            "gradleGroovy",
-            "jps",
-            "maven"
-        )
-
-        private val settings = Settings(
-            SettingIdWithPossibleValues.Enum(
-                id = "buildSystem.type",
-                values = listOf(
-                    "GradleKotlinDsl",
-                    "GradleGroovyDsl",
-                    "Jps",
-                    "Maven",
-                )
-            ),
-
-            SettingIdWithPossibleValues.Enum(
-                id = "testFramework",
-                values = listOf(
-                    "NONE",
-                    "JUNIT4",
-                    "JUNIT5",
-                    "TEST_NG",
-                    "JS",
-                    "COMMON",
-                )
-            ),
-
-            SettingIdWithPossibleValues.Enum(
-                id = "targetJvmVersion",
-                values = listOf(
-                    "JVM_1_6",
-                    "JVM_1_8",
-                    "JVM_9",
-                    "JVM_10",
-                    "JVM_11",
-                    "JVM_12",
-                    "JVM_13",
-                )
-            ),
-
-            SettingIdWithPossibleValues.Enum(
-                id = "androidPlugin",
-                values = listOf(
-                    "APPLICATION",
-                    "LIBRARY",
-                )
-            ),
-
-            SettingIdWithPossibleValues.Enum(
-                id = "serverEngine",
-                values = listOf(
-                    "Netty",
-                    "Tomcat",
-                    "Jetty",
-                )
-            ),
-
-            SettingIdWithPossibleValues.Enum(
-                id = "kind",
-                idToLog = "js.project.kind",
-                values = listOf(
-                    "LIBRARY",
-                    "APPLICATION",
-                )
-            ),
-
-            SettingIdWithPossibleValues.Enum(
-                id = "compiler",
-                idToLog = "js.compiler",
-                values = listOf(
-                    "IR",
-                    "LEGACY",
-                    "BOTH",
-                )
-            ),
-            SettingIdWithPossibleValues.Enum(
-                id = "projectTemplates.template",
-                values = allowedProjectTemplates
-            ),
-            SettingIdWithPossibleValues.Enum(
-                id = "module.template",
-                values = allowedModuleTemplates
-            ),
-            SettingIdWithPossibleValues.Enum(
-                id = "buildSystem.type",
-                values = allowedBuildSystems
-            ),
-
-            SettingIdWithPossibleValues.Boolean(
-                id = "javaSupport",
-                idToLog = "jvm.javaSupport"
-            ),
-            SettingIdWithPossibleValues.Boolean(
-                id = "cssSupport",
-                idToLog = "js.cssSupport"
-            ),
-            SettingIdWithPossibleValues.Boolean(
-                id = "useReactRouterDom",
-                idToLog = "js.useReactRouterDom"
-            ),
-            SettingIdWithPossibleValues.Boolean(
-                id = "useReactRedux",
-                idToLog = "js.useReactRedux"
-            ),
-        )
-
-        private val allowedModuleTypes = listOf(
-            "androidNativeArm32Target",
-            "androidNativeArm64Target",
-            "iosArm32Target",
-            "iosArm64Target",
-            "iosX64Target",
-            "iosTarget",
-            "linuxArm32HfpTarget",
-            "linuxMips32Target",
-            "linuxMipsel32Target",
-            "linuxX64Target",
-            "macosX64Target",
-            "mingwX64Target",
-            "mingwX86Target",
-            "nativeForCurrentSystem",
-            "jsBrowser",
-            "jsNode",
-            "commonTarget",
-            "jvmTarget",
-            "androidTarget",
-            "multiplatform",
-            "JVM_Module",
-            "android",
-            "IOS_Module",
-            "jsBrowserSinglePlatform",
-            "jsNodeSinglePlatform",
-            "wasmSimple",
-        )
-
-
-        private val settingIdField = EventFields.String("setting_id", settings.allowedIds)
-        private val settingValueField = EventFields.String("setting_value", settings.possibleValues)
-
-        // Event fields
-        val groupField = EventFields.String("group", allowedWizardsGroups)
-        val projectTemplateField = EventFields.String("project_template", allowedProjectTemplates)
-        val buildSystemField = EventFields.String("build_system", allowedBuildSystems)
-
-        val modulesCreatedField = EventFields.Int("modules_created")
-        val modulesRemovedField = EventFields.Int("modules_removed")
-        val moduleTemplateChangedField = EventFields.Int("module_template_changed")
-
-        private val moduleTemplateField = EventFields.String("module_template", allowedModuleTemplates)
-        private val sessionIdField = EventFields.Int("session_id")
-
-        val modulesListField = StringListEventField.ValidatedByAllowedValues("project_modules_list", allowedModuleTypes)
-
-        private val moduleTypeField = EventFields.String("module_type", allowedModuleTypes)
-
-        private val pluginInfoField = EventFields.PluginInfo.with(getPluginInfoById(KotlinIdePlugin.id))
-
-        // Events
-        private val projectCreatedEvent = GROUP.registerVarargEvent(
-            "project_created",
-            groupField,
-            projectTemplateField,
-            buildSystemField,
-            modulesCreatedField,
-            modulesRemovedField,
-            moduleTemplateChangedField,
-            modulesListField,
-            sessionIdField,
-            EventFields.PluginInfo
-        )
-
-        private val projectOpenedByHyperlinkEvent = GROUP.registerVarargEvent(
-            "wizard_opened_by_hyperlink",
-            projectTemplateField,
-            sessionIdField,
-            EventFields.PluginInfo
-        )
-
-        private val moduleTemplateCreatedEvent = GROUP.registerVarargEvent(
-            "module_template_created",
-            projectTemplateField,
-            moduleTemplateField,
-            sessionIdField,
-            EventFields.PluginInfo
-        )
-
-        private val settingValueChangedEvent = GROUP.registerVarargEvent(
-            "setting_value_changed",
-            settingIdField,
-            settingValueField,
-            sessionIdField,
-            EventFields.PluginInfo,
-        )
-
-        private val jdkChangedEvent = GROUP.registerVarargEvent(
-            "jdk_changed",
-            sessionIdField,
-            EventFields.PluginInfo,
-        )
-
-        private val nextClickedEvent = GROUP.registerVarargEvent(
-            "next_clicked",
-            sessionIdField,
-            EventFields.PluginInfo,
-        )
-
-        private val prevClickedEvent = GROUP.registerVarargEvent(
-            "prev_clicked",
-            sessionIdField,
-            EventFields.PluginInfo,
-        )
-
-        private val moduleCreatedEvent = GROUP.registerVarargEvent(
-            "module_created",
-            moduleTypeField,
-            sessionIdField,
-            EventFields.PluginInfo,
-        )
-
-        private val moduleRemovedEvent = GROUP.registerVarargEvent(
-            "module_removed",
-            moduleTypeField,
-            sessionIdField,
-            EventFields.PluginInfo,
-        )
-
-        // Log functions
-        fun logDataOnProjectGenerated(session: WizardLoggingSession?, project: Project?, projectCreationStats: ProjectCreationStats) {
-            projectCreatedEvent.log(
-                project,
-                *projectCreationStats.toPairs().toTypedArray(),
-                *session?.let { arrayOf(sessionIdField with it.id) }.orEmpty(),
-                pluginInfoField
+    private val settings = Settings(
+        SettingIdWithPossibleValues.Enum(
+            id = "buildSystem.type",
+            values = listOf(
+                "GradleKotlinDsl",
+                "GradleGroovyDsl",
+                "Jps",
+                "Maven",
             )
-        }
+        ),
 
-        fun logDataOnSettingValueChanged(
-            session: WizardLoggingSession,
-            settingId: String,
-            settingValue: String
-        ) {
-            val idToLog = settings.getIdToLog(settingId) ?: return
-            settingValueChangedEvent.log(
-                settingIdField with idToLog,
-                settingValueField with settingValue,
-                sessionIdField with session.id,
-                pluginInfoField,
+        SettingIdWithPossibleValues.Enum(
+            id = "testFramework",
+            values = listOf(
+                "NONE",
+                "JUNIT4",
+                "JUNIT5",
+                "TEST_NG",
+                "JS",
+                "COMMON",
             )
-        }
+        ),
 
-        fun logDataOnJdkChanged(
-            session: WizardLoggingSession,
-        ) {
-            jdkChangedEvent.log(
-                sessionIdField with session.id,
-                pluginInfoField,
+        SettingIdWithPossibleValues.Enum(
+            id = "targetJvmVersion",
+            values = listOf(
+                "JVM_1_6",
+                "JVM_1_8",
+                "JVM_9",
+                "JVM_10",
+                "JVM_11",
+                "JVM_12",
+                "JVM_13",
             )
-        }
+        ),
 
-        fun logDataOnNextClicked(
-            session: WizardLoggingSession,
-        ) {
-            nextClickedEvent.log(
-                sessionIdField with session.id,
-                pluginInfoField,
+        SettingIdWithPossibleValues.Enum(
+            id = "androidPlugin",
+            values = listOf(
+                "APPLICATION",
+                "LIBRARY",
             )
-        }
+        ),
 
-        fun logDataOnPrevClicked(
-            session: WizardLoggingSession,
-        ) {
-            prevClickedEvent.log(
-                sessionIdField with session.id,
-                pluginInfoField,
+        SettingIdWithPossibleValues.Enum(
+            id = "serverEngine",
+            values = listOf(
+                "Netty",
+                "Tomcat",
+                "Jetty",
             )
-        }
+        ),
 
-        fun logOnModuleCreated(
-            session: WizardLoggingSession,
-            moduleType: String,
-        ) {
-            moduleCreatedEvent.log(
-                sessionIdField with session.id,
-                moduleTypeField with moduleType.withSpacesRemoved(),
-                pluginInfoField,
+        SettingIdWithPossibleValues.Enum(
+            id = "kind",
+            idToLog = "js.project.kind",
+            values = listOf(
+                "LIBRARY",
+                "APPLICATION",
             )
-        }
+        ),
 
-        fun logOnModuleRemoved(
-            session: WizardLoggingSession,
-            moduleType: String,
-        ) {
-            moduleRemovedEvent.log(
-                sessionIdField with session.id,
-                moduleTypeField with moduleType.withSpacesRemoved(),
-                pluginInfoField,
+        SettingIdWithPossibleValues.Enum(
+            id = "compiler",
+            idToLog = "js.compiler",
+            values = listOf(
+                "IR",
+                "LEGACY",
+                "BOTH",
             )
-        }
+        ),
+        SettingIdWithPossibleValues.Enum(
+            id = "projectTemplates.template",
+            values = allowedProjectTemplates
+        ),
+        SettingIdWithPossibleValues.Enum(
+            id = "module.template",
+            values = allowedModuleTemplates
+        ),
+        SettingIdWithPossibleValues.Enum(
+            id = "buildSystem.type",
+            values = allowedBuildSystems
+        ),
+
+        SettingIdWithPossibleValues.Boolean(
+            id = "javaSupport",
+            idToLog = "jvm.javaSupport"
+        ),
+        SettingIdWithPossibleValues.Boolean(
+            id = "cssSupport",
+            idToLog = "js.cssSupport"
+        ),
+        SettingIdWithPossibleValues.Boolean(
+            id = "useReactRouterDom",
+            idToLog = "js.useReactRouterDom"
+        ),
+        SettingIdWithPossibleValues.Boolean(
+            id = "useReactRedux",
+            idToLog = "js.useReactRedux"
+        ),
+    )
+
+    private val allowedModuleTypes = listOf(
+        "androidNativeArm32Target",
+        "androidNativeArm64Target",
+        "iosArm32Target",
+        "iosArm64Target",
+        "iosX64Target",
+        "iosTarget",
+        "linuxArm32HfpTarget",
+        "linuxMips32Target",
+        "linuxMipsel32Target",
+        "linuxX64Target",
+        "macosX64Target",
+        "mingwX64Target",
+        "mingwX86Target",
+        "nativeForCurrentSystem",
+        "jsBrowser",
+        "jsNode",
+        "commonTarget",
+        "jvmTarget",
+        "androidTarget",
+        "multiplatform",
+        "JVM_Module",
+        "android",
+        "IOS_Module",
+        "jsBrowserSinglePlatform",
+        "jsNodeSinglePlatform",
+        "wasmSimple",
+    )
 
 
-        fun logDataOnProjectGenerated(
-            session: WizardLoggingSession?,
-            project: Project?,
-            projectCreationStats: ProjectCreationStats,
-            uiEditorUsageStats: UiEditorUsageStats
-        ) {
-            projectCreatedEvent.log(
-                project,
-                *projectCreationStats.toPairs().toTypedArray(),
-                *uiEditorUsageStats.toPairs().toTypedArray(),
-                *session?.let { arrayOf(sessionIdField with it.id) }.orEmpty(),
-                pluginInfoField
-            )
-        }
+    private val settingIdField = EventFields.String("setting_id", settings.allowedIds)
+    private val settingValueField = EventFields.String("setting_value", settings.possibleValues)
 
-        fun logUsedModuleTemplatesOnNewWizardProjectCreated(
-            session: WizardLoggingSession,
-            project: Project?,
-            projectTemplateId: String,
-            moduleTemplates: List<String>
-        ) {
-            moduleTemplates.forEach { moduleTemplateId ->
-                logModuleTemplateCreation(session, project, projectTemplateId, moduleTemplateId)
-            }
-        }
+    // Event fields
+    val groupField = EventFields.String("group", allowedWizardsGroups)
+    val projectTemplateField = EventFields.String("project_template", allowedProjectTemplates)
+    val buildSystemField = EventFields.String("build_system", allowedBuildSystems)
 
-        fun logWizardOpenByHyperlink(session: WizardLoggingSession, project: Project?, templateId: String?) {
-            projectOpenedByHyperlinkEvent.log(
-                project,
-                projectTemplateField.with(templateId ?: "none"),
-                sessionIdField with session.id,
-                pluginInfoField
-            )
-        }
+    val modulesCreatedField = EventFields.Int("modules_created")
+    val modulesRemovedField = EventFields.Int("modules_removed")
+    val moduleTemplateChangedField = EventFields.Int("module_template_changed")
 
-        private fun logModuleTemplateCreation(
-            session: WizardLoggingSession,
-            project: Project?,
-            projectTemplateId: String,
-            moduleTemplateId: String
-        ) {
-            moduleTemplateCreatedEvent.log(
-                project,
-                projectTemplateField.with(projectTemplateId),
-                moduleTemplateField.with(moduleTemplateId),
-                sessionIdField with session.id,
-                pluginInfoField
-            )
+    private val moduleTemplateField = EventFields.String("module_template", allowedModuleTemplates)
+    private val sessionIdField = EventFields.Int("session_id")
+
+    val modulesListField = StringListEventField.ValidatedByAllowedValues("project_modules_list", allowedModuleTypes)
+
+    private val moduleTypeField = EventFields.String("module_type", allowedModuleTypes)
+
+    private val pluginInfoField = EventFields.PluginInfo.with(getPluginInfoById(KotlinIdePlugin.id))
+
+    // Events
+    private val projectCreatedEvent = GROUP.registerVarargEvent(
+        "project_created",
+        groupField,
+        projectTemplateField,
+        buildSystemField,
+        modulesCreatedField,
+        modulesRemovedField,
+        moduleTemplateChangedField,
+        modulesListField,
+        sessionIdField,
+        EventFields.PluginInfo
+    )
+
+    private val projectOpenedByHyperlinkEvent = GROUP.registerVarargEvent(
+        "wizard_opened_by_hyperlink",
+        projectTemplateField,
+        sessionIdField,
+        EventFields.PluginInfo
+    )
+
+    private val moduleTemplateCreatedEvent = GROUP.registerVarargEvent(
+        "module_template_created",
+        projectTemplateField,
+        moduleTemplateField,
+        sessionIdField,
+        EventFields.PluginInfo
+    )
+
+    private val settingValueChangedEvent = GROUP.registerVarargEvent(
+        "setting_value_changed",
+        settingIdField,
+        settingValueField,
+        sessionIdField,
+        EventFields.PluginInfo,
+    )
+
+    private val jdkChangedEvent = GROUP.registerVarargEvent(
+        "jdk_changed",
+        sessionIdField,
+        EventFields.PluginInfo,
+    )
+
+    private val nextClickedEvent = GROUP.registerVarargEvent(
+        "next_clicked",
+        sessionIdField,
+        EventFields.PluginInfo,
+    )
+
+    private val prevClickedEvent = GROUP.registerVarargEvent(
+        "prev_clicked",
+        sessionIdField,
+        EventFields.PluginInfo,
+    )
+
+    private val moduleCreatedEvent = GROUP.registerVarargEvent(
+        "module_created",
+        moduleTypeField,
+        sessionIdField,
+        EventFields.PluginInfo,
+    )
+
+    private val moduleRemovedEvent = GROUP.registerVarargEvent(
+        "module_removed",
+        moduleTypeField,
+        sessionIdField,
+        EventFields.PluginInfo,
+    )
+
+    // Log functions
+    fun logDataOnProjectGenerated(session: WizardLoggingSession?, project: Project?, projectCreationStats: ProjectCreationStats) {
+        projectCreatedEvent.log(
+            project,
+            *projectCreationStats.toPairs().toTypedArray(),
+            *session?.let { arrayOf(sessionIdField with it.id) }.orEmpty(),
+            pluginInfoField
+        )
+    }
+
+    fun logDataOnSettingValueChanged(
+        session: WizardLoggingSession,
+        settingId: String,
+        settingValue: String
+    ) {
+        val idToLog = settings.getIdToLog(settingId) ?: return
+        settingValueChangedEvent.log(
+            settingIdField with idToLog,
+            settingValueField with settingValue,
+            sessionIdField with session.id,
+            pluginInfoField,
+        )
+    }
+
+    fun logDataOnJdkChanged(
+        session: WizardLoggingSession,
+    ) {
+        jdkChangedEvent.log(
+            sessionIdField with session.id,
+            pluginInfoField,
+        )
+    }
+
+    fun logDataOnNextClicked(
+        session: WizardLoggingSession,
+    ) {
+        nextClickedEvent.log(
+            sessionIdField with session.id,
+            pluginInfoField,
+        )
+    }
+
+    fun logDataOnPrevClicked(
+        session: WizardLoggingSession,
+    ) {
+        prevClickedEvent.log(
+            sessionIdField with session.id,
+            pluginInfoField,
+        )
+    }
+
+    fun logOnModuleCreated(
+        session: WizardLoggingSession,
+        moduleType: String,
+    ) {
+        moduleCreatedEvent.log(
+            sessionIdField with session.id,
+            moduleTypeField with moduleType.withSpacesRemoved(),
+            pluginInfoField,
+        )
+    }
+
+    fun logOnModuleRemoved(
+        session: WizardLoggingSession,
+        moduleType: String,
+    ) {
+        moduleRemovedEvent.log(
+            sessionIdField with session.id,
+            moduleTypeField with moduleType.withSpacesRemoved(),
+            pluginInfoField,
+        )
+    }
+
+
+    fun logDataOnProjectGenerated(
+        session: WizardLoggingSession?,
+        project: Project?,
+        projectCreationStats: ProjectCreationStats,
+        uiEditorUsageStats: UiEditorUsageStats
+    ) {
+        projectCreatedEvent.log(
+            project,
+            *projectCreationStats.toPairs().toTypedArray(),
+            *uiEditorUsageStats.toPairs().toTypedArray(),
+            *session?.let { arrayOf(sessionIdField with it.id) }.orEmpty(),
+            pluginInfoField
+        )
+    }
+
+    fun logUsedModuleTemplatesOnNewWizardProjectCreated(
+        session: WizardLoggingSession,
+        project: Project?,
+        projectTemplateId: String,
+        moduleTemplates: List<String>
+    ) {
+        moduleTemplates.forEach { moduleTemplateId ->
+            logModuleTemplateCreation(session, project, projectTemplateId, moduleTemplateId)
         }
     }
 
+    fun logWizardOpenByHyperlink(session: WizardLoggingSession, project: Project?, templateId: String?) {
+        projectOpenedByHyperlinkEvent.log(
+            project,
+            projectTemplateField.with(templateId ?: "none"),
+            sessionIdField with session.id,
+            pluginInfoField
+        )
+    }
+
+    private fun logModuleTemplateCreation(
+        session: WizardLoggingSession,
+        project: Project?,
+        projectTemplateId: String,
+        moduleTemplateId: String
+    ) {
+        moduleTemplateCreatedEvent.log(
+            project,
+            projectTemplateField.with(projectTemplateId),
+            moduleTemplateField.with(moduleTemplateId),
+            sessionIdField with session.id,
+            pluginInfoField
+        )
+    }
+
     data class ProjectCreationStats(
         val group: String,
         val projectTemplateId: String,

plugins/markdown/core/src/org/intellij/plugins/markdown/MarkdownUsageCollector.kt

@@ -6,19 +6,15 @@ import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesColle
 import org.intellij.plugins.markdown.extensions.jcef.commandRunner.RunnerPlace
 import org.intellij.plugins.markdown.extensions.jcef.commandRunner.RunnerType
 
-internal class MarkdownUsageCollector : CounterUsagesCollector() {
-  companion object {
-    private val GROUP = EventLogGroup("markdown.events", 1)
+internal object MarkdownUsageCollector : CounterUsagesCollector() {
+  private val GROUP = EventLogGroup("markdown.events", 1)
 
-    @JvmField
-    val RUNNER_EXECUTED = GROUP.registerEvent(
-      "runner.executed",
-      EventFields.Enum("place", RunnerPlace::class.java),
-      EventFields.Enum("type", RunnerType::class.java),
-      EventFields.Class("runner")
-    )
-
-  }
+  val RUNNER_EXECUTED = GROUP.registerEvent(
+    "runner.executed",
+    EventFields.Enum("place", RunnerPlace::class.java),
+    EventFields.Enum("type", RunnerType::class.java),
+    EventFields.Class("runner")
+  )
 
   override fun getGroup(): EventLogGroup {
     return GROUP

plugins/markdown/core/src/org/intellij/plugins/markdown/extensions/jcef/commandRunner/CommandRunnerExtension.kt

@@ -24,7 +24,7 @@ import com.intellij.openapi.vfs.LocalFileSystem
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.ui.AppUIUtil
 import org.intellij.plugins.markdown.MarkdownBundle
-import org.intellij.plugins.markdown.MarkdownUsageCollector.Companion.RUNNER_EXECUTED
+import org.intellij.plugins.markdown.MarkdownUsageCollector.RUNNER_EXECUTED
 import org.intellij.plugins.markdown.extensions.MarkdownBrowserPreviewExtension
 import org.intellij.plugins.markdown.extensions.MarkdownExtensionsUtil
 import org.intellij.plugins.markdown.injection.aliases.CodeFenceLanguageGuesser

plugins/markdown/core/src/org/intellij/plugins/markdown/extensions/jcef/commandRunner/MarkdownRunLineMarkersProvider.kt

@@ -10,7 +10,7 @@ import com.intellij.openapi.actionSystem.CommonDataKeys
 import com.intellij.openapi.util.NlsSafe
 import com.intellij.psi.PsiElement
 import org.intellij.plugins.markdown.MarkdownBundle
-import org.intellij.plugins.markdown.MarkdownUsageCollector.Companion.RUNNER_EXECUTED
+import org.intellij.plugins.markdown.MarkdownUsageCollector.RUNNER_EXECUTED
 import org.intellij.plugins.markdown.extensions.jcef.commandRunner.CommandRunnerExtension.Companion.execute
 import org.intellij.plugins.markdown.extensions.jcef.commandRunner.CommandRunnerExtension.Companion.matches
 import org.intellij.plugins.markdown.extensions.jcef.commandRunner.CommandRunnerExtension.Companion.trimPrompt

plugins/maven/src/main/java/org/jetbrains/idea/maven/dom/model/completion/insert/MavenDependencyInsertionTracker.kt

@@ -17,8 +17,8 @@ internal fun logMavenDependencyInsertion(context: InsertionContext, item: Lookup
 
   MavenDependencyInsertionCollector.logPackageAutoCompleted(
     groupId, artifactId, version,
-    MavenDependencyInsertionCollector.Companion.BuildSystem.MAVEN,
-    MavenDependencyInsertionCollector.Companion.DependencyDeclarationNotation.MAVEN,
+    MavenDependencyInsertionCollector.BuildSystem.MAVEN,
+    MavenDependencyInsertionCollector.DependencyDeclarationNotation.MAVEN,
     completionPrefix.length,
     selectedLookupIndex
   )

plugins/maven/src/main/java/org/jetbrains/idea/maven/statistics/MavenDependencyInsertionCollector.kt

@@ -4,113 +4,107 @@ package org.jetbrains.idea.maven.statistics
 import com.intellij.internal.statistic.eventLog.EventLogGroup
 import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
-import com.intellij.openapi.diagnostic.Logger
 import org.jetbrains.idea.reposearch.statistics.TopPackageIdValidationRule
 
-
-class MavenDependencyInsertionCollector : CounterUsagesCollector() {
-  private val logger = Logger.getInstance(MavenDependencyInsertionCollector::class.java)
-
+object MavenDependencyInsertionCollector : CounterUsagesCollector() {
   override fun getGroup() = GROUP
 
-  companion object {
-    private const val GROUP_ID = "gradle.maven.count"
-    private const val VERSION = 1
+  private const val GROUP_ID = "gradle.maven.count"
+  private const val VERSION = 1
 
-    private val GROUP = EventLogGroup(GROUP_ID, VERSION)
+  private val GROUP = EventLogGroup(GROUP_ID, VERSION)
 
-    private const val PACKAGE_ID = "package_id"
-    private const val PACKAGE_VERSION = "package_version"
-    private const val BUILD_SYSTEM = "build_system"
-    private const val DEPENDENCY_DECLARATION_NOTATION = "dependency_declaration_notation"
+  private const val PACKAGE_ID = "package_id"
+  private const val PACKAGE_VERSION = "package_version"
+  private const val BUILD_SYSTEM = "build_system"
+  private const val DEPENDENCY_DECLARATION_NOTATION = "dependency_declaration_notation"
 
-    private const val COMPLETION_PREFIX_LENGTH = "completion_prefix_length"
-    private const val SELECTED_LOOKUP_INDEX = "selected_lookup_index"
+  private const val COMPLETION_PREFIX_LENGTH = "completion_prefix_length"
+  private const val SELECTED_LOOKUP_INDEX = "selected_lookup_index"
 
-    private const val PACKAGE_AUTOCOMPLETED = "package_autocompleted"
-    private const val PACKAGE_COPYPASTED = "package_copypasted"
+  private const val PACKAGE_AUTOCOMPLETED = "package_autocompleted"
+  private const val PACKAGE_COPYPASTED = "package_copypasted"
 
-    enum class BuildSystem {
-      @JvmField
-      GRADLE,
+  enum class BuildSystem {
+    @JvmField
+    GRADLE,
 
-      @JvmField
-      MAVEN
-    }
+    @JvmField
+    MAVEN
+  }
 
-    enum class DependencyDeclarationNotation {
-      @JvmField
-      GRADLE_STRING_STYLE,
+  enum class DependencyDeclarationNotation {
+    @JvmField
+    GRADLE_STRING_STYLE,
 
-      @JvmField
-      GRADLE_MAP_STYLE,
+    @JvmField
+    GRADLE_MAP_STYLE,
 
-      @JvmField
-      MAVEN
-    }
+    @JvmField
+    MAVEN
+  }
 
-    private val packageIdField = EventFields.StringValidatedByCustomRule(PACKAGE_ID, TopPackageIdValidationRule::class.java)
-    private val packageVersionField = EventFields.StringValidatedByRegexp(PACKAGE_VERSION, regexpRef = "version")
-    private val completionPrefixLengthField = EventFields.Int(COMPLETION_PREFIX_LENGTH)
-    private val selectedLookupIndexField = EventFields.Int(SELECTED_LOOKUP_INDEX)
-    private val buildSystemField = EventFields.Enum<BuildSystem>(BUILD_SYSTEM)
-    private val dependencyDeclarationNotationField =
-      EventFields.Enum<DependencyDeclarationNotation>(DEPENDENCY_DECLARATION_NOTATION)
+  private val packageIdField = EventFields.StringValidatedByCustomRule(PACKAGE_ID, TopPackageIdValidationRule::class.java)
+  private val packageVersionField = EventFields.StringValidatedByRegexp(PACKAGE_VERSION, regexpRef = "version")
+  private val completionPrefixLengthField = EventFields.Int(COMPLETION_PREFIX_LENGTH)
+  private val selectedLookupIndexField = EventFields.Int(SELECTED_LOOKUP_INDEX)
+  private val buildSystemField = EventFields.Enum<BuildSystem>(BUILD_SYSTEM)
+  private val dependencyDeclarationNotationField =
+    EventFields.Enum<DependencyDeclarationNotation>(DEPENDENCY_DECLARATION_NOTATION)
 
-    private val packageAutoCompleted = GROUP.registerVarargEvent(
-      eventId = PACKAGE_AUTOCOMPLETED,
-      packageIdField,
-      packageVersionField,
-      buildSystemField,
-      dependencyDeclarationNotationField,
-      completionPrefixLengthField,
-      selectedLookupIndexField
+  private val packageAutoCompleted = GROUP.registerVarargEvent(
+    eventId = PACKAGE_AUTOCOMPLETED,
+    packageIdField,
+    packageVersionField,
+    buildSystemField,
+    dependencyDeclarationNotationField,
+    completionPrefixLengthField,
+    selectedLookupIndexField
+  )
+
+  private val packageCopyPasted = GROUP.registerVarargEvent(
+    eventId = PACKAGE_COPYPASTED,
+    packageIdField,
+    packageVersionField,
+    buildSystemField,
+    dependencyDeclarationNotationField
+  )
+
+  @JvmStatic
+  fun logPackageAutoCompleted(
+    groupId: String,
+    artifactId: String,
+    version: String,
+    buildSystem: BuildSystem,
+    dependencyDeclarationNotation: DependencyDeclarationNotation,
+    completionPrefixLength: Int,
+    selectedLookupIndex: Int
+  ) {
+    val packageId = "$groupId:$artifactId"
+    packageAutoCompleted.log(
+      packageIdField.with(packageId),
+      packageVersionField.with(version),
+      buildSystemField.with(buildSystem),
+      dependencyDeclarationNotationField.with(dependencyDeclarationNotation),
+      completionPrefixLengthField.with(completionPrefixLength),
+      selectedLookupIndexField.with(selectedLookupIndex),
     )
+  }
 
-    private val packageCopyPasted = GROUP.registerVarargEvent(
-      eventId = PACKAGE_COPYPASTED,
-      packageIdField,
-      packageVersionField,
-      buildSystemField,
-      dependencyDeclarationNotationField
+  @JvmStatic
+  fun logPackageCopyPasted(
+    groupId: String,
+    artifactId: String,
+    version: String,
+    buildSystem: BuildSystem,
+    dependencyDeclarationNotation: DependencyDeclarationNotation
+  ) {
+    val packageId = "$groupId:$artifactId"
+    packageCopyPasted.log(
+      packageIdField.with(packageId),
+      packageVersionField.with(version),
+      buildSystemField.with(buildSystem),
+      dependencyDeclarationNotationField.with(dependencyDeclarationNotation)
     )
-
-    @JvmStatic
-    fun logPackageAutoCompleted(
-      groupId: String,
-      artifactId: String,
-      version: String,
-      buildSystem: BuildSystem,
-      dependencyDeclarationNotation: DependencyDeclarationNotation,
-      completionPrefixLength: Int,
-      selectedLookupIndex: Int
-    ) {
-      val packageId = "$groupId:$artifactId"
-      packageAutoCompleted.log(
-        packageIdField.with(packageId),
-        packageVersionField.with(version),
-        buildSystemField.with(buildSystem),
-        dependencyDeclarationNotationField.with(dependencyDeclarationNotation),
-        completionPrefixLengthField.with(completionPrefixLength),
-        selectedLookupIndexField.with(selectedLookupIndex),
-      )
-    }
-
-    @JvmStatic
-    fun logPackageCopyPasted(
-      groupId: String,
-      artifactId: String,
-      version: String,
-      buildSystem: BuildSystem,
-      dependencyDeclarationNotation: DependencyDeclarationNotation
-    ) {
-      val packageId = "$groupId:$artifactId"
-      packageCopyPasted.log(
-        packageIdField.with(packageId),
-        packageVersionField.with(version),
-        buildSystemField.with(buildSystem),
-        dependencyDeclarationNotationField.with(dependencyDeclarationNotation)
-      )
-    }
   }
 }

plugins/maven/src/main/java/org/jetbrains/idea/maven/statistics/MavenImportCollector.kt

@@ -7,129 +7,125 @@ import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesColle
 import org.jetbrains.annotations.ApiStatus
 
 @ApiStatus.Internal
-class MavenImportCollector : CounterUsagesCollector() {
-  companion object {
-    val GROUP = EventLogGroup("maven.import", 10)
+object MavenImportCollector : CounterUsagesCollector() {
+  val GROUP = EventLogGroup("maven.import", 10)
 
-    @JvmField
-    val HAS_USER_ADDED_LIBRARY_DEP = GROUP.registerEvent("hasUserAddedLibraryDependency")
+  @JvmField
+  val HAS_USER_ADDED_LIBRARY_DEP = GROUP.registerEvent("hasUserAddedLibraryDependency")
 
-    @JvmField
-    val HAS_USER_ADDED_MODULE_DEP = GROUP.registerEvent("hasUserAddedModuleDependency")
+  @JvmField
+  val HAS_USER_ADDED_MODULE_DEP = GROUP.registerEvent("hasUserAddedModuleDependency")
 
-    @JvmField
-    val HAS_USER_MODIFIED_IMPORTED_LIBRARY = GROUP.registerEvent("hasUserModifiedImportedLibrary")
+  @JvmField
+  val HAS_USER_MODIFIED_IMPORTED_LIBRARY = GROUP.registerEvent("hasUserModifiedImportedLibrary")
 
-    @JvmField
-    val NUMBER_OF_MODULES = EventFields.RoundedInt("number_of_modules")
+  @JvmField
+  val NUMBER_OF_MODULES = EventFields.RoundedInt("number_of_modules")
 
-    // >>> Legacy import phases
-    @JvmField
-    val LEGACY_IMPORT = GROUP.registerIdeActivity("legacy_import",
-                                                  finishEventAdditionalFields = arrayOf(NUMBER_OF_MODULES))
+  // >>> Legacy import phases
+  @JvmField
+  val LEGACY_IMPORT = GROUP.registerIdeActivity("legacy_import",
+                                                finishEventAdditionalFields = arrayOf(NUMBER_OF_MODULES))
 
-    @JvmField
-    val LEGACY_CREATE_MODULES_PHASE = GROUP.registerIdeActivity("create_modules", parentActivity = LEGACY_IMPORT)
+  @JvmField
+  val LEGACY_CREATE_MODULES_PHASE = GROUP.registerIdeActivity("create_modules", parentActivity = LEGACY_IMPORT)
 
-    @JvmField
-    val LEGACY_DELETE_OBSOLETE_PHASE = GROUP.registerIdeActivity("delete_obsolete", parentActivity = LEGACY_IMPORT)
+  @JvmField
+  val LEGACY_DELETE_OBSOLETE_PHASE = GROUP.registerIdeActivity("delete_obsolete", parentActivity = LEGACY_IMPORT)
 
-    @JvmField
-    val LEGACY_IMPORTERS_PHASE = GROUP.registerIdeActivity("importers", parentActivity = LEGACY_IMPORT)
-    // <<< Legacy import phases
+  @JvmField
+  val LEGACY_IMPORTERS_PHASE = GROUP.registerIdeActivity("importers", parentActivity = LEGACY_IMPORT)
+  // <<< Legacy import phases
 
-    @JvmField
-    val ACTIVITY_ID = EventFields.IdeActivityIdField
+  @JvmField
+  val ACTIVITY_ID = EventFields.IdeActivityIdField
 
-    // >>> Workspace import phases
-    @JvmField
-    val WORKSPACE_IMPORT = GROUP.registerIdeActivity("workspace_import",
-                                                     finishEventAdditionalFields = arrayOf(NUMBER_OF_MODULES))
+  // >>> Workspace import phases
+  @JvmField
+  val WORKSPACE_IMPORT = GROUP.registerIdeActivity("workspace_import",
+                                                   finishEventAdditionalFields = arrayOf(NUMBER_OF_MODULES))
 
-    @JvmField
-    val WORKSPACE_FOLDERS_UPDATE = GROUP.registerIdeActivity("workspace_folders_update",
-                                                             finishEventAdditionalFields = arrayOf(NUMBER_OF_MODULES))
+  @JvmField
+  val WORKSPACE_FOLDERS_UPDATE = GROUP.registerIdeActivity("workspace_folders_update",
+                                                           finishEventAdditionalFields = arrayOf(NUMBER_OF_MODULES))
 
-    @JvmField
-    val WORKSPACE_POPULATE_PHASE = GROUP.registerIdeActivity("populate", parentActivity = WORKSPACE_IMPORT)
+  @JvmField
+  val WORKSPACE_POPULATE_PHASE = GROUP.registerIdeActivity("populate", parentActivity = WORKSPACE_IMPORT)
 
-    @JvmField
-    val DURATION_BACKGROUND_MS = EventFields.Long("duration_in_background_ms")
+  @JvmField
+  val DURATION_BACKGROUND_MS = EventFields.Long("duration_in_background_ms")
 
-    @JvmField
-    val DURATION_WRITE_ACTION_MS = EventFields.Long("duration_in_write_action_ms")
+  @JvmField
+  val DURATION_WRITE_ACTION_MS = EventFields.Long("duration_in_write_action_ms")
 
-    @JvmField
-    val DURATION_OF_WORKSPACE_UPDATE_CALL_MS = EventFields.Long("duration_of_workspace_update_call_ms")
+  @JvmField
+  val DURATION_OF_WORKSPACE_UPDATE_CALL_MS = EventFields.Long("duration_of_workspace_update_call_ms")
 
-    @JvmField
-    val ATTEMPTS = EventFields.Int("attempts")
+  @JvmField
+  val ATTEMPTS = EventFields.Int("attempts")
 
-    @JvmField
-    val WORKSPACE_COMMIT_STATS = GROUP.registerVarargEvent("workspace_commit", ACTIVITY_ID, DURATION_BACKGROUND_MS,
-                                                           DURATION_WRITE_ACTION_MS, DURATION_OF_WORKSPACE_UPDATE_CALL_MS, ATTEMPTS)
+  @JvmField
+  val WORKSPACE_COMMIT_STATS = GROUP.registerVarargEvent("workspace_commit", ACTIVITY_ID, DURATION_BACKGROUND_MS,
+                                                         DURATION_WRITE_ACTION_MS, DURATION_OF_WORKSPACE_UPDATE_CALL_MS, ATTEMPTS)
 
-    @JvmField
-    val WORKSPACE_COMMIT_PHASE = GROUP.registerIdeActivity("commit", parentActivity = WORKSPACE_IMPORT)
+  @JvmField
+  val WORKSPACE_COMMIT_PHASE = GROUP.registerIdeActivity("commit", parentActivity = WORKSPACE_IMPORT)
 
-    @JvmField
-    val WORKSPACE_LEGACY_IMPORTERS_PHASE = GROUP.registerIdeActivity("legacy_importers", parentActivity = WORKSPACE_IMPORT)
-    // <<< Workspace import phases
+  @JvmField
+  val WORKSPACE_LEGACY_IMPORTERS_PHASE = GROUP.registerIdeActivity("legacy_importers", parentActivity = WORKSPACE_IMPORT)
+  // <<< Workspace import phases
 
-    @JvmField
-    val TOTAL_DURATION_MS = EventFields.Long("total_duration_ms")
+  @JvmField
+  val TOTAL_DURATION_MS = EventFields.Long("total_duration_ms")
 
-    @JvmField
-    val COLLECT_FOLDERS_DURATION_MS = EventFields.Long("collect_folders_duration_ms")
+  @JvmField
+  val COLLECT_FOLDERS_DURATION_MS = EventFields.Long("collect_folders_duration_ms")
 
-    @JvmField
-    val CONFIG_MODULES_DURATION_MS = EventFields.Long("config_modules_duration_ms")
+  @JvmField
+  val CONFIG_MODULES_DURATION_MS = EventFields.Long("config_modules_duration_ms")
 
-    @JvmField
-    val BEFORE_APPLY_DURATION_MS = EventFields.Long("before_apply_duration_ms")
+  @JvmField
+  val BEFORE_APPLY_DURATION_MS = EventFields.Long("before_apply_duration_ms")
 
-    @JvmField
-    val AFTER_APPLY_DURATION_MS = EventFields.Long("after_apply_duration_ms")
+  @JvmField
+  val AFTER_APPLY_DURATION_MS = EventFields.Long("after_apply_duration_ms")
 
-    @JvmField
-    val IMPORTER_CLASS = EventFields.Class("importer_class")
+  @JvmField
+  val IMPORTER_CLASS = EventFields.Class("importer_class")
 
-    @JvmField
-    val IMPORTER_RUN = GROUP.registerVarargEvent("importer_run", ACTIVITY_ID, IMPORTER_CLASS, NUMBER_OF_MODULES, TOTAL_DURATION_MS)
+  @JvmField
+  val IMPORTER_RUN = GROUP.registerVarargEvent("importer_run", ACTIVITY_ID, IMPORTER_CLASS, NUMBER_OF_MODULES, TOTAL_DURATION_MS)
 
-    @JvmField
-    val CONFIGURATOR_CLASS = EventFields.Class("configurator_class")
+  @JvmField
+  val CONFIGURATOR_CLASS = EventFields.Class("configurator_class")
 
-    @JvmField
-    val DURATION_OF_LEGACY_BRIDGES_CREATION_MS = EventFields.Long("duration_of_bridges_creation_ms")
+  @JvmField
+  val DURATION_OF_LEGACY_BRIDGES_CREATION_MS = EventFields.Long("duration_of_bridges_creation_ms")
 
-    @JvmField
-    val DURATION_OF_LEGACY_BRIDGES_COMMIT_MS = EventFields.Long("duration_of_bridges_commit_ms")
+  @JvmField
+  val DURATION_OF_LEGACY_BRIDGES_COMMIT_MS = EventFields.Long("duration_of_bridges_commit_ms")
 
-    @JvmField
-    val LEGACY_IMPORTERS_STATS = GROUP.registerVarargEvent("workspace_import.legacy_importers.stats",
-                                                           ACTIVITY_ID,
-                                                           DURATION_OF_LEGACY_BRIDGES_CREATION_MS,
-                                                           DURATION_OF_LEGACY_BRIDGES_COMMIT_MS)
+  @JvmField
+  val LEGACY_IMPORTERS_STATS = GROUP.registerVarargEvent("workspace_import.legacy_importers.stats",
+                                                         ACTIVITY_ID,
+                                                         DURATION_OF_LEGACY_BRIDGES_CREATION_MS,
+                                                         DURATION_OF_LEGACY_BRIDGES_COMMIT_MS)
 
 
-    @JvmField
-    val CONFIGURATOR_RUN = GROUP.registerVarargEvent("workspace_import.configurator_run",
-                                                     ACTIVITY_ID,
-                                                     CONFIGURATOR_CLASS,
-                                                     NUMBER_OF_MODULES,
-                                                     TOTAL_DURATION_MS,
-                                                     COLLECT_FOLDERS_DURATION_MS,
-                                                     CONFIG_MODULES_DURATION_MS,
-                                                     BEFORE_APPLY_DURATION_MS,
-                                                     AFTER_APPLY_DURATION_MS)
+  @JvmField
+  val CONFIGURATOR_RUN = GROUP.registerVarargEvent("workspace_import.configurator_run",
+                                                   ACTIVITY_ID,
+                                                   CONFIGURATOR_CLASS,
+                                                   NUMBER_OF_MODULES,
+                                                   TOTAL_DURATION_MS,
+                                                   COLLECT_FOLDERS_DURATION_MS,
+                                                   CONFIG_MODULES_DURATION_MS,
+                                                   BEFORE_APPLY_DURATION_MS,
+                                                   AFTER_APPLY_DURATION_MS)
 
 
-    @JvmField
-    val POST_IMPORT_TASKS_RUN =  GROUP.registerEvent("post_import_tasks_run", ACTIVITY_ID, TOTAL_DURATION_MS)
-  }
+  @JvmField
+  val POST_IMPORT_TASKS_RUN = GROUP.registerEvent("post_import_tasks_run", ACTIVITY_ID, TOTAL_DURATION_MS)
 
-  override fun getGroup(): EventLogGroup {
-    return GROUP
-  }
+  override fun getGroup(): EventLogGroup = GROUP
 }

plugins/settings-sync/src/com/intellij/settingsSync/SettingsSyncEventsStatistics.kt

@@ -4,17 +4,17 @@ import com.intellij.internal.statistic.eventLog.EventLogGroup
 import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 
-class SettingsSyncEventsStatistics : CounterUsagesCollector() {
-  companion object {
-    val GROUP: EventLogGroup = EventLogGroup("settings.sync.events", 1)
+object SettingsSyncEventsStatistics : CounterUsagesCollector() {
+  val GROUP: EventLogGroup = EventLogGroup("settings.sync.events", 1)
 
-    val ENABLED_MANUALLY = GROUP.registerEvent("enabled.manually", EventFields.Enum("method", EnabledMethod::class.java))
-    val DISABLED_MANUALLY = GROUP.registerEvent("disabled.manually", EventFields.Enum("method", ManualDisableMethod::class.java))
-    val DISABLED_AUTOMATICALLY = GROUP.registerEvent("disabled.automatically", EventFields.Enum("reason", AutomaticDisableReason::class.java))
-    val MIGRATED_FROM_OLD_PLUGIN = GROUP.registerEvent("migrated.from.old.plugin")
-    val MIGRATED_FROM_SETTINGS_REPOSITORY = GROUP.registerEvent("migrated.from.settings.repository")
-    val SETTINGS_REPOSITORY_NOTIFICATION_ACTION = GROUP.registerEvent("invoked.settings.repository.notification.action", EventFields.Enum("action", SettingsRepositoryMigrationNotificationAction::class.java))
-  }
+  val ENABLED_MANUALLY = GROUP.registerEvent("enabled.manually", EventFields.Enum("method", EnabledMethod::class.java))
+  val DISABLED_MANUALLY = GROUP.registerEvent("disabled.manually", EventFields.Enum("method", ManualDisableMethod::class.java))
+  val DISABLED_AUTOMATICALLY = GROUP.registerEvent("disabled.automatically", EventFields.Enum("reason", AutomaticDisableReason::class.java))
+  val MIGRATED_FROM_OLD_PLUGIN = GROUP.registerEvent("migrated.from.old.plugin")
+  val MIGRATED_FROM_SETTINGS_REPOSITORY = GROUP.registerEvent("migrated.from.settings.repository")
+  val SETTINGS_REPOSITORY_NOTIFICATION_ACTION = GROUP.registerEvent("invoked.settings.repository.notification.action",
+                                                                    EventFields.Enum("action",
+                                                                                     SettingsRepositoryMigrationNotificationAction::class.java))
 
   enum class EnabledMethod {
     GET_FROM_SERVER,

python/ide/impl/src/com/jetbrains/python/sdk/configuration/PyEnvironmentYmlSdkConfiguration.kt

@@ -33,9 +33,9 @@ import com.jetbrains.python.sdk.add.target.conda.suggestCondaPath
 import com.jetbrains.python.sdk.associateWithModule
 import com.jetbrains.python.sdk.basePath
 import com.jetbrains.python.sdk.conda.PyCondaSdkCustomizer
-import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.Companion.CondaEnvResult
-import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.Companion.InputData
-import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.Companion.Source
+import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.CondaEnvResult
+import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.InputData
+import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.Source
 import com.jetbrains.python.sdk.flavors.conda.CondaEnvSdkFlavor
 import com.jetbrains.python.sdk.flavors.conda.NewCondaEnvRequest
 import com.jetbrains.python.sdk.flavors.conda.PyCondaCommand

python/ide/impl/src/com/jetbrains/python/sdk/configuration/PyPipfileSdkConfiguration.kt

@@ -21,9 +21,9 @@ import com.intellij.util.ui.JBUI
 import com.jetbrains.python.PyBundle
 import com.jetbrains.python.PyCharmCommunityCustomizationBundle
 import com.jetbrains.python.sdk.*
-import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.Companion.InputData
-import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.Companion.PipEnvResult
-import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.Companion.Source
+import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.InputData
+import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.PipEnvResult
+import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.Source
 import com.jetbrains.python.sdk.pipenv.*
 import java.awt.BorderLayout
 import java.awt.Insets

python/ide/impl/src/com/jetbrains/python/sdk/configuration/PyRequirementsTxtOrSetupPySdkConfiguration.kt

@@ -33,9 +33,9 @@ import com.jetbrains.python.packaging.PyPackageManagerImpl
 import com.jetbrains.python.packaging.PyPackageUtil
 import com.jetbrains.python.sdk.*
 import com.jetbrains.python.sdk.add.PyAddNewVirtualEnvFromFilePanel
-import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.Companion.InputData
-import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.Companion.Source
-import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.Companion.VirtualEnvResult
+import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.InputData
+import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.Source
+import com.jetbrains.python.sdk.configuration.PySdkConfigurationCollector.VirtualEnvResult
 import java.awt.BorderLayout
 import java.awt.Insets
 import java.nio.file.Paths

python/ide/impl/src/com/jetbrains/python/sdk/configuration/PySdkConfigurationCollector.kt

@@ -6,79 +6,78 @@ import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 import com.intellij.openapi.project.Project
 
-class PySdkConfigurationCollector : CounterUsagesCollector() {
+object PySdkConfigurationCollector : CounterUsagesCollector() {
 
   override fun getGroup(): EventLogGroup = GROUP
 
-  companion object {
-
-    internal enum class Source { CONFIGURATOR, INSPECTION }
-    internal enum class InputData { NOT_FILLED, SPECIFIED }
-    internal enum class VirtualEnvResult { CREATION_FAILURE, DEPS_NOT_FOUND, INSTALLATION_FAILURE, CREATED }
-    internal enum class CondaEnvResult {
-      LISTING_FAILURE,
-      CREATION_FAILURE,
-      NO_LISTING_DIFFERENCE,
-      AMBIGUOUS_LISTING_DIFFERENCE,
-      NO_BINARY,
-      AMBIGUOUS_BINARIES,
-      CREATED
-    }
-    internal enum class PipEnvResult { CREATION_FAILURE, NO_EXECUTABLE, NO_EXECUTABLE_FILE, CREATED }
-
-    internal fun logVirtualEnvDialog(project: Project, permitted: Boolean, source: Source, baseSdk: InputData) {
-      venvDialogEvent.log(project, permitted.asDialogResult, source, baseSdk)
-    }
-
-    internal fun logVirtualEnv(project: Project, result: VirtualEnvResult): Unit = venvEvent.log(project, result)
-
-    internal fun logCondaEnvDialog(project: Project, permitted: Boolean, source: Source, condaPath: InputData) {
-      condaEnvDialogEvent.log(project, permitted.asDialogResult, source, condaPath)
-    }
-
-    internal fun logCondaEnvDialogSkipped(project: Project, source: Source, condaPath: InputData) {
-      condaEnvDialogEvent.log(project, DialogResult.SKIPPED, source, condaPath)
-    }
-
-    internal fun logCondaEnv(project: Project, result: CondaEnvResult): Unit = condaEnvEvent.log(project, result)
-
-    internal fun logPipEnvDialog(project: Project, permitted: Boolean, source: Source, pipenvPath: InputData) {
-      pipenvDialogEvent.log(project, permitted.asDialogResult, source, pipenvPath)
-    }
-
-    internal fun logPipEnv(project: Project, result: PipEnvResult): Unit = pipenvEvent.log(project, result)
-
-    private val GROUP = EventLogGroup("python.sdk.configuration", 1)
-
-    private enum class DialogResult { OK, CANCELLED, SKIPPED }
-    private val Boolean.asDialogResult: DialogResult
-      get() = if (this) DialogResult.OK else DialogResult.CANCELLED
-
-    private val venvDialogEvent = GROUP.registerEvent(
-      "venv.dialog.closed",
-      EventFields.Enum("dialog_result", DialogResult::class.java),
-      EventFields.Enum("source", Source::class.java),
-      EventFields.Enum("baseSdk", InputData::class.java)
-    )
-
-    private val venvEvent = GROUP.registerEvent("venv.created", EventFields.Enum("env_result", VirtualEnvResult::class.java))
-
-    private val condaEnvDialogEvent = GROUP.registerEvent(
-      "condaEnv.dialog.closed",
-      EventFields.Enum("dialog_result", DialogResult::class.java),
-      EventFields.Enum("source", Source::class.java),
-      EventFields.Enum("conda_path", InputData::class.java)
-    )
-
-    private val condaEnvEvent = GROUP.registerEvent("condaEnv.created", EventFields.Enum("env_result", CondaEnvResult::class.java))
-
-    private val pipenvDialogEvent = GROUP.registerEvent(
-      "pipenv.dialog.closed",
-      EventFields.Enum("dialog_result", DialogResult::class.java),
-      EventFields.Enum("source", Source::class.java),
-      EventFields.Enum("pipenv_path", InputData::class.java)
-    )
-
-    private val pipenvEvent = GROUP.registerEvent("pipenv.created", EventFields.Enum("env_result", PipEnvResult::class.java))
+  internal enum class Source { CONFIGURATOR, INSPECTION }
+  internal enum class InputData { NOT_FILLED, SPECIFIED }
+  internal enum class VirtualEnvResult { CREATION_FAILURE, DEPS_NOT_FOUND, INSTALLATION_FAILURE, CREATED }
+  internal enum class CondaEnvResult {
+    LISTING_FAILURE,
+    CREATION_FAILURE,
+    NO_LISTING_DIFFERENCE,
+    AMBIGUOUS_LISTING_DIFFERENCE,
+    NO_BINARY,
+    AMBIGUOUS_BINARIES,
+    CREATED
   }
+
+  internal enum class PipEnvResult { CREATION_FAILURE, NO_EXECUTABLE, NO_EXECUTABLE_FILE, CREATED }
+
+  internal fun logVirtualEnvDialog(project: Project, permitted: Boolean, source: Source, baseSdk: InputData) {
+    venvDialogEvent.log(project, permitted.asDialogResult, source, baseSdk)
+  }
+
+  internal fun logVirtualEnv(project: Project, result: VirtualEnvResult): Unit = venvEvent.log(project, result)
+
+  internal fun logCondaEnvDialog(project: Project, permitted: Boolean, source: Source, condaPath: InputData) {
+    condaEnvDialogEvent.log(project, permitted.asDialogResult, source, condaPath)
+  }
+
+  internal fun logCondaEnvDialogSkipped(project: Project, source: Source, condaPath: InputData) {
+    condaEnvDialogEvent.log(project, DialogResult.SKIPPED, source, condaPath)
+  }
+
+  internal fun logCondaEnv(project: Project, result: CondaEnvResult): Unit = condaEnvEvent.log(project, result)
+
+  internal fun logPipEnvDialog(project: Project, permitted: Boolean, source: Source, pipenvPath: InputData) {
+    pipenvDialogEvent.log(project, permitted.asDialogResult, source, pipenvPath)
+  }
+
+  internal fun logPipEnv(project: Project, result: PipEnvResult): Unit = pipenvEvent.log(project, result)
+
+  private val GROUP = EventLogGroup("python.sdk.configuration", 1)
+
+  private enum class DialogResult { OK, CANCELLED, SKIPPED }
+
+  private val Boolean.asDialogResult: DialogResult
+    get() = if (this) DialogResult.OK else DialogResult.CANCELLED
+
+  private val venvDialogEvent = GROUP.registerEvent(
+    "venv.dialog.closed",
+    EventFields.Enum("dialog_result", DialogResult::class.java),
+    EventFields.Enum("source", Source::class.java),
+    EventFields.Enum("baseSdk", InputData::class.java)
+  )
+
+  private val venvEvent = GROUP.registerEvent("venv.created", EventFields.Enum("env_result", VirtualEnvResult::class.java))
+
+  private val condaEnvDialogEvent = GROUP.registerEvent(
+    "condaEnv.dialog.closed",
+    EventFields.Enum("dialog_result", DialogResult::class.java),
+    EventFields.Enum("source", Source::class.java),
+    EventFields.Enum("conda_path", InputData::class.java)
+  )
+
+  private val condaEnvEvent = GROUP.registerEvent("condaEnv.created", EventFields.Enum("env_result", CondaEnvResult::class.java))
+
+  private val pipenvDialogEvent = GROUP.registerEvent(
+    "pipenv.dialog.closed",
+    EventFields.Enum("dialog_result", DialogResult::class.java),
+    EventFields.Enum("source", Source::class.java),
+    EventFields.Enum("pipenv_path", InputData::class.java)
+  )
+
+  private val pipenvEvent = GROUP.registerEvent("pipenv.created", EventFields.Enum("env_result", PipEnvResult::class.java))
 }

python/src/com/jetbrains/python/actions/CreatePackageAction.java

@@ -77,7 +77,7 @@ public final class CreatePackageAction extends DumbAwareAction {
                            view.selectElement(item);
                          }
                        });
-                       PyNamespacePackagesStatisticsCollector.Companion.logNamespacePackageCreatedByUser();
+                       PyNamespacePackagesStatisticsCollector.logNamespacePackageCreatedByUser();
                      }
                      return directory;
                    }

python/src/com/jetbrains/python/namespacePackages/PyNamespacePackagesService.java

@@ -71,11 +71,11 @@ public class PyNamespacePackagesService implements PersistentStateComponent<PyNa
 
     if (canBeMarked(directory)) {
       myNamespacePackageFolders.add(directory);
-      PyNamespacePackagesStatisticsCollector.Companion.logToggleMarkingAsNamespacePackage(true);
+      PyNamespacePackagesStatisticsCollector.logToggleMarkingAsNamespacePackage(true);
     }
     else if (isMarked(directory)) {
       myNamespacePackageFolders.remove(directory);
-      PyNamespacePackagesStatisticsCollector.Companion.logToggleMarkingAsNamespacePackage(false);
+      PyNamespacePackagesStatisticsCollector.logToggleMarkingAsNamespacePackage(false);
     }
     else {
       throw new IllegalStateException("Can't toggle namespace package state for: " + directory.getName());

python/src/com/jetbrains/python/namespacePackages/PyNamespacePackagesStatisticsCollector.kt

@@ -5,28 +5,26 @@ import com.intellij.internal.statistic.eventLog.EventLogGroup
 import com.intellij.internal.statistic.eventLog.events.EventFields
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 
-class PyNamespacePackagesStatisticsCollector : CounterUsagesCollector() {
+object PyNamespacePackagesStatisticsCollector : CounterUsagesCollector() {
   override fun getGroup(): EventLogGroup = GROUP
 
-  companion object {
-    fun logNamespacePackageCreatedByUser() {
-      namespacePackageCreatedEvent.log()
-    }
-
-    fun logToggleMarkingAsNamespacePackage(mark: Boolean) {
-      toggleMarkingAsNamespacePackageEvent.log(mark)
-    }
-
-    fun logApplyInNamespacePackageRootProvider() {
-      namespacePackagesEditedViaProjectStructure.log()
-    }
-
-    private val GROUP = EventLogGroup("python.namespace.packages.events", 1)
-
-    private val namespacePackageCreatedEvent = GROUP.registerEvent("namespace.package.created")
-
-    private val toggleMarkingAsNamespacePackageEvent = GROUP.registerEvent("namespace.package.mark.or.unmark", EventFields.Boolean("is_mark"))
-
-    private val namespacePackagesEditedViaProjectStructure = GROUP.registerEvent("namespace.package.apply.in.root.provider")
+  @JvmStatic
+  fun logNamespacePackageCreatedByUser() {
+    namespacePackageCreatedEvent.log()
   }
+
+  @JvmStatic
+  fun logToggleMarkingAsNamespacePackage(mark: Boolean) {
+    toggleMarkingAsNamespacePackageEvent.log(mark)
+  }
+
+  fun logApplyInNamespacePackageRootProvider() {
+    namespacePackagesEditedViaProjectStructure.log()
+  }
+
+  private val GROUP = EventLogGroup("python.namespace.packages.events", 1)
+
+  private val namespacePackageCreatedEvent = GROUP.registerEvent("namespace.package.created")
+  private val toggleMarkingAsNamespacePackageEvent = GROUP.registerEvent("namespace.package.mark.or.unmark", EventFields.Boolean("is_mark"))
+  private val namespacePackagesEditedViaProjectStructure = GROUP.registerEvent("namespace.package.apply.in.root.provider")
 }

python/src/com/jetbrains/python/newProject/PythonProjectGenerator.java

@@ -207,9 +207,9 @@ public abstract class PythonProjectGenerator<T extends PyNewProjectSettings> ext
     configureProject(project, baseDir, settings, module, synchronizer);
     var statisticsInfo = settings.getInterpreterInfoForStatistics();
     if (statisticsInfo instanceof InterpreterStatisticsInfo interpreterStatisticsInfo) {
-      PythonNewProjectWizardCollector.Companion.logPythonNewProjectGenerated(interpreterStatisticsInfo,
-                                                                             PyStatisticToolsKt.getVersion(settings.getSdk()),
-                                                                             this.getClass());
+      PythonNewProjectWizardCollector.logPythonNewProjectGenerated(interpreterStatisticsInfo,
+                                                                   PyStatisticToolsKt.getVersion(settings.getSdk()),
+                                                                   this.getClass());
     }
   }
 

python/src/com/jetbrains/python/newProject/collector/PythonNewProjectWizardCollector.kt

@@ -7,45 +7,45 @@ import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesColle
 import com.jetbrains.python.psi.LanguageLevel
 import com.jetbrains.python.statistics.*
 
-class PythonNewProjectWizardCollector : CounterUsagesCollector() {
+object PythonNewProjectWizardCollector : CounterUsagesCollector() {
 
   override fun getGroup(): EventLogGroup {
     return GROUP
   }
 
-  companion object {
-    private val GROUP = EventLogGroup("python.new.project.wizard", 2)
-    private val INHERIT_GLOBAL_SITE_PACKAGE_FIELD = EventFields.Boolean("inherit_global_site_package")
-    private val MAKE_AVAILABLE_TO_ALL_PROJECTS = EventFields.Boolean("make_available_to_all_projects")
-    private val PREVIOUSLY_CONFIGURED = EventFields.Boolean("previously_configured")
-    private val GENERATOR_FIELD = EventFields.Class("generator")
-    private val DJANGO_ADMIN_FIELD = EventFields.Boolean("django_admin")
-    private val PROJECT_GENERATED_EVENT = GROUP.registerVarargEvent("project.generated",
-                                                            INTERPRETER_TYPE,
-                                                            EXECUTION_TYPE,
-                                                            PYTHON_VERSION,
-                                                            GENERATOR_FIELD,
-                                                            INHERIT_GLOBAL_SITE_PACKAGE_FIELD,
-                                                            MAKE_AVAILABLE_TO_ALL_PROJECTS,
-                                                            PREVIOUSLY_CONFIGURED)
+  private val GROUP = EventLogGroup("python.new.project.wizard", 2)
+  private val INHERIT_GLOBAL_SITE_PACKAGE_FIELD = EventFields.Boolean("inherit_global_site_package")
+  private val MAKE_AVAILABLE_TO_ALL_PROJECTS = EventFields.Boolean("make_available_to_all_projects")
+  private val PREVIOUSLY_CONFIGURED = EventFields.Boolean("previously_configured")
+  private val GENERATOR_FIELD = EventFields.Class("generator")
+  private val DJANGO_ADMIN_FIELD = EventFields.Boolean("django_admin")
+  private val PROJECT_GENERATED_EVENT = GROUP.registerVarargEvent("project.generated",
+                                                                  INTERPRETER_TYPE,
+                                                                  EXECUTION_TYPE,
+                                                                  PYTHON_VERSION,
+                                                                  GENERATOR_FIELD,
+                                                                  INHERIT_GLOBAL_SITE_PACKAGE_FIELD,
+                                                                  MAKE_AVAILABLE_TO_ALL_PROJECTS,
+                                                                  PREVIOUSLY_CONFIGURED)
 
-    private val DJANGO_ADMIN_CHECKED = GROUP.registerEvent("django.admin.selected", DJANGO_ADMIN_FIELD)
+  private val DJANGO_ADMIN_CHECKED = GROUP.registerEvent("django.admin.selected", DJANGO_ADMIN_FIELD)
 
-    fun logPythonNewProjectGenerated(info: InterpreterStatisticsInfo, pythonVersion: LanguageLevel, generatorClass: Class<*>) {
-      PROJECT_GENERATED_EVENT.log(
-        INTERPRETER_TYPE.with(info.type.value),
-        EXECUTION_TYPE.with(info.target.value),
-        PYTHON_VERSION.with(pythonVersion.toPythonVersion()),
-        INHERIT_GLOBAL_SITE_PACKAGE_FIELD.with(info.globalSitePackage),
-        MAKE_AVAILABLE_TO_ALL_PROJECTS.with(info.makeAvailableToAllProjects),
-        PREVIOUSLY_CONFIGURED.with(info.previouslyConfigured),
-        GENERATOR_FIELD.with(generatorClass)
-      )
-    }
+  @JvmStatic
+  fun logPythonNewProjectGenerated(info: InterpreterStatisticsInfo, pythonVersion: LanguageLevel, generatorClass: Class<*>) {
+    PROJECT_GENERATED_EVENT.log(
+      INTERPRETER_TYPE.with(info.type.value),
+      EXECUTION_TYPE.with(info.target.value),
+      PYTHON_VERSION.with(pythonVersion.toPythonVersion()),
+      INHERIT_GLOBAL_SITE_PACKAGE_FIELD.with(info.globalSitePackage),
+      MAKE_AVAILABLE_TO_ALL_PROJECTS.with(info.makeAvailableToAllProjects),
+      PREVIOUSLY_CONFIGURED.with(info.previouslyConfigured),
+      GENERATOR_FIELD.with(generatorClass)
+    )
+  }
 
-    fun logDjangoAdminSelected(djangoAdminSelected: Boolean) {
-      DJANGO_ADMIN_CHECKED.log(djangoAdminSelected)
-    }
+  @JvmStatic
+  fun logDjangoAdminSelected(djangoAdminSelected: Boolean) {
+    DJANGO_ADMIN_CHECKED.log(djangoAdminSelected)
   }
 }
 

python/src/com/jetbrains/python/packaging/statistics/PythonPackagesToolwindowStatisticsCollector.kt

@@ -4,23 +4,14 @@ package com.jetbrains.python.packaging.statistics
 import com.intellij.internal.statistic.eventLog.EventLogGroup
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
 
-class PythonPackagesToolwindowStatisticsCollector : CounterUsagesCollector() {
+object PythonPackagesToolwindowStatisticsCollector : CounterUsagesCollector() {
 
   override fun getGroup() = GROUP
 
-  companion object {
-    private val GROUP = EventLogGroup("python.packages.toolwindow", 1)
+  private val GROUP = EventLogGroup("python.packages.toolwindow", 1)
 
-    @JvmStatic
-    val installPackageEvent = GROUP.registerEvent("installed")
-
-    @JvmStatic
-    val uninstallPackageEvent = GROUP.registerEvent("uninstalled")
-
-    @JvmStatic
-    val requestDetailsEvent = GROUP.registerEvent("details.requested")
-
-    @JvmStatic
-    val repositoriesChangedEvent = GROUP.registerEvent("repositories.changed")
-  }
+  val installPackageEvent = GROUP.registerEvent("installed")
+  val uninstallPackageEvent = GROUP.registerEvent("uninstalled")
+  val requestDetailsEvent = GROUP.registerEvent("details.requested")
+  val repositoriesChangedEvent = GROUP.registerEvent("repositories.changed")
 }

python/src/com/jetbrains/python/sdk/add/collector/PythonNewInterpreterAddedCollector.kt

@@ -6,26 +6,22 @@ import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesColle
 import com.intellij.openapi.projectRoots.Sdk
 import com.jetbrains.python.statistics.*
 
-class PythonNewInterpreterAddedCollector : CounterUsagesCollector() {
+object PythonNewInterpreterAddedCollector : CounterUsagesCollector() {
 
-  override fun getGroup(): EventLogGroup {
-    return GROUP
-  }
+  override fun getGroup(): EventLogGroup = GROUP
 
-  companion object {
-    private val GROUP = EventLogGroup("python.new.interpreter.added", 1)
-    private val PROJECT_GENERATED_EVENT = GROUP.registerVarargEvent("interpreted.added",
-                                                                    INTERPRETER_TYPE,
-                                                                    EXECUTION_TYPE,
-                                                                    PYTHON_VERSION)
+  private val GROUP = EventLogGroup("python.new.interpreter.added", 1)
+  private val PROJECT_GENERATED_EVENT = GROUP.registerVarargEvent("interpreted.added",
+                                                                  INTERPRETER_TYPE,
+                                                                  EXECUTION_TYPE,
+                                                                  PYTHON_VERSION)
 
-    fun logPythonNewInterpreterAdded(sdk: Sdk) {
-      PROJECT_GENERATED_EVENT.log(
-        INTERPRETER_TYPE.with(sdk.interpreterType.value),
-        EXECUTION_TYPE.with(sdk.executionType.value),
-        PYTHON_VERSION.with(sdk.version.toPythonVersion())
-      )
-    }
+  fun logPythonNewInterpreterAdded(sdk: Sdk) {
+    PROJECT_GENERATED_EVENT.log(
+      INTERPRETER_TYPE.with(sdk.interpreterType.value),
+      EXECUTION_TYPE.with(sdk.executionType.value),
+      PYTHON_VERSION.with(sdk.version.toPythonVersion())
+    )
   }
 }
 

spellchecker/src/com/intellij/spellchecker/statistics/SpellcheckerActionStatistics.kt

@@ -2,19 +2,16 @@
 package com.intellij.spellchecker.statistics
 
 import com.intellij.internal.statistic.eventLog.EventLogGroup
-import com.intellij.internal.statistic.eventLog.events.EventId
 import com.intellij.internal.statistic.service.fus.collectors.CounterUsagesCollector
-import com.intellij.internal.statistic.service.fus.collectors.FUCounterUsageLogger
-import com.intellij.openapi.project.Project
 
-class SpellcheckerActionStatistics : CounterUsagesCollector() {
+object SpellcheckerActionStatistics : CounterUsagesCollector() {
   override fun getGroup(): EventLogGroup = GROUP
 
-  companion object {
-    private val GROUP = EventLogGroup("spellchecker.events", 2)
-    @JvmField
-    val REMOVE_FROM_ACCEPTED_WORDS = GROUP.registerEvent("remove.from.accepted.words.ui")
-    @JvmField
-    val ADD_TO_ACCEPTED_WORDS = GROUP.registerEvent("add.to.accepted.words.ui")
-  }
+  private val GROUP = EventLogGroup("spellchecker.events", 2)
+
+  @JvmField
+  val REMOVE_FROM_ACCEPTED_WORDS = GROUP.registerEvent("remove.from.accepted.words.ui")
+
+  @JvmField
+  val ADD_TO_ACCEPTED_WORDS = GROUP.registerEvent("add.to.accepted.words.ui")
 }