Fix error when {#await} with literal (#125)

Author: ota-meshi

src/context/script-let.ts

@@ -337,7 +337,7 @@ export class ScriptLetContext {
             | string[]
             | ((helper: TypeGenHelper) => {
                   typings: string[]
-                  preparationScript?: string
+                  preparationScript?: string[]
               }),
     ): void
 
@@ -353,7 +353,7 @@ export class ScriptLetContext {
             | string[]
             | ((helper: TypeGenHelper) => {
                   typings: string[]
-                  preparationScript?: string
+                  preparationScript?: string[]
               }),
     ): void {
         let arrayTypings: string[] = []
@@ -366,14 +366,16 @@ export class ScriptLetContext {
                 })
                 arrayTypings = generatedTypes.typings
                 if (generatedTypes.preparationScript) {
-                    this.appendScriptWithoutOffset(
-                        generatedTypes.preparationScript,
-                        (node, tokens, comments, result) => {
-                            tokens.length = 0
-                            comments.length = 0
-                            removeAllReference(node, result)
-                        },
-                    )
+                    for (const preparationScript of generatedTypes.preparationScript) {
+                        this.appendScriptWithoutOffset(
+                            preparationScript,
+                            (node, tokens, comments, result) => {
+                                tokens.length = 0
+                                comments.length = 0
+                                removeAllScope(node, result)
+                            },
+                        )
+                    }
                 }
             }
         }
@@ -445,7 +447,7 @@ export class ScriptLetContext {
                                 column: typeAnnotation.loc.start.column,
                             }
 
-                            removeAllReference(typeAnnotation, result)
+                            removeAllScope(typeAnnotation, result)
                         }
                     }
 
@@ -869,23 +871,55 @@ function applyLocs(target: Locations | ESTree.Node, locs: Locations) {
 }
 
 /** Remove all reference */
-function removeAllReference(
-    target: ESTree.Node,
-    result: ScriptLetCallbackOption,
-) {
+function removeAllScope(target: ESTree.Node, result: ScriptLetCallbackOption) {
+    const targetScopes = new Set<Scope>()
     traverseNodes(target, {
         visitorKeys: result.visitorKeys,
         enterNode(node) {
+            const scope = result.scopeManager.acquire(node)
+            if (scope) {
+                targetScopes.add(scope)
+                return
+            }
             if (node.type === "Identifier") {
-                const scope = result.getScope(node)
+                let scope = result.getScope(node)
+                if (
+                    (scope.block as any).type === "TSTypeAliasDeclaration" &&
+                    (scope.block as any).id === node
+                ) {
+                    scope = scope.upper!
+                }
+                if (targetScopes.has(scope)) {
+                    return
+                }
 
+                removeIdentifierVariable(node, scope)
                 removeIdentifierReference(node, scope)
             }
         },
         leaveNode() {
             // noop
         },
     })
+
+    for (const scope of targetScopes) {
+        removeScope(result.scopeManager, scope)
+    }
+}
+
+/** Remove variable */
+function removeIdentifierVariable(node: ESTree.Identifier, scope: Scope): void {
+    const varIndex = scope.variables.findIndex((v) =>
+        v.defs.some((def) => def.name === node),
+    )
+    if (varIndex >= 0) {
+        const variable = scope.variables[varIndex]
+        scope.variables.splice(varIndex, 1)
+        const name = node.name
+        if (variable === scope.set.get(name)) {
+            scope.set.delete(name)
+        }
+    }
 }
 
 /** Remove reference */

src/parser/converts/block.ts

@@ -293,22 +293,29 @@ export function convertAwaitBlock(
                 },
                 ({ generateUniqueId }) => {
                     const expression = ctx.getText(node.expression)
-                    if (
-                        node.expression.type === "Identifier" ||
-                        node.expression.type === "Literal"
-                    ) {
+                    if (node.expression.type === "Literal") {
                         return {
+                            typings: [expression],
+                        }
+                    }
+                    const idAwaitThenValue = generateUniqueId("AwaitThenValue")
+                    if (node.expression.type === "Identifier") {
+                        return {
+                            preparationScript: [
+                                generateAwaitThenValueType(idAwaitThenValue),
+                            ],
                             typings: [
-                                `Parameters<Parameters<(typeof ${expression})["then"]>[0]>[0]`,
+                                `${idAwaitThenValue}<(typeof ${expression})>`,
                             ],
                         }
                     }
                     const id = generateUniqueId(expression)
                     return {
-                        preparationScript: `const ${id} = ${expression};`,
-                        typings: [
-                            `Parameters<Parameters<(typeof ${id})["then"]>[0]>[0]`,
+                        preparationScript: [
+                            `const ${id} = ${expression};`,
+                            generateAwaitThenValueType(idAwaitThenValue),
                         ],
+                        typings: [`${idAwaitThenValue}<(typeof ${id})>`],
                     }
                 },
             )
@@ -465,3 +472,14 @@ function extractMustacheBlockTokens(
         end: endSectionNameEnd,
     })
 }
+
+/** Generate Awaited like type code */
+function generateAwaitThenValueType(id: string) {
+    return `type ${id}<T> = T extends null | undefined
+    ? T
+    : T extends { then(value: infer F): any }
+    ? F extends (value: infer V, ...args: any) => any
+        ? ${id}<V>
+        : never
+        : T;`
+}

tests/fixtures/parser/ast/ts-await-non-promise01-input.svelte

@@ -0,0 +1,15 @@
+<script lang="ts">
+	const str = 'abc' as const
+</script>
+
+{#await 1234 then number}
+	<p>The number is {number}</p>
+{/await}
+
+{#await str then s}
+	<p>The string is {s}</p>
+{/await}
+
+{#await str.slice(0) then s}
+	<p>The string is {s}</p>
+{/await}