fix: use last args to avoid improper suggestions

Author: Hweinstock

packages/amazonq/src/app/inline/recommendationService.ts

@@ -22,7 +22,7 @@ export class RecommendationService {
         private readonly inlineGeneratingMessage: InlineGeneratingMessage
     ) {}
 
-    getAllRecommendations = debounce(this._getAllRecommendations.bind(this), inlineCompletionsDebounceDelay)
+    getAllRecommendations = debounce(this._getAllRecommendations.bind(this), inlineCompletionsDebounceDelay, true)
 
     private async _getAllRecommendations(
         languageClient: LanguageClient,

packages/amazonq/test/unit/amazonq/apps/inline/recommendationService.test.ts

@@ -214,6 +214,47 @@ describe('RecommendationService', () => {
 
                 await promise2
             })
+
+            it('makes request with the last call', async () => {
+                const mockResult = {
+                    sessionId: 'test-session',
+                    items: [mockInlineCompletionItemOne],
+                    partialResultToken: undefined,
+                }
+
+                sendRequestStub.resolves(mockResult)
+
+                const promise1 = service.getAllRecommendations(
+                    languageClient,
+                    mockDocument,
+                    mockPosition,
+                    mockContext,
+                    mockToken
+                )
+
+                const promise2 = service.getAllRecommendations(
+                    languageClient,
+                    mockDocument,
+                    { line: 2, character: 2 } as Position,
+                    mockContext,
+                    mockToken
+                )
+
+                await clock.tickAsync(inlineCompletionsDebounceDelay + 1000)
+
+                await promise1
+                await promise2
+
+                const expectedRequestArgs = {
+                    textDocument: {
+                        uri: 'file:///test.py',
+                    },
+                    position: { line: 2, character: 2 } as Position,
+                    context: mockContext,
+                }
+                const firstCallArgs = sendRequestStub.firstCall.args[1]
+                assert.deepStrictEqual(firstCallArgs, expectedRequestArgs)
+            })
         })
     })
 })

packages/core/src/shared/utilities/functionUtils.ts

@@ -93,9 +93,10 @@ export function memoize<T, U extends any[]>(fn: (...args: U) => T): (...args: U)
  */
 export function debounce<Input extends any[], Output>(
     cb: (...args: Input) => Output | Promise<Output>,
-    delay: number = 0
+    delay: number = 0,
+    useLastCall: boolean = false
 ): (...args: Input) => Promise<Output> {
-    return cancellableDebounce(cb, delay).promise
+    return cancellableDebounce(cb, delay, useLastCall).promise
 }
 
 /**
@@ -104,10 +105,12 @@ export function debounce<Input extends any[], Output>(
  */
 export function cancellableDebounce<Input extends any[], Output>(
     cb: (...args: Input) => Output | Promise<Output>,
-    delay: number = 0
+    delay: number = 0,
+    useLastCall: boolean = false
 ): { promise: (...args: Input) => Promise<Output>; cancel: () => void } {
     let timeout: Timeout | undefined
     let promise: Promise<Output> | undefined
+    let lastestArgs: Input | undefined
 
     const cancel = (): void => {
         if (timeout) {
@@ -119,14 +122,16 @@ export function cancellableDebounce<Input extends any[], Output>(
 
     return {
         promise: (...args: Input) => {
+            lastestArgs = args
             timeout?.refresh()
 
             return (promise ??= new Promise<Output>((resolve, reject) => {
                 timeout = new Timeout(delay)
                 timeout.onCompletion(async () => {
                     timeout = promise = undefined
                     try {
-                        resolve(await cb(...args))
+                        const argsToUse = useLastCall ? lastestArgs! : args
+                        resolve(await cb(...argsToUse))
                     } catch (err) {
                         reject(err)
                     }

packages/core/src/test/shared/utilities/functionUtils.test.ts

@@ -152,6 +152,32 @@ describe('debounce', function () {
         assert.strictEqual(counter, 2)
     })
 
+    describe('useLastCall option', function () {
+        let args: number[]
+        let clock: ReturnType<typeof installFakeClock>
+        let addToArgs: (i: number) => void
+
+        before(function () {
+            args = []
+            clock = installFakeClock()
+            addToArgs = args.push
+        })
+
+        afterEach(function () {
+            clock.uninstall()
+            args.length = 0
+        })
+
+        it('only calls with the last args', async function () {
+            const debounced = debounce((i: number) => args.push(i), 10, true)
+            debounced(1)
+            debounced(2)
+            debounced(3)
+            await clock.tickAsync(100)
+            assert.deepStrictEqual(args, [3])
+        })
+    })
+
     describe('window rolling', function () {
         let clock: ReturnType<typeof installFakeClock>
         const calls: ReturnType<typeof fn>[] = []