Change parser to allow parsing two script tags on <script setup> (#108)

* Change parser to allow parsing two script tags on `<script setup>`

* Add testcase

* Update tests

* update

* fix test

* update

* refactor

* refactor

* Add test case

* remap scope

Author: ota-meshi

package.json

@@ -64,7 +64,7 @@
     "pretest": "run-s build lint",
     "test": "npm run -s test:mocha",
     "test:mocha": "nyc mocha \"test/*.js\" --reporter dot --timeout 10000",
-    "test:debug": "mocha --inspect --require ts-node/register \"test/*.js\" --reporter dot --timeout 10000",
+    "test:debug": "mocha --inspect --require ts-node/register/transpile-only \"test/*.js\" --reporter dot --timeout 10000",
     "preupdate-fixtures": "npm run -s build",
     "update-fixtures": "node scripts/update-fixtures-ast.js && node scripts/update-fixtures-document-fragment.js",
     "preversion": "npm test",

scripts/update-fixtures-ast.js

@@ -12,6 +12,7 @@
 const fs = require("fs")
 const path = require("path")
 const parser = require("../")
+const escope = require("eslint-scope")
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -38,7 +39,7 @@ function replacer(key, value) {
         return undefined
     }
     if (key === "errors" && Array.isArray(value)) {
-        return value.map(e => ({
+        return value.map((e) => ({
             message: e.message,
             index: e.index,
             lineNumber: e.lineNumber,
@@ -95,6 +96,106 @@ function getTree(source, ast) {
     return root.children
 }
 
+function scopeToJSON(scopeManager) {
+    return JSON.stringify(normalizeScope(scopeManager.globalScope), replacer, 4)
+
+    function normalizeScope(scope) {
+        return {
+            type: scope.type,
+            variables: scope.variables.map(normalizeVar),
+            references: scope.references.map(normalizeReference),
+            childScopes: scope.childScopes.map(normalizeScope),
+            through: scope.through.map(normalizeReference),
+        }
+    }
+
+    function normalizeVar(v) {
+        return {
+            name: v.name,
+            identifiers: v.identifiers.map(normalizeId),
+            defs: v.defs.map(normalizeDef),
+            references: v.references.map(normalizeReference),
+        }
+    }
+
+    function normalizeReference(reference) {
+        return {
+            identifier: normalizeId(reference.identifier),
+            from: reference.from.type,
+            resolved: normalizeId(
+                reference.resolved &&
+                    reference.resolved.defs &&
+                    reference.resolved.defs[0] &&
+                    reference.resolved.defs[0].name
+            ),
+            init: reference.init || null,
+        }
+    }
+
+    function normalizeDef(def) {
+        return {
+            type: def.type,
+            node: normalizeDefNode(def.node),
+            name: def.name.name,
+        }
+    }
+
+    function normalizeId(identifier) {
+        return (
+            identifier && {
+                type: identifier.type,
+                name: identifier.name,
+                loc: identifier.loc,
+            }
+        )
+    }
+
+    function normalizeDefNode(node) {
+        return {
+            type: node.type,
+            loc: node.loc,
+        }
+    }
+}
+
+/**
+ * Analyze scope
+ */
+function analyze(ast, parserOptions) {
+    const ecmaVersion = parserOptions.ecmaVersion || 2017
+    const ecmaFeatures = parserOptions.ecmaFeatures || {}
+    const sourceType = parserOptions.sourceType || "script"
+    const result = escope.analyze(ast, {
+        ignoreEval: true,
+        nodejsScope: false,
+        impliedStrict: ecmaFeatures.impliedStrict,
+        ecmaVersion,
+        sourceType,
+        fallback: getFallbackKeys,
+    })
+
+    return result
+
+    function getFallbackKeys(node) {
+        return Object.keys(node).filter(fallbackKeysFilter, node)
+    }
+
+    function fallbackKeysFilter(key) {
+        const value = null
+        return (
+            key !== "comments" &&
+            key !== "leadingComments" &&
+            key !== "loc" &&
+            key !== "parent" &&
+            key !== "range" &&
+            key !== "tokens" &&
+            key !== "trailingComments" &&
+            typeof value === "object" &&
+            (typeof value.type === "string" || Array.isArray(value))
+        )
+    }
+}
+
 //------------------------------------------------------------------------------
 // Main
 //------------------------------------------------------------------------------
@@ -105,25 +206,30 @@ for (const name of TARGETS) {
     const astPath = path.join(ROOT, `${name}/ast.json`)
     const tokenRangesPath = path.join(ROOT, `${name}/token-ranges.json`)
     const treePath = path.join(ROOT, `${name}/tree.json`)
+    const scopePath = path.join(ROOT, `${name}/scope.json`)
     const source = fs.readFileSync(sourcePath, "utf8")
-    const actual = parser.parse(
-        source,
-        Object.assign(
-            { filePath: sourcePath },
-            PARSER_OPTIONS,
-            fs.existsSync(optionsPath)
-                ? JSON.parse(fs.readFileSync(optionsPath, "utf8"))
-                : {}
-        )
+    const options = Object.assign(
+        { filePath: sourcePath },
+        PARSER_OPTIONS,
+        fs.existsSync(optionsPath)
+            ? JSON.parse(fs.readFileSync(optionsPath, "utf8"))
+            : {}
     )
-    const tokenRanges = getAllTokens(actual).map(t =>
+    const actual = parser.parseForESLint(source, options)
+    const tokenRanges = getAllTokens(actual.ast).map((t) =>
         source.slice(t.range[0], t.range[1])
     )
-    const tree = getTree(source, actual)
+    const tree = getTree(source, actual.ast)
 
     console.log("Update:", name)
 
-    fs.writeFileSync(astPath, JSON.stringify(actual, replacer, 4))
+    fs.writeFileSync(astPath, JSON.stringify(actual.ast, replacer, 4))
     fs.writeFileSync(tokenRangesPath, JSON.stringify(tokenRanges, replacer, 4))
     fs.writeFileSync(treePath, JSON.stringify(tree, replacer, 4))
+    if (fs.existsSync(scopePath)) {
+        fs.writeFileSync(
+            scopePath,
+            scopeToJSON(actual.scopeManager || analyze(actual.ast, options))
+        )
+    }
 }