Cleanup compiler warnings (#3094)

rli · web-flow · commit 5c87fd9fe015 · 2022-03-09T10:39:41.000-08:00
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/core/AwsResourceCache.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/core/AwsResourceCache.kt
@@ -11,6 +11,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.util.Alarm
 import com.intellij.util.AlarmFactory
 import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.async
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.launch
@@ -273,6 +274,7 @@ class ExecutableBackedCacheResource<ReturnType, ExecType : ExecutableType<*>>(
     override fun toString(): String = "ExecutableBackedCacheResource(id='$id')"
 }
 
+@ExperimentalCoroutinesApi
 class DefaultAwsResourceCache(
     private val clock: Clock,
     private val maximumCacheEntries: Int,
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/core/explorer/ExplorerToolWindow.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/core/explorer/ExplorerToolWindow.kt
@@ -80,7 +80,7 @@ class ExplorerToolWindow(project: Project) : SimpleToolWindowPanel(true, true),
     private val awsTreeModel = AwsExplorerTreeStructure(project)
 
     // The 4 max threads is arbitrary, but we want > 1 so that we can load more than one node at a time
-    private val structureTreeModel = StructureTreeModel(awsTreeModel, null, Invoker.Background(this, 4), this)
+    private val structureTreeModel = StructureTreeModel(awsTreeModel, null, Invoker.forBackgroundPoolWithReadAction(this), this)
     private val awsTree = createTree(AsyncTreeModel(structureTreeModel, true, this))
     private val awsTreePanel = ScrollPaneFactory.createScrollPane(awsTree)
     private val accountSettingsManager = AwsConnectionManager.getInstance(project)
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/core/tools/ToolConfigurable.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/core/tools/ToolConfigurable.kt
@@ -53,6 +53,7 @@ class ToolConfigurable : BoundConfigurable(message("executableCommon.configurabl
     }
 
     override fun disposeUIResources() {
+        // TODO: why are we overriding and not allowing the disposable to be disposed?
         panel.drop()
     }
 
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/services/clouddebug/CloudDebugResolver.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/services/clouddebug/CloudDebugResolver.kt
@@ -8,6 +8,7 @@ import com.fasterxml.jackson.databind.DeserializationFeature
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.SystemInfo
+import com.intellij.util.system.CpuArch
 import com.intellij.util.text.SemVer
 import org.apache.commons.codec.digest.DigestUtils
 import software.aws.toolkits.jetbrains.core.executables.ExecutableInstance
@@ -149,7 +150,7 @@ object CloudDebugResolver {
     }
 
     private fun generateCloudDebugManifestUrl(suffix: String): String {
-        if (!SystemInfo.is64Bit) {
+        if (CpuArch.CURRENT.width != 64) {
             throw RuntimeException("Cloud Debugging requires a 64-bit OS")
         }
         val os = when {
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/services/clouddebug/execution/CloudDebugCliStep.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/services/clouddebug/execution/CloudDebugCliStep.kt
@@ -24,20 +24,20 @@ import java.util.concurrent.atomic.AtomicReference
 abstract class CloudDebugCliStep : CliBasedStep() {
     protected fun getCli(context: Context): GeneralCommandLine = context.getRequiredAttribute(CloudDebugCliValidate.EXECUTABLE_ATTRIBUTE).getCommandLine()
 
-    override fun handleErrorResult(exitCode: Int, output: String, messageEmitter: StepEmitter) {
+    override fun handleErrorResult(exitCode: Int, output: String, stepEmitter: StepEmitter) {
         if (output.isNotEmpty()) {
-            messageEmitter.emitMessage("Error details:\n", true)
+            stepEmitter.emitMessage("Error details:\n", true)
             CliOutputParser.parseErrorOutput(output)?.run {
                 errors.forEach {
-                    messageEmitter.emitMessage("\t- $it\n", true)
+                    stepEmitter.emitMessage("\t- $it\n", true)
                 }
-            } ?: messageEmitter.emitMessage(output, true)
+            } ?: stepEmitter.emitMessage(output, true)
         }
 
         throw IllegalStateException(message("cloud_debug.step.general.cli_error"))
     }
 
-    override fun createProcessEmitter(messageEmitter: StepEmitter): ProcessListener = CliOutputEmitter(messageEmitter)
+    override fun createProcessEmitter(stepEmitter: StepEmitter): ProcessListener = CliOutputEmitter(stepEmitter)
 
     private class CliOutputEmitter(private val messageEmitter: StepEmitter) : ProcessAdapter() {
         val previousLevel = AtomicReference<Level>(null)
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/services/clouddebug/execution/steps/CloudDebugCliValidate.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/services/clouddebug/execution/steps/CloudDebugCliValidate.kt
@@ -17,8 +17,8 @@ import software.aws.toolkits.resources.message
 class CloudDebugCliValidate : Step() {
     override val stepName = "Checking for cloud-debug validity and updates"
 
-    override fun execute(context: Context, messageEmitter: StepEmitter, ignoreCancellation: Boolean) {
-        CloudDebugResolver.validateOrUpdateCloudDebug(context.getRequiredAttribute(Context.PROJECT_ATTRIBUTE), messageEmitter, context)
+    override fun execute(context: Context, stepEmitter: StepEmitter, ignoreCancellation: Boolean) {
+        CloudDebugResolver.validateOrUpdateCloudDebug(context.getRequiredAttribute(Context.PROJECT_ATTRIBUTE), stepEmitter, context)
     }
 
     companion object {
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/services/clouddebug/execution/steps/ResourceInstrumenter.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/services/clouddebug/execution/steps/ResourceInstrumenter.kt
@@ -51,7 +51,7 @@ class ResourceInstrumenter(private val settings: EcsServiceCloudDebuggingRunSett
         )
     }
 
-    override fun handleSuccessResult(output: String, messageEmitter: StepEmitter, context: Context) {
+    override fun handleSuccessResult(output: String, stepEmitter: StepEmitter, context: Context) {
         val targets = CliOutputParser.parseInstrumentResponse(output) ?: throw RuntimeException("Could not get targets from response")
         /* TODO uncomment this when the cli conforms to the contract
         val mappedTargets = targets.targets.map { it.name to it.target }.toMap()
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/services/clouddebug/execution/steps/RetrieveRole.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/services/clouddebug/execution/steps/RetrieveRole.kt
@@ -22,7 +22,7 @@ class RetrieveRole(private val settings: EcsServiceCloudDebuggingRunSettings) :
 
     override fun execute(
         context: Context,
-        messageEmitter: StepEmitter,
+        stepEmitter: StepEmitter,
         ignoreCancellation: Boolean
     ) {
         val startTime = Instant.now()
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/services/clouddebug/execution/steps/StopApplications.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/services/clouddebug/execution/steps/StopApplications.kt
@@ -65,11 +65,11 @@ class StopApplication(
         )
     }
 
-    override fun handleErrorResult(exitCode: Int, output: String, messageEmitter: StepEmitter) =
+    override fun handleErrorResult(exitCode: Int, output: String, stepEmitter: StepEmitter) =
         if (isCleanup) {
-            super.handleErrorResult(exitCode, output, messageEmitter)
+            super.handleErrorResult(exitCode, output, stepEmitter)
         } else {
-            messageEmitter.emitMessage(output, true)
+            stepEmitter.emitMessage(output, true)
             // suppress the error if stop fails
         }
 }
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/services/cloudformation/stack/EventsFetcher.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/services/cloudformation/stack/EventsFetcher.kt
@@ -42,6 +42,7 @@ class EventsFetcher(private val stackName: String) {
         when (pageToSwitchTo) {
             Page.NEXT -> currentPage?.let { previousPages.add(it) } // Store current as prev
             Page.PREVIOUS -> if (previousPages.isNotEmpty()) previousPages.removeAt(previousPages.size - 1)
+            else -> {}
         }
         nextPage = response.nextToken()
         currentPage = pageToFetch
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/services/ecs/execution/ContainerMappingTable.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/services/ecs/execution/ContainerMappingTable.kt
@@ -20,7 +20,7 @@ abstract class ContainerMappingTable<T>(emptyTableMainText: String, addNewEntryT
 
             emptyText.appendSecondaryText(
                 addNewEntryText,
-                SimpleTextAttributes(SimpleTextAttributes.STYLE_PLAIN, JBUI.CurrentTheme.Link.linkColor())
+                SimpleTextAttributes(SimpleTextAttributes.STYLE_PLAIN, JBUI.CurrentTheme.Link.Foreground.ENABLED)
             ) {
                 stopEditing()
 
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/services/lambda/steps/AttachDebugger.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/services/lambda/steps/AttachDebugger.kt
@@ -32,7 +32,7 @@ class AttachDebugger(val environment: ExecutionEnvironment, val state: SamRunnin
     override val stepName = message("sam.debug.attach")
     override val hidden = false
 
-    override fun execute(context: Context, messageEmitter: StepEmitter, ignoreCancellation: Boolean) {
+    override fun execute(context: Context, stepEmitter: StepEmitter, ignoreCancellation: Boolean) {
         try {
             val samProcessHandler = getSamProcess(context)
             val samCompleted = AtomicBoolean(false)
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/services/lambda/steps/BuildLambda.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/services/lambda/steps/BuildLambda.kt
@@ -33,7 +33,7 @@ class BuildLambda(private val request: BuildLambdaRequest) : SamCliStep() {
         samOptions = request.samOptions
     )
 
-    override fun handleSuccessResult(output: String, messageEmitter: StepEmitter, context: Context) {
+    override fun handleSuccessResult(output: String, stepEmitter: StepEmitter, context: Context) {
         context.putAttribute(BUILT_LAMBDA, BuiltLambda(request.buildDir.resolve("template.yaml"), request.logicalId))
     }
 
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/services/lambda/steps/CreateLambda.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/services/lambda/steps/CreateLambda.kt
@@ -16,7 +16,7 @@ import software.aws.toolkits.resources.message
 class CreateLambda(private val lambdaClient: LambdaClient, private val details: FunctionDetails) : Step() {
     override val stepName = message("lambda.create.step.create_lambda")
 
-    override fun execute(context: Context, messageEmitter: StepEmitter, ignoreCancellation: Boolean) {
+    override fun execute(context: Context, stepEmitter: StepEmitter, ignoreCancellation: Boolean) {
         lambdaClient.createFunction {
             it.functionName(details.name)
             it.description(details.description)
@@ -50,7 +50,7 @@ class CreateLambda(private val lambdaClient: LambdaClient, private val details:
             }
         }
 
-        messageEmitter.emitMessage(message("lambda.workflow.update_code.wait_for_stable"), isError = false)
+        stepEmitter.emitMessage(message("lambda.workflow.update_code.wait_for_stable"), isError = false)
         val response = lambdaClient.waiter().waitUntilFunctionExists() { it.functionName(details.name) }.matched().response().get()
 
         // Also wait for it to become active
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/services/lambda/steps/PackageLambda.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/services/lambda/steps/PackageLambda.kt
@@ -30,7 +30,7 @@ class PackageLambda(
         ecrRepo = ecrRepo
     )
 
-    override fun handleSuccessResult(output: String, messageEmitter: StepEmitter, context: Context) {
+    override fun handleSuccessResult(output: String, stepEmitter: StepEmitter, context: Context) {
         // We finished the upload, extract out the uploaded code location if we have a logicalId
         logicalId ?: return
 
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/utils/execution/steps/CliBasedStep.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/utils/execution/steps/CliBasedStep.kt
@@ -25,7 +25,7 @@ abstract class CliBasedStep : Step() {
     protected open fun onProcessStart(context: Context, processHandler: ProcessHandler) {}
     protected open fun createProcessEmitter(stepEmitter: StepEmitter): ProcessListener = CliOutputEmitter(stepEmitter)
 
-    protected open fun handleSuccessResult(output: String, messageEmitter: StepEmitter, context: Context) {}
+    protected open fun handleSuccessResult(output: String, stepEmitter: StepEmitter, context: Context) {}
 
     /**
      * Processes the command's stdout and throws an exception after the CLI exits with failure.
@@ -35,7 +35,7 @@ abstract class CliBasedStep : Step() {
         throw IllegalStateException(message("general.execution.cli_error", exitCode))
     }
 
-    final override fun execute(context: Context, messageEmitter: StepEmitter, ignoreCancellation: Boolean) {
+    final override fun execute(context: Context, stepEmitter: StepEmitter, ignoreCancellation: Boolean) {
         val startTime = Instant.now()
         var result = Result.Succeeded
         try {
@@ -50,8 +50,8 @@ abstract class CliBasedStep : Step() {
             val processHandler = createProcessHandler(commandLine, context)
             val processCapture = CapturingProcessAdapter()
             processHandler.addProcessListener(processCapture)
-            processHandler.addProcessListener(createProcessEmitter(messageEmitter))
-            messageEmitter.attachProcess(processHandler)
+            processHandler.addProcessListener(createProcessEmitter(stepEmitter))
+            stepEmitter.attachProcess(processHandler)
             processHandler.startNotify()
 
             monitorProcess(processHandler, context, ignoreCancellation)
@@ -61,11 +61,11 @@ abstract class CliBasedStep : Step() {
             }
 
             if (processHandler.exitCode == 0) {
-                handleSuccessResult(processCapture.output.stdout, messageEmitter, context)
+                handleSuccessResult(processCapture.output.stdout, stepEmitter, context)
                 return
             }
 
-            handleErrorResult(processCapture.output.exitCode, processCapture.output.stdout, messageEmitter)
+            handleErrorResult(processCapture.output.exitCode, processCapture.output.stdout, stepEmitter)
         } catch (e: SkipStepException) {
             LOG.debug(e) { """Step "$stepName" skipped!""" }
         } catch (e: ProcessCanceledException) {
diff --git a/jetbrains-core/src/software/aws/toolkits/jetbrains/utils/execution/steps/Step.kt b/jetbrains-core/src/software/aws/toolkits/jetbrains/utils/execution/steps/Step.kt
@@ -33,7 +33,7 @@ abstract class Step {
         }
     }
 
-    protected abstract fun execute(context: Context, messageEmitter: StepEmitter, ignoreCancellation: Boolean)
+    protected abstract fun execute(context: Context, stepEmitter: StepEmitter, ignoreCancellation: Boolean)
 
     /**
      * Exception used to abort out of a step and mark it as skipped. This may be used in the case that a step has to make a decision before it decides it
diff --git a/jetbrains-core/tst-211-212/software/aws/toolkits/jetbrains/core/explorer/AwsExplorerNodeProcessorTestUtils.kt b/jetbrains-core/tst-211-212/software/aws/toolkits/jetbrains/core/explorer/AwsExplorerNodeProcessorTestUtils.kt
diff --git a/jetbrains-core/tst-211-213/software/aws/toolkits/jetbrains/core/EditorUtils.kt b/jetbrains-core/tst-211-213/software/aws/toolkits/jetbrains/core/EditorUtils.kt
@@ -10,6 +10,7 @@ import com.intellij.testFramework.PlatformTestUtil
 import com.intellij.ui.EditorNotificationPanel
 import com.intellij.ui.EditorNotifications
 
+@Suppress("UNUSED_PARAMETER")
 fun <T : EditorNotifications.Provider<*>, U : EditorNotificationPanel> getEditorNotifications(editor: FileEditor, provider: Class<T>, key: Key<U>): U? {
     PlatformTestUtil.dispatchAllInvocationEventsInIdeEventQueue()
     NonBlockingReadActionImpl.waitForAsyncTaskCompletion()
diff --git a/jetbrains-core/tst-213+/software/aws/toolkits/jetbrains/core/explorer/AwsExplorerNodeProcessorTestUtils.kt b/jetbrains-core/tst-213+/software/aws/toolkits/jetbrains/core/explorer/AwsExplorerNodeProcessorTestUtils.kt
diff --git a/jetbrains-core/tst-221+/software/aws/toolkits/jetbrains/core/EditorUtils.kt b/jetbrains-core/tst-221+/software/aws/toolkits/jetbrains/core/EditorUtils.kt
@@ -11,6 +11,7 @@ import com.intellij.ui.EditorNotificationPanel
 import com.intellij.ui.EditorNotificationProvider
 import com.intellij.ui.EditorNotificationsImpl
 
+@Suppress("UNUSED_PARAMETER")
 fun <T : EditorNotificationProvider, U : EditorNotificationPanel> getEditorNotifications(editor: FileEditor, provider: Class<T>, key: Key<U>): U? {
     PlatformTestUtil.dispatchAllInvocationEventsInIdeEventQueue()
     NonBlockingReadActionImpl.waitForAsyncTaskCompletion()
diff --git a/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/AwsResourceCacheTest.kt b/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/AwsResourceCacheTest.kt
@@ -6,6 +6,7 @@ package software.aws.toolkits.jetbrains.core
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.testFramework.ProjectRule
 import com.intellij.testFramework.RuleChain
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.runBlocking
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatThrownBy
@@ -46,6 +47,7 @@ import java.util.concurrent.TimeUnit
 import java.util.concurrent.TimeoutException
 import java.util.concurrent.atomic.AtomicInteger
 
+@ExperimentalCoroutinesApi
 class AwsResourceCacheTest {
     private val projectRule = ProjectRule()
     private val credentialsManager = MockCredentialManagerRule()
diff --git a/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/credentials/MockAwsConnectionManager.kt b/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/credentials/MockAwsConnectionManager.kt
@@ -25,6 +25,7 @@ class MockAwsConnectionManager(project: Project) : AwsConnectionManager(project)
         recentlyUsedRegions.clear()
         recentlyUsedProfiles.clear()
         val regionProvider = AwsRegionProvider.getInstance()
+        @Suppress("DEPRECATION")
         changeConnectionSettings(DUMMY_PROVIDER_IDENTIFIER, regionProvider.defaultRegion())
 
         waitUntilConnectionStateIsStable()
diff --git a/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/credentials/MockCredentialsManager.kt b/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/credentials/MockCredentialsManager.kt
@@ -26,6 +26,7 @@ class MockCredentialsManager : CredentialManager() {
         reset()
     }
 
+    @Suppress("DEPRECATION")
     fun reset() {
         getCredentialIdentifiers().filterNot { it.id == DUMMY_PROVIDER_IDENTIFIER.id }.forEach { removeProvider(it) }
 
diff --git a/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/execution/AwsConnectionExtensionSettingsEditorTest.kt b/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/execution/AwsConnectionExtensionSettingsEditorTest.kt
@@ -132,7 +132,7 @@ class AwsConnectionExtensionSettingsEditorTest {
         satisfies {
             val updatedConfiguration = createConfiguration { }
             it.applyTo(updatedConfiguration)
-            assertThat(updatedConfiguration.extensionOptions()).isEqualToComparingFieldByField(AwsCredentialInjectionOptions(expected))
+            assertThat(updatedConfiguration.extensionOptions()).usingRecursiveComparison().isEqualTo(AwsCredentialInjectionOptions(expected))
         }
     }
 }
diff --git a/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/execution/JavaAwsConnectionExtensionTest.kt b/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/execution/JavaAwsConnectionExtensionTest.kt
@@ -66,7 +66,7 @@ class JavaAwsConnectionExtensionTest {
         deserialized.readExternal(element)
 
         assertThat(deserialized.mainClassName).isEqualTo("com.bla.Boop")
-        assertThat(deserialized.getCopyableUserData(AWS_CONNECTION_RUN_CONFIGURATION_KEY)).isEqualToComparingFieldByField(data)
+        assertThat(deserialized.getCopyableUserData(AWS_CONNECTION_RUN_CONFIGURATION_KEY)).usingRecursiveComparison().isEqualTo(data)
     }
 
     @Test
diff --git a/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/explorer/AwsExplorerNodeProcessorTest.kt b/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/explorer/AwsExplorerNodeProcessorTest.kt
@@ -13,6 +13,7 @@ import com.intellij.testFramework.ProjectRule
 import com.intellij.ui.tree.AsyncTreeModel
 import com.intellij.ui.tree.StructureTreeModel
 import com.intellij.ui.treeStructure.Tree
+import com.intellij.util.concurrency.Invoker
 import com.intellij.util.ui.tree.TreeUtil
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.Before
@@ -103,7 +104,7 @@ class AwsExplorerNodeProcessorTest {
         val structureTreeModel = StructureTreeModel(
             awsTreeModel,
             null,
-            AwsExplorerNodeProcessorTestUtils.getInvoker(disposableRule.disposable),
+            Invoker.forBackgroundPoolWithoutReadAction(disposableRule.disposable),
             disposableRule.disposable
         )
         return AsyncTreeModel(structureTreeModel, false, disposableRule.disposable)
diff --git a/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/notification/MinimumVersionChangeTest.kt b/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/notification/MinimumVersionChangeTest.kt
@@ -4,6 +4,7 @@
 package software.aws.toolkits.jetbrains.core.notification
 
 import com.intellij.ide.util.PropertiesComponent
+import com.intellij.openapi.actionSystem.DataKey
 import com.intellij.openapi.actionSystem.impl.SimpleDataContext
 import com.intellij.openapi.application.ApplicationInfo
 import com.intellij.openapi.application.ApplicationManager
@@ -125,8 +126,12 @@ class MinimumVersionChangeTest {
         // While this code should never throw...the DateKey for the Notification is private, so we can't make this logic 100% safe forever.
         // The logic that makes use of it is to dismiss the balloon and runs after our logic, so it should be safe.
         runCatching {
-            val actionEvent = TestActionEvent(SimpleDataContext.getSimpleContext("Notification", notifications.notifications.first()))
-            notifications.notifications.first().actions.first().actionPerformed(actionEvent)
+            val notification = notifications.notifications.first()
+            val context = SimpleDataContext.builder()
+                .add(DataKey.create("Notification"), notification)
+                .build()
+            val actionEvent = TestActionEvent(context)
+            notification.actions.first().actionPerformed(actionEvent)
         }
 
         assertThat(PropertiesComponent.getInstance().getBoolean(MinimumVersionChange.IGNORE_PROMPT)).isTrue
diff --git a/jetbrains-core/tst/software/aws/toolkits/jetbrains/services/cloudwatch/logs/insights/QueryActorTest.kt b/jetbrains-core/tst/software/aws/toolkits/jetbrains/services/cloudwatch/logs/insights/QueryActorTest.kt
@@ -5,6 +5,7 @@ package software.aws.toolkits.jetbrains.services.cloudwatch.logs.insights
 
 import com.intellij.ui.table.TableView
 import com.intellij.util.ui.ListTableModel
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.test.runBlockingTest
@@ -31,6 +32,7 @@ import software.aws.toolkits.resources.message
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 
+@ExperimentalCoroutinesApi
 class QueryActorTest : BaseCoroutineTest() {
     private lateinit var client: CloudWatchLogsClient
     private lateinit var tableModel: ListTableModel<LogResult>
diff --git a/jetbrains-core/tst/software/aws/toolkits/jetbrains/services/ecr/EcrUtilsTest.kt b/jetbrains-core/tst/software/aws/toolkits/jetbrains/services/ecr/EcrUtilsTest.kt
diff --git a/jetbrains-core/tst/software/aws/toolkits/jetbrains/services/ecs/exec/DisableEcsExecuteCommandTest.kt b/jetbrains-core/tst/software/aws/toolkits/jetbrains/services/ecs/exec/DisableEcsExecuteCommandTest.kt
diff --git a/jetbrains-core/tst/software/aws/toolkits/jetbrains/services/ecs/exec/EnableEcsExecuteCommandTest.kt b/jetbrains-core/tst/software/aws/toolkits/jetbrains/services/ecs/exec/EnableEcsExecuteCommandTest.kt
diff --git a/jetbrains-core/tst/software/aws/toolkits/jetbrains/services/s3/objectActions/ObjectActionTestBase.kt b/jetbrains-core/tst/software/aws/toolkits/jetbrains/services/s3/objectActions/ObjectActionTestBase.kt
diff --git a/jetbrains-core/tst/software/aws/toolkits/jetbrains/utils/BaseCoroutineTest.kt b/jetbrains-core/tst/software/aws/toolkits/jetbrains/utils/BaseCoroutineTest.kt
diff --git a/jetbrains-core/tst/software/aws/toolkits/jetbrains/utils/execution/steps/StepTest.kt b/jetbrains-core/tst/software/aws/toolkits/jetbrains/utils/execution/steps/StepTest.kt
diff --git a/jetbrains-core/tst/software/aws/toolkits/jetbrains/utils/rules/RunWithRealCredentials.kt b/jetbrains-core/tst/software/aws/toolkits/jetbrains/utils/rules/RunWithRealCredentials.kt
diff --git a/jetbrains-rider/src/software/aws/toolkits/jetbrains/services/clouddebug/DotNetStartupCommand.kt b/jetbrains-rider/src/software/aws/toolkits/jetbrains/services/clouddebug/DotNetStartupCommand.kt
diff --git a/jetbrains-rider/src/software/aws/toolkits/jetbrains/services/lambda/LambdaDaemonHost.kt b/jetbrains-rider/src/software/aws/toolkits/jetbrains/services/lambda/LambdaDaemonHost.kt
diff --git a/jetbrains-rider/src/software/aws/toolkits/jetbrains/services/lambda/dotnet/DebuggingSteps.kt b/jetbrains-rider/src/software/aws/toolkits/jetbrains/services/lambda/dotnet/DebuggingSteps.kt
diff --git a/jetbrains-ultimate/src/software/aws/toolkits/jetbrains/services/lambda/nodejs/NodeJsLambdaBuilder.kt b/jetbrains-ultimate/src/software/aws/toolkits/jetbrains/services/lambda/nodejs/NodeJsLambdaBuilder.kt

Original file line number	Diff line number	Diff line change
`@@ -53,6 +53,7 @@ class ToolConfigurable : BoundConfigurable(message("executableCommon.configurabl`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`override fun disposeUIResources() {`
	`56`	`+ // TODO: why are we overriding and not allowing the disposable to be disposed?`
`56`	`57`	`panel.drop()`
`57`	`58`	`}`
`58`	`59`
Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,8 @@ import software.aws.toolkits.resources.message`
`17`	`17`	`class CloudDebugCliValidate : Step() {`
`18`	`18`	`override val stepName = "Checking for cloud-debug validity and updates"`
`19`	`19`
`20`		`- override fun execute(context: Context, messageEmitter: StepEmitter, ignoreCancellation: Boolean) {`
`21`		`- CloudDebugResolver.validateOrUpdateCloudDebug(context.getRequiredAttribute(Context.PROJECT_ATTRIBUTE), messageEmitter, context)`
	`20`	`+ override fun execute(context: Context, stepEmitter: StepEmitter, ignoreCancellation: Boolean) {`
	`21`	`+ CloudDebugResolver.validateOrUpdateCloudDebug(context.getRequiredAttribute(Context.PROJECT_ATTRIBUTE), stepEmitter, context)`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`companion object {`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ class ResourceInstrumenter(private val settings: EcsServiceCloudDebuggingRunSett`
`51`	`51`	`)`
`52`	`52`	`}`
`53`	`53`
`54`		`- override fun handleSuccessResult(output: String, messageEmitter: StepEmitter, context: Context) {`
	`54`	`+ override fun handleSuccessResult(output: String, stepEmitter: StepEmitter, context: Context) {`
`55`	`55`	`val targets = CliOutputParser.parseInstrumentResponse(output) ?: throw RuntimeException("Could not get targets from response")`
`56`	`56`	`/* TODO uncomment this when the cli conforms to the contract`
`57`	`57`	`val mappedTargets = targets.targets.map { it.name to it.target }.toMap()`
Original file line number	Diff line number	Diff line change
`@@ -65,11 +65,11 @@ class StopApplication(`
`65`	`65`	`)`
`66`	`66`	`}`
`67`	`67`
`68`		`- override fun handleErrorResult(exitCode: Int, output: String, messageEmitter: StepEmitter) =`
	`68`	`+ override fun handleErrorResult(exitCode: Int, output: String, stepEmitter: StepEmitter) =`
`69`	`69`	`if (isCleanup) {`
`70`		`- super.handleErrorResult(exitCode, output, messageEmitter)`
	`70`	`+ super.handleErrorResult(exitCode, output, stepEmitter)`
`71`	`71`	`} else {`
`72`		`- messageEmitter.emitMessage(output, true)`
	`72`	`+ stepEmitter.emitMessage(output, true)`
`73`	`73`	`// suppress the error if stop fails`
`74`	`74`	`}`
`75`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,6 +42,7 @@ class EventsFetcher(private val stackName: String) {`
`42`	`42`	`when (pageToSwitchTo) {`
`43`	`43`	`Page.NEXT -> currentPage?.let { previousPages.add(it) } // Store current as prev`
`44`	`44`	`Page.PREVIOUS -> if (previousPages.isNotEmpty()) previousPages.removeAt(previousPages.size - 1)`
	`45`	`+ else -> {}`
`45`	`46`	`}`
`46`	`47`	`nextPage = response.nextToken()`
`47`	`48`	`currentPage = pageToFetch`