feat: created initial core JSON language plugin (#91)

## PR Checklist

- [x] Addresses an existing open issue: fixes #46
- [x] That issue was marked as [`status: accepting
prs`](https://github.com/JoshuaKGoldberg/flint/issues?q=is%3Aopen+is%3Aissue+label%3A%22status%3A+accepting+prs%22)
- [x] Steps in
[CONTRIBUTING.md](https://github.com/JoshuaKGoldberg/flint/blob/main/.github/CONTRIBUTING.md)
were taken

## Overview

Adds an initial JSON language that uses in-memory `ts.parseJsonText`
from TypeScript. It's used for an initial JSON plugin with one rule,
`duplicateKeys`.

❤️‍🔥

Author: JoshuaKGoldberg

flint.config.js

@@ -1,17 +1,18 @@
-import { defineConfig, ts } from "./lib/index.js";
+import { defineConfig, json, ts } from "./lib/index.js";
 
 export default defineConfig({
 	use: [
+		{
+			glob: json.globs.all,
+			rules: [json.presets.logical],
+		},
 		{
 			glob: ts.globs.all,
 			rules: [ts.presets.logical],
 		},
 		// Catch-all globs until we have dedicated plugins...
 		{
 			glob: [
-				// https://github.com/JoshuaKGoldberg/flint/issues/46
-				"**/*.json",
-
 				// https://github.com/JoshuaKGoldberg/flint/issues/47
 				"**/*.md",
 

src/index.ts

@@ -1,4 +1,5 @@
 export { defineConfig } from "./configs/defineConfig.js";
+export { json } from "./json/plugin.js";
 export { createLanguage } from "./languages/createLanguage.js";
 export { createPlugin } from "./plugins/createPlugin.js";
 export { RuleTester } from "./testing/RuleTester.js";

src/json/createJsonFile.ts

@@ -0,0 +1,50 @@
+import * as ts from "typescript";
+
+import { LanguageFileDefinition } from "../types/languages.js";
+import { NormalizedRuleReport, RuleReport } from "../types/reports.js";
+import { normalizeRange } from "../typescript/normalizeRange.js";
+
+// TODO: Eventually, it might make sense to use a native speed JSON parser.
+// The standard TypeScript language will likely use that itself.
+// https://github.com/JoshuaKGoldberg/flint/issues/44
+export function createTypeScriptJsonFile(
+	filePathAbsolute: string,
+	sourceText: string,
+): LanguageFileDefinition {
+	const sourceFile = ts.parseJsonText(filePathAbsolute, sourceText);
+
+	return {
+		runRule(rule, options) {
+			const reports: NormalizedRuleReport[] = [];
+
+			const context = {
+				report: (report: RuleReport) => {
+					reports.push({
+						...report,
+						message: rule.messages[report.message],
+						range: normalizeRange(report.range, sourceFile),
+					});
+				},
+				sourceFile,
+			};
+
+			const visitors = rule.setup(context, options);
+
+			if (!visitors) {
+				return reports;
+			}
+
+			function visit(node: ts.Node) {
+				// @ts-expect-error - TODO: Figure this out later...
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-call
+				visitors[ts.SyntaxKind[node.kind]]?.(node);
+
+				node.forEachChild(visit);
+			}
+
+			sourceFile.forEachChild(visit);
+
+			return reports;
+		},
+	};
+}

src/json/language.ts

@@ -0,0 +1,28 @@
+import fsSync from "node:fs";
+import * as ts from "typescript";
+
+import { createLanguage } from "../languages/createLanguage.js";
+import { createTypeScriptJsonFile } from "./createJsonFile.js";
+
+export interface JsonServices {
+	sourceFile: ts.JsonSourceFile;
+}
+
+export const json = createLanguage<JsonServices>({
+	about: {
+		name: "JSON",
+	},
+	prepare: () => {
+		return {
+			prepareFileOnDisk: (filePathAbsolute) => {
+				return createTypeScriptJsonFile(
+					filePathAbsolute,
+					fsSync.readFileSync(filePathAbsolute, "utf8"),
+				);
+			},
+			prepareFileVirtually: (filePathAbsolute, sourceText) => {
+				return createTypeScriptJsonFile(filePathAbsolute, sourceText);
+			},
+		};
+	},
+});

src/json/plugin.ts

@@ -0,0 +1,10 @@
+import { createPlugin } from "../plugins/createPlugin.js";
+import duplicateKeys from "./rules/duplicateKeys.js";
+
+export const json = createPlugin({
+	globs: {
+		all: ["**/*.json"],
+	},
+	name: "json",
+	rules: [duplicateKeys],
+});

src/json/rules/duplicateKeys.test.ts

@@ -0,0 +1,33 @@
+import { ruleTester } from "../../ruleTester.js";
+import rule from "./duplicateKeys.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+{
+  "a": "first",
+  "a": "second",
+}
+`,
+			snapshot: `
+{
+  "a": "first",
+  ~~~
+  This key is made redundant by an identical key later in the object.
+  "a": "second",
+}
+`,
+		},
+	],
+	valid: [
+		`{}`,
+		`{ "a": "apple" }`,
+		`
+{
+  "a": "first",
+  "b": "second",
+}
+`,
+	],
+});

src/json/rules/duplicateKeys.ts

@@ -0,0 +1,57 @@
+import * as ts from "typescript";
+
+import { json } from "../language.js";
+
+export default json.createRule({
+	about: {
+		id: "duplicateKeys",
+		preset: "logical",
+	},
+	messages: {
+		duplicateKey: {
+			primary:
+				"This key is made redundant by an identical key later in the object.",
+			secondary: [
+				"Although JSON technically allows duplicate keys, using them is at best confusing.",
+				"Most JSON parsers will ignore all but the last value for a given key.",
+				"It's generally best to ensure that each key in a JSON object is unique.",
+			],
+			suggestions: [
+				"If both values are meant to exist, change one of the keys to be different.",
+				"If only the last value is meant to exist, you can remove any prior values.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			ObjectLiteralExpression(node) {
+				const seenKeys = new Map<string, ts.StringLiteral>();
+
+				for (const property of node.properties.toReversed()) {
+					if (
+						!ts.isPropertyAssignment(property) ||
+						!ts.isStringLiteral(property.name)
+					) {
+						continue;
+					}
+
+					const key = property.name.text;
+					const existingNode = seenKeys.get(key);
+
+					if (!existingNode) {
+						seenKeys.set(key, property.name);
+						continue;
+					}
+
+					context.report({
+						message: "duplicateKey",
+						range: {
+							begin: property.name.getStart(context.sourceFile) + 1,
+							end: property.name.end + 1,
+						},
+					});
+				}
+			},
+		};
+	},
+});

src/rules/ruleTester.ts src/ruleTester.tssrc/rules/ruleTester.ts renamed to src/ruleTester.ts

@@ -1,6 +1,6 @@
 import { describe, it } from "vitest";
 
-import { RuleTester } from "../testing/RuleTester.js";
+import { RuleTester } from "./testing/RuleTester.js";
 
 export const ruleTester = new RuleTester({
 	describe,

src/typescript/getNodeRange.ts

@@ -2,9 +2,12 @@ import type * as ts from "typescript";
 
 import { CharacterReportRange } from "../types/ranges.js";
 
-export function getNodeRange(node: ts.Node): CharacterReportRange {
+export function getNodeRange(
+	node: ts.Node,
+	sourceFile: ts.SourceFile,
+): CharacterReportRange {
 	return {
-		begin: node.getStart(),
+		begin: node.getStart(sourceFile),
 		end: node.getEnd(),
 	};
 }

src/typescript/plugin.ts

@@ -1,18 +1,12 @@
 import { createPlugin } from "../plugins/createPlugin.js";
-import consecutiveNonNullAssertions from "../rules/consecutiveNonNullAssertions.js";
-import forInArrays from "../rules/forInArrays.js";
-import namespaceDeclarations from "../rules/namespaceDeclarations.js";
-
-const rules = [
-	forInArrays,
-	consecutiveNonNullAssertions,
-	namespaceDeclarations,
-];
+import consecutiveNonNullAssertions from "./rules/consecutiveNonNullAssertions.js";
+import forInArrays from "./rules/forInArrays.js";
+import namespaceDeclarations from "./rules/namespaceDeclarations.js";
 
 export const ts = createPlugin({
 	globs: {
 		all: ["**/*.{cjs,js,jsx,mjs,ts,tsx}"],
 	},
 	name: "ts",
-	rules,
+	rules: [forInArrays, consecutiveNonNullAssertions, namespaceDeclarations],
 });