Change template parsing method (#29)

* Add scope testcases

* update

* Change template parsing method

Author: ota-meshi

src/ast.ts

@@ -71,6 +71,7 @@ export type SvelteNode =
     | SvelteShorthandAttribute
     | SvelteSpreadAttribute
     | SvelteDirective
+    | SvelteSpecialDirective
     | SvelteHTMLComment
     | SvelteReactiveStatement
 

src/context/index.ts

@@ -1,16 +1,54 @@
 import type { Comment, Locations, Position, Token } from "../ast"
 import lodash from "lodash"
 import type ESTree from "estree"
-import type { ScopeManager } from "eslint-scope"
-import { TemplateScopeManager } from "./template-scope-manager"
+import { ScriptLetContext } from "./script-let"
+import { LetDirectiveCollections } from "./let-directive-collection"
 
-type ContextSourceCode = {
-    template: string
-    scripts: {
-        code: string
-        attrs: Record<string, string | undefined>
+export class ScriptsSourceCode {
+    private readonly raw
+
+    public readonly attrs: Record<string, string | undefined>
+
+    private _vcode: string | null = null
+
+    public separateSemiIndex: number
+
+    public constructor(
+        script: string,
+        attrs: Record<string, string | undefined>,
+    ) {
+        this.raw = script
+        this.attrs = attrs
+        this.separateSemiIndex = script.length
+    }
+
+    public get vcode(): string {
+        if (this._vcode == null) {
+            return this.raw
+        }
+        return this._vcode
+    }
+
+    public addLet(letCode: string): { start: number; end: number } {
+        if (this._vcode == null) {
+            this._vcode = this.raw.trimEnd()
+            this.separateSemiIndex = this._vcode.length
+            this._vcode += ";"
+            const after = this.raw.slice(this._vcode.length)
+            this._vcode += after
+        }
+        const start = this._vcode.length
+        this._vcode += letCode
+        return {
+            start,
+            end: this._vcode.length,
+        }
     }
 }
+export type ContextSourceCode = {
+    template: string
+    scripts: ScriptsSourceCode
+}
 export class Context {
     public readonly code: string
 
@@ -26,7 +64,9 @@ export class Context {
 
     private readonly locsMap = new Map<number, Position>()
 
-    private _templateScopeManager: TemplateScopeManager | null = null
+    public readonly scriptLet: ScriptLetContext
+
+    public readonly letDirCollections = new LetDirectiveCollections()
 
     public constructor(code: string, parserOptions: any) {
         this.code = code
@@ -50,17 +90,15 @@ export class Context {
             }
             start = block.codeRange[1]
         }
-        const before = code.slice(start)
-        templateCode += before
-        scriptCode += before.replace(/[^\n\r ]/g, " ")
+        const after = code.slice(start)
+        templateCode += after
+        scriptCode += after.replace(/[^\n\r ]/g, " ")
 
         this.sourceCode = {
             template: templateCode,
-            scripts: {
-                code: scriptCode,
-                attrs: scriptAttrs,
-            },
+            scripts: new ScriptsSourceCode(scriptCode, scriptAttrs),
         }
+        this.scriptLet = new ScriptLetContext(this)
     }
 
     public getLocFromIndex(index: number): { line: number; column: number } {
@@ -119,14 +157,6 @@ export class Context {
     public getText(range: { start: number; end: number }): string {
         return this.code.slice(range.start, range.end)
     }
-
-    public readyScopeManager(scopeManager: ScopeManager): void {
-        this._templateScopeManager = new TemplateScopeManager(scopeManager)
-    }
-
-    public get templateScopeManager(): TemplateScopeManager {
-        return this._templateScopeManager!
-    }
 }
 
 /** Extract <script> blocks */

src/context/let-directive-collection.ts

@@ -0,0 +1,62 @@
+import type { SvelteLetDirective } from "../ast"
+import type * as ESTree from "estree"
+import type { ScriptLetCallback, ScriptLetCallbackOption } from "./script-let"
+
+/** A class that collects pattern nodes for Let directives. */
+export class LetDirectiveCollection {
+    private readonly list: {
+        pattern: ESTree.Pattern
+        directive: SvelteLetDirective
+        callbacks: ScriptLetCallback<ESTree.Pattern>[]
+    }[] = []
+
+    public isEmpty(): boolean {
+        return this.list.length === 0
+    }
+
+    public getLetParams(): ESTree.Pattern[] {
+        return this.list.map((d) => d.pattern)
+    }
+
+    public getCallback(): (
+        nodes: ESTree.Pattern[],
+        options: ScriptLetCallbackOption,
+    ) => void {
+        return (nodes, options) => {
+            for (let index = 0; index < nodes.length; index++) {
+                const node = nodes[index]
+                for (const callback of this.list[index].callbacks) {
+                    callback(node, options)
+                }
+            }
+        }
+    }
+
+    public addPattern(
+        pattern: ESTree.Pattern,
+        directive: SvelteLetDirective,
+        ...callbacks: ScriptLetCallback<ESTree.Pattern>[]
+    ): ScriptLetCallback<ESTree.Pattern>[] {
+        this.list.push({
+            pattern,
+            directive,
+            callbacks,
+        })
+        return callbacks
+    }
+}
+export class LetDirectiveCollections {
+    private readonly stack: LetDirectiveCollection[] = []
+
+    public beginExtract(): void {
+        this.stack.push(new LetDirectiveCollection())
+    }
+
+    public getCollection(): LetDirectiveCollection {
+        return this.stack[this.stack.length - 1]
+    }
+
+    public extract(): LetDirectiveCollection {
+        return this.stack.pop()!
+    }
+}