Merge branch 'main' into dogusata/add-description-to-feedback-form

dogusata · web-flow · commit d7aaad9d5860 · 2025-02-04T16:58:18.000+01:00
diff --git a/.changes/next-release/bugfix-24d6621e-32d3-45c5-a996-66232724e425.json b/.changes/next-release/bugfix-24d6621e-32d3-45c5-a996-66232724e425.json
@@ -0,0 +1,4 @@
+{
+  "type" : "bugfix",
+  "description" : "Amazon Q: Prevent IndexOutOfBoundsException by adding boundary checks for invalid range markers (#5187)"
+}
diff --git a/.changes/next-release/feature-6565a79c-90f3-4d49-abb6-ca4d5c0ff679.json b/.changes/next-release/feature-6565a79c-90f3-4d49-abb6-ca4d5c0ff679.json
@@ -0,0 +1,4 @@
+{
+  "type" : "feature",
+  "description" : "Amazon Q /review: Code issues can now be grouped by severity or file location."
+}
diff --git a/plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonqCodeTest/CodeWhispererUTGChatManager.kt b/plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonqCodeTest/CodeWhispererUTGChatManager.kt
@@ -16,14 +16,14 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
-import software.amazon.awssdk.core.exception.SdkServiceException
 import software.amazon.awssdk.services.codewhispererruntime.model.GetTestGenerationResponse
 import software.amazon.awssdk.services.codewhispererruntime.model.Range
 import software.amazon.awssdk.services.codewhispererruntime.model.StartTestGenerationResponse
 import software.amazon.awssdk.services.codewhispererruntime.model.TargetCode
 import software.amazon.awssdk.services.codewhispererruntime.model.TestGenerationJobStatus
 import software.amazon.awssdk.services.codewhispererstreaming.model.ExportContext
 import software.amazon.awssdk.services.codewhispererstreaming.model.ExportIntent
+import software.aws.toolkits.core.utils.Waiters.waitUntil
 import software.aws.toolkits.core.utils.debug
 import software.aws.toolkits.core.utils.error
 import software.aws.toolkits.core.utils.getLogger
@@ -58,6 +58,7 @@ import java.io.ByteArrayOutputStream
 import java.io.File
 import java.io.IOException
 import java.nio.file.Paths
