test: add test cases for runes

Author: ota-meshi

README.md

@@ -169,6 +169,56 @@ module.exports = {
 }
 ```
 
+### parserOptions.runes
+
+***This is an experimental feature. It may be changed or removed in minor versions without notice.***
+
+If set to `true`, Rune symbols will be parsed. In this mode, the parser also parses files other than `*.svelte`.
+
+```json
+{
+    "parser": "svelte-eslint-parser",
+    "parserOptions": {
+        "runes": true
+    }
+}
+```
+
+When using this mode in an ESLint configuration, it is recommended to set it per file pattern as below.
+
+```json
+{
+    "overrides": [
+        {
+            "files": ["*.svelte"],
+            "parser": "svelte-eslint-parser",
+            "parserOptions": {
+                "runes": true,
+                "parser": "...",
+                ...
+            }
+        },
+        {
+            "files": ["*.svelte.js"],
+            "parser": "svelte-eslint-parser",
+            "parserOptions": {
+                "runes": true,
+                ...
+            }
+        },
+        {
+            "files": ["*.svelte.ts"],
+            "parser": "svelte-eslint-parser",
+            "parserOptions": {
+                "runes": true,
+                "parser": "...(ts parser)...",
+                ...
+            }
+        }
+    ]
+}
+```
+
 ## :computer: Editor Integrations
 
 ### Visual Studio Code

src/parser/index.ts

@@ -10,7 +10,7 @@ import type {
 import type { Program } from "estree";
 import type { ScopeManager } from "eslint-scope";
 import { Variable } from "eslint-scope";
-import { parseScript } from "./script";
+import { parseScript, parseScriptInSvelte } from "./script";
 import type * as SvAST from "./svelte-ast-types";
 import { sortNodes } from "./sort";
 import { parseTemplate } from "./template";
@@ -59,39 +59,48 @@ export interface ESLintExtendedProgram {
   // The code used to parse the script.
   _virtualScriptCode?: string;
 }
-/**
- * Parse source code
- */
-export function parseForESLint(
-  code: string,
-  options?: any,
-): {
+type ParseResult = {
   ast: SvelteProgram;
-  services: Record<string, any> & {
-    isSvelte: true;
-    getSvelteHtmlAst: () => SvAST.Fragment;
-    getStyleContext: () => StyleContext;
-  };
+  services: Record<string, any> &
+    (
+      | {
+          isSvelte: true;
+          svelteRunes: boolean;
+          getSvelteHtmlAst: () => SvAST.Fragment;
+          getStyleContext: () => StyleContext;
+        }
+      | { isSvelte: false; svelteRunes: boolean }
+    );
   visitorKeys: { [type: string]: string[] };
   scopeManager: ScopeManager;
-} {
-  const parserOptions = {
-    ecmaVersion: 2020,
-    sourceType: "module",
-    loc: true,
-    range: true,
-    raw: true,
-    tokens: true,
-    comment: true,
-    eslintVisitorKeys: true,
-    eslintScopeManager: true,
-    ...(options || {}),
-  };
-  parserOptions.sourceType = "module";
-  if (parserOptions.ecmaVersion <= 5 || parserOptions.ecmaVersion == null) {
-    parserOptions.ecmaVersion = 2015;
+};
+/**
+ * Parse source code
+ */
+export function parseForESLint(code: string, options?: any): ParseResult {
+  const parserOptions = normalizeParserOptions(options);
+
+  if (
+    parserOptions.filePath &&
+    !parserOptions.filePath.endsWith(".svelte") &&
+    parserOptions.runes
+  ) {
+    const trimmed = code.trim();
+    if (!trimmed.startsWith("<") && !trimmed.endsWith(">")) {
+      return parseAsScript(code, parserOptions);
+    }
   }
 
+  return parseAsSvelte(code, parserOptions);
+}
+
+/**
+ * Parse source code as svelte component
+ */
+function parseAsSvelte(
+  code: string,
+  parserOptions: NormalizedParserOptions,
+): ParseResult {
   const ctx = new Context(code, parserOptions);
   const resultTemplate = parseTemplate(
     ctx.sourceCode.template,
@@ -107,7 +116,7 @@ export function parseForESLint(
         parserOptions,
         { slots: ctx.slots },
       )
-    : parseScript(
+    : parseScriptInSvelte(
         scripts.getCurrentVirtualCode(),
         scripts.attrs,
         parserOptions,
@@ -212,6 +221,61 @@ export function parseForESLint(
   return resultScript as any;
 }
 
+/**
+ * Parse source code as script
+ */
+function parseAsScript(
+  code: string,
+  parserOptions: NormalizedParserOptions,
+): ParseResult {
+  const lang = parserOptions.filePath?.split(".").pop() || "js";
+  // TODO support runes
+  const resultScript = parseScript(code, { lang }, parserOptions);
+  resultScript.services = Object.assign(resultScript.services || {}, {
+    isSvelte: false,
+    runes: parserOptions.runes,
+  });
+  resultScript.visitorKeys = Object.assign({}, KEYS, resultScript.visitorKeys);
+  return resultScript as any;
+}
+
+type NormalizedParserOptions = {
+  ecmaVersion: number | "latest";
+  sourceType: "module" | "script";
+  loc: boolean;
+  range: boolean;
+  raw: boolean;
+  tokens: boolean;
+  comment: boolean;
+  eslintVisitorKeys: boolean;
+  eslintScopeManager: boolean;
+  runes: boolean;
+  filePath?: string;
+};
+
+/** Normalize parserOptions */
+function normalizeParserOptions(options: any): NormalizedParserOptions {
+  const parserOptions = {
+    ecmaVersion: 2020,
+    sourceType: "module",
+    loc: true,
+    range: true,
+    raw: true,
+    tokens: true,
+    comment: true,
+    eslintVisitorKeys: true,
+    eslintScopeManager: true,
+    rune: false,
+    ...(options || {}),
+  };
+  parserOptions.sourceType = "module";
+  if (parserOptions.ecmaVersion <= 5 || parserOptions.ecmaVersion == null) {
+    parserOptions.ecmaVersion = 2015;
+  }
+
+  return parserOptions;
+}
+
 /** Extract tokens */
 function extractTokens(ctx: Context) {
   const useRanges = sortNodes([...ctx.tokens, ...ctx.comments]).map(

src/parser/script.ts

@@ -5,23 +5,14 @@ import { getParser } from "./resolve-parser";
 import { isEnhancedParserObject } from "./parser-object";
 
 /**
- * Parse for script
+ * Parse for <script>
  */
-export function parseScript(
+export function parseScriptInSvelte(
   code: string,
   attrs: Record<string, string | undefined>,
   parserOptions: any = {},
 ): ESLintExtendedProgram {
-  const result = parseScriptWithoutAnalyzeScopeFromVCode(
-    code,
-    attrs,
-    parserOptions,
-  );
-
-  if (!result.scopeManager) {
-    const scopeManager = analyzeScope(result.ast, parserOptions);
-    result.scopeManager = scopeManager;
-  }
+  const result = parseScript(code, attrs, parserOptions);
 
   traverseNodes(result.ast, {
     visitorKeys: result.visitorKeys,
@@ -42,6 +33,27 @@ export function parseScript(
 
   return result;
 }
+/**
+ * Parse for script
+ */
+export function parseScript(
+  code: string,
+  attrs: Record<string, string | undefined>,
+  parserOptions: any = {},
+): ESLintExtendedProgram {
+  const result = parseScriptWithoutAnalyzeScopeFromVCode(
+    code,
+    attrs,
+    parserOptions,
+  );
+
+  if (!result.scopeManager) {
+    const scopeManager = analyzeScope(result.ast, parserOptions);
+    result.scopeManager = scopeManager;
+  }
+
+  return result;
+}
 
 /**
  * Parse for script without analyze scope

src/parser/typescript/index.ts

@@ -1,5 +1,5 @@
 import type { ESLintExtendedProgram } from "..";
-import { parseScript } from "../script";
+import { parseScriptInSvelte } from "../script";
 import type { AnalyzeTypeScriptContext } from "./analyze";
 import { analyzeTypeScript } from "./analyze";
 import type { TSESParseForESLintResult } from "./types";
@@ -15,7 +15,7 @@ export function parseTypeScript(
 ): ESLintExtendedProgram {
   const tsCtx = analyzeTypeScript(code, attrs, parserOptions, context);
 
-  const result = parseScript(tsCtx.script, attrs, parserOptions);
+  const result = parseScriptInSvelte(tsCtx.script, attrs, parserOptions);
 
   tsCtx.restoreContext.restore(result as unknown as TSESParseForESLintResult);
 

tests/fixtures/parser/ast/svelte-5-preview/docs/fine-grained-reactivity/_config.json

@@ -0,0 +1,3 @@
+{
+    "runes": true
+}

tests/fixtures/parser/ast/svelte-5-preview/docs/fine-grained-reactivity/example01-input.svelte

@@ -0,0 +1,24 @@
+<script>
+	let todos = $state([]);
+
+	function remaining(todos) {
+		console.log('recalculating');
+		return todos.filter(todo => !todo.done).length;
+	}
+
+	function addTodo(event) {
+		if (event.key !== 'Enter') return;
+
+		let done = $state(false);
+		let text = $state(event.target.value);
+
+		todos = [...todos, {
+			get done() { return done },
+			set done(value) { done = value },
+			get text() { return text },
+			set text(value) { text = value }
+		}];
+
+		event.target.value = '';
+	}
+</script>

tests/fixtures/parser/ast/svelte-5-preview/docs/fine-grained-reactivity/example01-no-undef-result.json

@@ -0,0 +1,20 @@
+[
+  {
+    "ruleId": "no-undef",
+    "code": "$state",
+    "line": 2,
+    "column": 14
+  },
+  {
+    "ruleId": "no-undef",
+    "code": "$state",
+    "line": 12,
+    "column": 14
+  },
+  {
+    "ruleId": "no-undef",
+    "code": "$state",
+    "line": 13,
+    "column": 14
+  }
+]

tests/fixtures/parser/ast/svelte-5-preview/docs/fine-grained-reactivity/example01-no-unused-vars-result.json

@@ -0,0 +1,14 @@
+[
+  {
+    "ruleId": "no-unused-vars",
+    "code": "remaining",
+    "line": 4,
+    "column": 11
+  },
+  {
+    "ruleId": "no-unused-vars",
+    "code": "addTodo",
+    "line": 9,
+    "column": 11
+  }
+]