+import java.time.Duration
 import java.time.Instant
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.zip.ZipInputStream
@@ -109,29 +110,38 @@ class CodeWhispererUTGChatManager(val project: Project, private val cs: Coroutin
 
         // 2nd API call: StartTestGeneration
         val startTestGenerationResponse = try {
-            startTestGeneration(
-                uploadId = createUploadUrlResponse.uploadId(),
-                targetCode = listOf(
-                    TargetCode.builder()
-                        .relativeTargetPath(codeTestResponseContext.currentFileRelativePath.toString())
-                        .targetLineRangeList(
-                            if (selectionRange != null) {
-                                listOf(
-                                    selectionRange
+            var response: StartTestGenerationResponse? = null
+
+            waitUntil(
+                succeedOn = { response?.sdkHttpResponse()?.statusCode() == 200 },
+                maxDuration = Duration.ofSeconds(1), // 1 second timeout
+            ) {
+                try {
+                    response = startTestGeneration(
+                        uploadId = createUploadUrlResponse.uploadId(),
+                        targetCode = listOf(
+                            TargetCode.builder()
+                                .relativeTargetPath(codeTestResponseContext.currentFileRelativePath.toString())
+                                .targetLineRangeList(
+                                    if (selectionRange != null) {
+                                        listOf(selectionRange)
+                                    } else {
+                                        emptyList()
+                                    }
                                 )
-                            } else {
-                                emptyList()
-                            }
-                        )
-                        .build()
-                ),
-                userInput = prompt
-            )
-        } catch (e: Exception) {
-            val statusCode = when {
-                e is SdkServiceException -> e.statusCode()
-                else -> 400
+                                .build()
+                        ),
+                        userInput = prompt
+                    )
+                    delay(200)
+                    response?.testGenerationJob() != null
+                } catch (e: Exception) {
+                    throw e
+                }
             }
+
+            response ?: throw RuntimeException("Failed to start test generation")
+        } catch (e: Exception) {
             LOG.error(e) { "Unexpected error while creating test generation job" }
             val errorMessage = getTelemetryErrorMessage(e, CodeWhispererConstants.FeatureName.TEST_GENERATION)
             throw CodeTestException(
diff --git a/plugins/amazonq/codewhisperer/jetbrains-community/resources/META-INF/plugin-codewhisperer.xml b/plugins/amazonq/codewhisperer/jetbrains-community/resources/META-INF/plugin-codewhisperer.xml
@@ -114,6 +114,11 @@
 
 
         <group id="aws.toolkit.codewhisperer.toolbar.security">
+            <group id="codewhisperer.toolbar.security.group" icon="AllIcons.Actions.GroupBy" text="Group" popup="true">
+                <separator text="Group By"/>
+                <group id="CodeWhispererCodeScanGroupBy"
+                       class="software.aws.toolkits.jetbrains.services.codewhisperer.codescan.actions.CodeWhispererCodeScanGroupingStrategyActionGroup" text="Group"/>
+            </group>
             <group id="codewhisperer.toolbar.security.filter" icon="AllIcons.General.Filter" text="Filter" popup="true">
                 <separator text="Severity"/>
                 <group id="CodeWhispererCodeScanFilterGroup"
diff --git a/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/CodeWhispererCodeScanManager.kt b/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/CodeWhispererCodeScanManager.kt
@@ -71,6 +71,7 @@ import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.listeners
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.listeners.CodeWhispererCodeScanFileListener
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.sessionconfig.CodeScanSessionConfig
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.AmazonQCodeReviewGitUtils.isInsideWorkTree
+import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.IssueGroupingStrategy
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.IssueSeverity
 import software.aws.toolkits.jetbrains.services.codewhisperer.credentials.CodeWhispererClientAdaptor
 import software.aws.toolkits.jetbrains.services.codewhisperer.editor.CodeWhispererEditorUtil.overlaps
@@ -138,8 +139,10 @@ class CodeWhispererCodeScanManager(val project: Project) {
         IssueSeverity.LOW.displayName to DefaultMutableTreeNode(IssueSeverity.LOW.displayName),
         IssueSeverity.INFO.displayName to DefaultMutableTreeNode(IssueSeverity.INFO.displayName)
     )
+    private val fileNodeLookup = mutableMapOf<VirtualFile, DefaultMutableTreeNode>()
     private val scanNodesLookup = mutableMapOf<VirtualFile, MutableList<DefaultMutableTreeNode>>()
     private val selectedSeverityValues = IssueSeverity.entries.associate { it.displayName to true }.toMutableMap()
+    private var selectedGroupingStrategy = IssueGroupingStrategy.SEVERITY
 
     private val documentListener = CodeWhispererCodeScanDocumentListener(project)
     private val editorMouseListener = CodeWhispererCodeScanEditorMouseMotionListener(project)
@@ -281,6 +284,12 @@ class CodeWhispererCodeScanManager(val project: Project) {
         updateCodeScanIssuesTree()
     }
 
+    fun getGroupingStrategySelected() = selectedGroupingStrategy
+    fun setGroupingStrategySelected(groupingStrategy: IssueGroupingStrategy) {
+        selectedGroupingStrategy = groupingStrategy
+        updateCodeScanIssuesTree()
+    }
+
     /**
      * Returns true if there are any code scan issues.
      */
@@ -868,7 +877,18 @@ class CodeWhispererCodeScanManager(val project: Project) {
                 node.removeAllChildren()
             }
         }
+        synchronized(fileNodeLookup) {
+            fileNodeLookup.clear()
+        }
 
+        return if (selectedGroupingStrategy == IssueGroupingStrategy.SEVERITY) {
+            createCodeScanIssuesTreeBySeverity(codeScanIssues)
+        } else {
+            createCodeScanIssuesTreeByFileLocation(codeScanIssues)
+        }
+    }
+
+    private fun createCodeScanIssuesTreeBySeverity(codeScanIssues: List<CodeWhispererCodeScanIssue>): DefaultMutableTreeNode {
         severityNodeLookup.forEach { (severity, node) ->
             if (selectedSeverityValues[severity] == true) {
                 synchronized(codeScanTreeNodeRoot) {
@@ -890,6 +910,27 @@ class CodeWhispererCodeScanManager(val project: Project) {
         return codeScanTreeNodeRoot
     }
 
+    private fun createCodeScanIssuesTreeByFileLocation(codeScanIssues: List<CodeWhispererCodeScanIssue>): DefaultMutableTreeNode {
+        codeScanIssues.forEach { issue ->
+            val fileNode = synchronized(fileNodeLookup) {
+                fileNodeLookup.getOrPut(issue.file) {
+                    val node = DefaultMutableTreeNode(issue.file)
+                    synchronized(codeScanTreeNodeRoot) {
+                        codeScanTreeNodeRoot.add(node)
+                    }
+                    node
+                }
+            }
+
+            val scanNode = DefaultMutableTreeNode(issue)
+            fileNode.add(scanNode)
+            scanNodesLookup.getOrPut(issue.file) {
+                mutableListOf()
+            }.add(scanNode)
+        }
+        return codeScanTreeNodeRoot
+    }
+
     private fun checkIssueCodeSnippet(codeSnippet: List<CodeLine>, startLine: Int, endLine: Int, documentLines: List<String>): Boolean = try {
         codeSnippet
             .asSequence()
diff --git a/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/CodeWhispererCodeScanResultsView.kt b/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/CodeWhispererCodeScanResultsView.kt
@@ -20,6 +20,7 @@ import com.intellij.util.ui.JBUI
 import icons.AwsIcons
 import kotlinx.coroutines.CoroutineScope
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.listeners.CodeWhispererCodeScanTreeMouseListener
+import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.IssueGroupingStrategy
 import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.IssueSeverity
 import software.aws.toolkits.jetbrains.services.codewhisperer.layout.CodeWhispererLayoutConfig
 import software.aws.toolkits.jetbrains.services.codewhisperer.layout.CodeWhispererLayoutConfig.addHorizontalGlue
@@ -47,6 +48,8 @@ import javax.swing.tree.TreePath
  */
 internal class CodeWhispererCodeScanResultsView(private val project: Project, private val defaultScope: CoroutineScope) : JPanel(BorderLayout()) {
 
+    private fun isGroupedBySeverity() = CodeWhispererCodeScanManager.getInstance(project).getGroupingStrategySelected() == IssueGroupingStrategy.SEVERITY
+
     private val codeScanTree: Tree = Tree().apply {
         isRootVisible = false
         CodeWhispererCodeScanTreeMouseListener(project).installOn(this)
@@ -62,6 +65,9 @@ internal class CodeWhispererCodeScanResultsView(private val project: Project, pr
     }
 
     private fun expandItems() {
+        if (!isGroupedBySeverity()) {
+            return
+        }
         val criticalTreePath = TreePath(arrayOf(codeScanTree.model.root, codeScanTree.model.getChild(codeScanTree.model.root, 0)))
         val highTreePath = TreePath(arrayOf(codeScanTree.model.root, codeScanTree.model.getChild(codeScanTree.model.root, 1)))
         codeScanTree.expandPath(criticalTreePath)
@@ -326,7 +332,7 @@ internal class CodeWhispererCodeScanResultsView(private val project: Project, pr
         return actionManager.createActionToolbar(ACTION_PLACE, group, false)
     }
 
-    private class ColoredTreeCellRenderer : TreeCellRenderer {
+    private inner class ColoredTreeCellRenderer : TreeCellRenderer {
         private fun getSeverityIcon(severity: String): Icon? = when (severity) {
             IssueSeverity.LOW.displayName -> AwsIcons.Resources.CodeWhisperer.SEVERITY_INITIAL_LOW
             IssueSeverity.MEDIUM.displayName -> AwsIcons.Resources.CodeWhisperer.SEVERITY_INITIAL_MEDIUM
@@ -359,15 +365,23 @@ internal class CodeWhispererCodeScanResultsView(private val project: Project, pr
                     }
                     is CodeWhispererCodeScanIssue -> {
                         val cellText = obj.title.trimEnd('.')
-                        val cellDescription = "${obj.file.name} ${obj.displayTextRange()}"
+                        val cellDescription = if (this@CodeWhispererCodeScanResultsView.isGroupedBySeverity()) {
+                            "${obj.file.name} ${obj.displayTextRange()}"
+                        } else {
+                            obj.displayTextRange()
+                        }
                         if (obj.isInvalid) {
                             cell.text = message("codewhisperer.codescan.scan_recommendation_invalid", obj.title, cellDescription, INACTIVE_TEXT_COLOR)
                             cell.toolTipText = message("codewhisperer.codescan.scan_recommendation_invalid.tooltip_text")
                             cell.icon = AllIcons.General.Information
                         } else {
                             cell.text = message("codewhisperer.codescan.scan_recommendation", cellText, cellDescription, INACTIVE_TEXT_COLOR)
                             cell.toolTipText = cellText
-                            cell.icon = obj.issueSeverity.icon
+                            cell.icon = if (this@CodeWhispererCodeScanResultsView.isGroupedBySeverity()) {
+                                obj.issueSeverity.icon
+                            } else {
+                                getSeverityIcon(obj.severity)
+                            }
                         }
                     }
                 }
diff --git a/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/actions/CodeWhispererCodeScanGroupingStrategyActionGroup.kt b/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/actions/CodeWhispererCodeScanGroupingStrategyActionGroup.kt
@@ -0,0 +1,37 @@
+// Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.services.codewhisperer.codescan.actions
+
+import com.intellij.openapi.actionSystem.ActionGroup
+import com.intellij.openapi.actionSystem.ActionUpdateThread
+import com.intellij.openapi.actionSystem.AnAction
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.actionSystem.ex.CheckboxAction
+import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.CodeWhispererCodeScanManager
+import software.aws.toolkits.jetbrains.services.codewhisperer.codescan.utils.IssueGroupingStrategy
+
+class CodeWhispererCodeScanGroupingStrategyActionGroup : ActionGroup() {
+    override fun getChildren(e: AnActionEvent?): Array<out AnAction> = IssueGroupingStrategy.entries.map { GroupByAction(it) }.toTypedArray()
+
+    private class GroupByAction(private val groupingStrategy: IssueGroupingStrategy) : CheckboxAction() {
+        override fun getActionUpdateThread() = ActionUpdateThread.BGT
+
+        override fun isSelected(event: AnActionEvent): Boolean {
+            val project = event.project ?: return false
+            return CodeWhispererCodeScanManager.getInstance(project).getGroupingStrategySelected() == groupingStrategy
+        }
+
+        override fun setSelected(event: AnActionEvent, state: Boolean) {
+            val project = event.project ?: return
+            if (state) {
+                CodeWhispererCodeScanManager.getInstance(project).setGroupingStrategySelected(groupingStrategy)
+            }
+        }
+
+        override fun update(e: AnActionEvent) {
+            super.update(e)
+            e.presentation.text = groupingStrategy.displayName
+        }
+    }
+}
diff --git a/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/utils/CodeWhispererCodeScanIssueUtils.kt b/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/codescan/utils/CodeWhispererCodeScanIssueUtils.kt
@@ -73,6 +73,11 @@ enum class IssueSeverity(val displayName: String) {
     INFO("Info"),
 }
 
+enum class IssueGroupingStrategy(val displayName: String) {
+    SEVERITY("Severity"),
+    FILE_LOCATION("File Location"),
+}
+
 fun getCodeScanIssueDetailsHtml(
     issue: CodeWhispererCodeScanIssue,
     display: CodeScanIssueDetailsDisplayType,
diff --git a/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/telemetry/CodeWhispererUserModificationTracker.kt b/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/telemetry/CodeWhispererUserModificationTracker.kt
@@ -19,6 +19,7 @@ import org.assertj.core.util.VisibleForTesting
 import software.amazon.awssdk.services.codewhispererruntime.model.CodeWhispererRuntimeException
 import software.aws.toolkits.core.utils.debug
 import software.aws.toolkits.core.utils.getLogger
+import software.aws.toolkits.core.utils.warn
 import software.aws.toolkits.jetbrains.core.credentials.ToolkitConnection
 import software.aws.toolkits.jetbrains.services.codewhisperer.credentials.CodeWhispererClientAdaptor
 import software.aws.toolkits.jetbrains.services.codewhisperer.customization.CodeWhispererModelConfigurator
@@ -154,14 +155,28 @@ class CodeWhispererUserModificationTracker(private val project: Project) : Dispo
     private fun emitTelemetryOnSuggestion(acceptedSuggestion: AcceptedSuggestionEntry) {
         val file = acceptedSuggestion.vFile
 
-        if (file == null || (!file.isValid)) {
+        if (file == null || (!file.isValid) || !acceptedSuggestion.range.isValid) {
             sendModificationTelemetry(acceptedSuggestion, null)
             sendUserModificationTelemetryToServiceAPI(acceptedSuggestion)
         } else {
             // Will remove this later when we truly don't need toolkit user modification telemetry anymore
             val document = runReadAction {
                 FileDocumentManager.getInstance().getDocument(file)
             }
+            val start = acceptedSuggestion.range.startOffset
+            val end = acceptedSuggestion.range.endOffset
+            if (document != null) {
+                if (start < 0 || end < start || end > document.textLength) {
+                    LOG.warn {
+                        "Invalid range for suggestion ${acceptedSuggestion.requestId}: " +
+                            "start=$start, end=$end, docLength=${document.textLength}"
+                    }
+                    sendModificationTelemetry(acceptedSuggestion, null)
+                    sendUserModificationTelemetryToServiceAPI(acceptedSuggestion)
+                    return
+                }
+            }
+
             val currentString = document?.getText(
                 TextRange(acceptedSuggestion.range.startOffset, acceptedSuggestion.range.endOffset)
             )
diff --git a/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/util/CodeWhispererZipUploadManager.kt b/plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/util/CodeWhispererZipUploadManager.kt
