@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/negativeZeroComparisons.js

@@ -1,65 +1,48 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-import { isComparisonOperator, isEqualityOperator, isNegatedEqualityOperator, } from "./utils/operators.js";
+import { ruleCreator } from "./ruleCreator.js";
+import { isComparisonOperator, isEqualityOperator, isNegatedEqualityOperator } from "./utils/operators.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/negativeZeroComparisons.ts
 function isNegativeZero(node) {
-    return (ts.isPrefixUnaryExpression(node) &&
-        node.operator === ts.SyntaxKind.MinusToken &&
-        ts.isNumericLiteral(node.operand) &&
-        node.operand.text === "0");
+	return node.kind === SyntaxKind.PrefixUnaryExpression && node.operator === SyntaxKind.MinusToken && node.operand.kind === SyntaxKind.NumericLiteral && node.operand.text === "0";
 }
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports comparisons with -0 that may not behave as expected.",
-        id: "negativeZeroComparisons",
-        preset: "logical",
-    },
-    messages: {
-        unexpectedNegativeZeroComparison: {
-            primary: "Comparisons with -0 using {{ operator }} do not distinguish between -0 and +0.",
-            secondary: [
-                "In JavaScript, -0 and +0 are considered equal when using comparison operators like === or ==, even though they are distinct values.",
-                "To properly check for -0, use `Object.is(value, -0)` which correctly distinguishes between -0 and +0.",
-            ],
-            suggestions: ["Use `Object.is()` to reliably check if a value is -0."],
-        },
-    },
-    setup(context) {
-        function generateObjectIsText(node, isNegated) {
-            const leftText = node.left.getText(context.sourceFile);
-            const rightText = node.right.getText(context.sourceFile);
-            const objectIsCall = `Object.is(${leftText}, ${rightText})`;
-            return isNegated ? `!${objectIsCall}` : objectIsCall;
-        }
-        return {
-            visitors: {
-                BinaryExpression: (node) => {
-                    if (!isComparisonOperator(node.operatorToken) ||
-                        (!isNegativeZero(node.left) && !isNegativeZero(node.right))) {
-                        return;
-                    }
-                    const operator = node.operatorToken.getText(context.sourceFile);
-                    const range = {
-                        begin: node.getStart(context.sourceFile),
-                        end: node.getEnd(),
-                    };
-                    context.report({
-                        data: {
-                            operator,
-                        },
-                        message: "unexpectedNegativeZeroComparison",
-                        range,
-                        suggestions: isEqualityOperator(node.operatorToken)
-                            ? [
-                                {
-                                    id: "useObjectIs",
-                                    range,
-                                    text: generateObjectIsText(node, isNegatedEqualityOperator(node.operatorToken)),
-                                },
-                            ]
-                            : undefined,
-                    });
-                },
-            },
-        };
-    },
+var negativeZeroComparisons_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports comparisons with -0 that may not behave as expected.",
+		id: "negativeZeroComparisons",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { unexpectedNegativeZeroComparison: {
+		primary: "Comparisons with -0 using {{ operator }} do not distinguish between -0 and +0.",
+		secondary: ["In JavaScript, -0 and +0 are considered equal when using comparison operators like === or ==, even though they are distinct values.", "To properly check for -0, use `Object.is(value, -0)` which correctly distinguishes between -0 and +0."],
+		suggestions: ["Use `Object.is()` to reliably check if a value is -0."]
+	} },
+	setup(context) {
+		function generateObjectIsText(node, isNegated, sourceFile) {
+			const objectIsCall = `Object.is(${node.left.getText(sourceFile)}, ${node.right.getText(sourceFile)})`;
+			return isNegated ? `!${objectIsCall}` : objectIsCall;
+		}
+		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
+			if (!isComparisonOperator(node.operatorToken) || !isNegativeZero(node.left) && !isNegativeZero(node.right)) return;
+			const operator = node.operatorToken.getText(sourceFile);
+			const range = {
+				begin: node.getStart(sourceFile),
+				end: node.getEnd()
+			};
+			context.report({
+				data: { operator },
+				message: "unexpectedNegativeZeroComparison",
+				range,
+				suggestions: isEqualityOperator(node.operatorToken) ? [{
+					id: "useObjectIs",
+					range,
+					text: generateObjectIsText(node, isNegatedEqualityOperator(node.operatorToken), sourceFile)
+				}] : void 0
+			});
+		} } };
+	}
 });
+//#endregion
+export { negativeZeroComparisons_default as default };
+
+//# sourceMappingURL=negativeZeroComparisons.js.map

package/lib/rules/nestedStandaloneIfs.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports `if` statements that are the only statement inside an `else` block or inside another `if` without an `else`.";
+    readonly id: "nestedStandaloneIfs";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "lonelyIfInElse" | "lonelyIfInIf", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=nestedStandaloneIfs.d.ts.map

package/lib/rules/nestedStandaloneIfs.js

@@ -0,0 +1,105 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/nestedStandaloneIfs.ts
+function hasCommentsInRange(sourceFile, start, end) {
+	const text = sourceFile.text.slice(start, end);
+	return text.includes("//") || text.includes("/*");
+}
+function isIfWithoutElse(node) {
+	return ts.isIfStatement(node) && node.elseStatement === void 0;
+}
+const lowerPrecedenceThanLogicalAnd = new Set([
+	SyntaxKind.BinaryExpression,
+	SyntaxKind.ConditionalExpression,
+	SyntaxKind.YieldExpression
+]);
+function needsParentheses(node) {
+	if (node.kind !== SyntaxKind.BinaryExpression) return lowerPrecedenceThanLogicalAnd.has(node.kind);
+	const operator = node.operatorToken.kind;
+	return operator === SyntaxKind.BarBarToken || operator === SyntaxKind.QuestionQuestionToken || operator === SyntaxKind.CommaToken || operator === SyntaxKind.EqualsToken || operator === SyntaxKind.PlusEqualsToken || operator === SyntaxKind.MinusEqualsToken || operator === SyntaxKind.AsteriskEqualsToken || operator === SyntaxKind.SlashEqualsToken || operator === SyntaxKind.PercentEqualsToken || operator === SyntaxKind.AsteriskAsteriskEqualsToken || operator === SyntaxKind.LessThanLessThanEqualsToken || operator === SyntaxKind.GreaterThanGreaterThanEqualsToken || operator === SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken || operator === SyntaxKind.AmpersandEqualsToken || operator === SyntaxKind.BarEqualsToken || operator === SyntaxKind.CaretEqualsToken || operator === SyntaxKind.BarBarEqualsToken || operator === SyntaxKind.AmpersandAmpersandEqualsToken || operator === SyntaxKind.QuestionQuestionEqualsToken;
+}
+function wrapWithParenthesesIfNeeded(expression, sourceFile) {
+	const text = expression.getText(sourceFile);
+	return needsParentheses(expression) ? `(${text})` : text;
+}
+var nestedStandaloneIfs_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports `if` statements that are the only statement inside an `else` block or inside another `if` without an `else`.",
+		id: "nestedStandaloneIfs",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: {
+		lonelyIfInElse: {
+			primary: "This `if` is the only statement in an `else` block and can be written as `else if`.",
+			secondary: ["An `if` statement that is the only statement inside an `else` block can be collapsed into `else if`, which reduces nesting and improves readability."],
+			suggestions: ["Convert to `else if` to flatten the structure."]
+		},
+		lonelyIfInIf: {
+			primary: "This `if` is the only statement inside another `if` without an `else` and can be combined using `&&`.",
+			secondary: ["When an `if` statement is the only statement inside another `if` that has no `else`, the conditions can be combined with `&&` for simpler code."],
+			suggestions: ["Combine the conditions with `&&`."]
+		}
+	},
+	setup(context) {
+		function checkSoleBlockChild(node, sourceFile) {
+			if (node.parent.parent.kind === SyntaxKind.IfStatement && node.parent.parent.elseStatement === node.parent) {
+				const grandparent = node.parent.parent;
+				const openBrace = node.parent.getStart(sourceFile);
+				const closeBrace = node.parent.getEnd();
+				if (hasCommentsInRange(sourceFile, openBrace + 1, node.getStart(sourceFile))) return;
+				if (hasCommentsInRange(sourceFile, node.getEnd(), closeBrace - 1)) return;
+				if (!grandparent.getChildren(sourceFile).find((child) => child.kind === SyntaxKind.ElseKeyword)) return;
+				const nodeText = node.getText(sourceFile);
+				context.report({
+					fix: {
+						range: {
+							begin: node.parent.getStart(sourceFile),
+							end: node.parent.getEnd()
+						},
+						text: nodeText
+					},
+					message: "lonelyIfInElse",
+					range: getTSNodeRange(node, sourceFile)
+				});
+				return;
+			}
+			if (!isIfWithoutElse(node)) return;
+			if (isIfWithoutElse(node.parent.parent) && node.parent.parent.thenStatement === node.parent) {
+				const outerIf = node.parent.parent;
+				const openBrace = node.parent.getStart(sourceFile);
+				const closeBrace = node.parent.getEnd();
+				if (hasCommentsInRange(sourceFile, openBrace + 1, node.getStart(sourceFile)) || hasCommentsInRange(sourceFile, node.getEnd(), closeBrace - 1)) return;
+				const fixedText = `if (${wrapWithParenthesesIfNeeded(outerIf.expression, sourceFile)} && ${wrapWithParenthesesIfNeeded(node.expression, sourceFile)}) ${node.thenStatement.getText(sourceFile)}`;
+				context.report({
+					fix: {
+						range: getTSNodeRange(outerIf, sourceFile),
+						text: fixedText
+					},
+					message: "lonelyIfInIf",
+					range: getTSNodeRange(node, sourceFile)
+				});
+				return;
+			}
+		}
+		function checkChildOfIfWithoutElse(node, parent, sourceFile) {
+			const fixedText = `if (${wrapWithParenthesesIfNeeded(parent.expression, sourceFile)} && ${wrapWithParenthesesIfNeeded(node.expression, sourceFile)}) ${node.thenStatement.getText(sourceFile)}`;
+			context.report({
+				fix: {
+					range: getTSNodeRange(parent, sourceFile),
+					text: fixedText
+				},
+				message: "lonelyIfInIf",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		}
+		return { visitors: { IfStatement: (node, { sourceFile }) => {
+			if (node.parent.kind === SyntaxKind.Block && node.parent.statements.length === 1) checkSoleBlockChild(node, sourceFile);
+			else if (isIfWithoutElse(node.parent) && node.parent.thenStatement === node) checkChildOfIfWithoutElse(node, node.parent, sourceFile);
+		} } };
+	}
+});
+//#endregion
+export { nestedStandaloneIfs_default as default };
+
+//# sourceMappingURL=nestedStandaloneIfs.js.map

package/lib/rules/newDefinitions.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports misleading constructor and `new` definitions in interfaces and classes.";
+    readonly id: "newDefinitions";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "classMethodNamedNew" | "interfaceConstructSignature" | "interfaceMethodNamedConstructor", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=newDefinitions.d.ts.map

package/lib/rules/newDefinitions.js

@@ -0,0 +1,84 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/newDefinitions.ts
+function getParentClassName(node) {
+	switch (node.parent.kind) {
+		case ts.SyntaxKind.ClassDeclaration:
+		case ts.SyntaxKind.ClassExpression: return node.parent.name?.text;
+		case ts.SyntaxKind.SourceFile: return;
+		default: return getParentClassName(node.parent);
+	}
+}
+function getParentInterface(node) {
+	switch (node.parent.kind) {
+		case ts.SyntaxKind.InterfaceDeclaration: return node.parent;
+		case ts.SyntaxKind.SourceFile: return;
+		default: return getParentInterface(node.parent);
+	}
+}
+function getTypeReferenceName(node) {
+	return node?.kind === ts.SyntaxKind.TypeReference && node.typeName.kind === ts.SyntaxKind.Identifier ? node.typeName.text : void 0;
+}
+var newDefinitions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports misleading constructor and `new` definitions in interfaces and classes.",
+		id: "newDefinitions",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		classMethodNamedNew: {
+			primary: "A class method named `new` that returns the class type is misleading.",
+			secondary: ["This looks like a constructor definition, but classes use `constructor` instead of `new`.", "A method named `new` suggests instantiation, which is confusing in a class context."],
+			suggestions: ["Rename the method if it's not meant to be a constructor.", "Use `constructor` to define the class constructor."]
+		},
+		interfaceConstructSignature: {
+			primary: "An interface cannot be constructed directly; only classes can be instantiated.",
+			secondary: [
+				"A `new()` signature in an interface that returns the interface type is misleading.",
+				"If you want to define a class, use `class` instead of `interface`.",
+				"If you want to define a constructor function type, the return type should differ from the interface name."
+			],
+			suggestions: ["Use a class declaration instead of an interface.", "Change the return type if this describes a constructor function."]
+		},
+		interfaceMethodNamedConstructor: {
+			primary: "Interfaces define `new()` signatures, not `constructor` methods.",
+			secondary: ["A method named `constructor` in an interface is misleading because interfaces cannot be instantiated.", "The `constructor` keyword is used in classes, not interfaces."],
+			suggestions: ["Use `new()` to define a construct signature in the interface.", "Convert this to a class if you need a constructor."]
+		}
+	},
+	setup(context) {
+		return { visitors: {
+			ConstructSignature: (node, { sourceFile }) => {
+				const parentInterface = getParentInterface(node);
+				if (!parentInterface?.name) return;
+				if (getTypeReferenceName(node.type) !== parentInterface.name.text) return;
+				context.report({
+					message: "interfaceConstructSignature",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			},
+			MethodDeclaration: (node, { sourceFile }) => {
+				if (node.body || node.parent.kind !== ts.SyntaxKind.ClassDeclaration && node.parent.kind !== ts.SyntaxKind.ClassExpression || node.name.kind !== ts.SyntaxKind.Identifier || node.name.text !== "new") return;
+				const parentName = getParentClassName(node);
+				if (!parentName) return;
+				if (getTypeReferenceName(node.type) !== parentName) return;
+				context.report({
+					message: "classMethodNamedNew",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			},
+			MethodSignature: (node, { sourceFile }) => {
+				if (node.name.kind !== ts.SyntaxKind.Identifier || node.name.text !== "constructor") return;
+				context.report({
+					message: "interfaceMethodNamedConstructor",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { newDefinitions_default as default };
+
+//# sourceMappingURL=newDefinitions.js.map

package/lib/rules/newExpressions.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports standalone new expressions that don't use the constructed object.";
     readonly id: "newExpressions";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noStandaloneNew", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noStandaloneNew", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=newExpressions.d.ts.map

package/lib/rules/newExpressions.js

@@ -1,54 +1,38 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports standalone new expressions that don't use the constructed object.",
-        id: "newExpressions",
-        preset: "logical",
-    },
-    messages: {
-        noStandaloneNew: {
-            primary: "Constructors should only be called when their return value is used.",
-            secondary: [
-                "Using `new` to construct an object but not storing or using the result is often a mistake or indicates unclear code intent.",
-                "If the constructor has side effects you want to trigger, it's better to make that explicit by calling a separate method rather than relying on constructor side effects.",
-            ],
-            suggestions: [
-                "If you need to use the constructed object, assign it to a variable or return it.",
-                "If you only need the constructor's side effects, consider refactoring to a function that makes the side effects explicit.",
-            ],
-        },
-    },
-    setup(context) {
-        function isStandaloneExpression(node) {
-            const parent = node.parent;
-            // If parent is an ExpressionStatement, it's standalone
-            if (parent.kind === ts.SyntaxKind.ExpressionStatement) {
-                return true;
-            }
-            // If parent is a comma expression, check recursively
-            if (ts.isBinaryExpression(parent) &&
-                parent.operatorToken.kind === ts.SyntaxKind.CommaToken) {
-                // If this is the last expression in the comma sequence, check if the parent is standalone
-                if (parent.right === node) {
-                    return isStandaloneExpression(parent);
-                }
-                return true;
-            }
-            return false;
-        }
-        return {
-            visitors: {
-                NewExpression: (node) => {
-                    if (isStandaloneExpression(node)) {
-                        context.report({
-                            message: "noStandaloneNew",
-                            range: getTSNodeRange(node.getChildAt(0, context.sourceFile), context.sourceFile),
-                        });
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/newExpressions.ts
+var newExpressions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports standalone new expressions that don't use the constructed object.",
+		id: "newExpressions",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { noStandaloneNew: {
+		primary: "Constructors should only be called when their return value is used.",
+		secondary: ["Using `new` to construct an object but not storing or using the result is often a mistake or indicates unclear code intent.", "If the constructor has side effects you want to trigger, it's better to make that explicit by calling a separate method rather than relying on constructor side effects."],
+		suggestions: ["If you need to use the constructed object, assign it to a variable or return it.", "If you only need the constructor's side effects, consider refactoring to a function that makes the side effects explicit."]
+	} },
+	setup(context) {
+		function isStandaloneExpression(node) {
+			switch (node.parent.kind) {
+				case SyntaxKind.BinaryExpression:
+					if (node.parent.operatorToken.kind !== SyntaxKind.CommaToken) return false;
+					if (node.parent.right === node) return isStandaloneExpression(node.parent);
+					return true;
+				case SyntaxKind.ExpressionStatement: return true;
+				default: return false;
+			}
+		}
+		return { visitors: { NewExpression: (node, { sourceFile }) => {
+			if (isStandaloneExpression(node)) context.report({
+				message: "noStandaloneNew",
+				range: getTSNodeRange(node.getChildAt(0, sourceFile), sourceFile)
+			});
+		} } };
+	}
 });
+//#endregion
+export { newExpressions_default as default };
+
+//# sourceMappingURL=newExpressions.js.map

package/lib/rules/newNativeNonConstructors.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Disallows using `new` with global non-constructor functions like Symbol and BigInt.";
     readonly id: "newNativeNonConstructors";
-    readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noNewNonConstructor", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noNewNonConstructor", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=newNativeNonConstructors.d.ts.map

package/lib/rules/newNativeNonConstructors.js

@@ -1,49 +1,39 @@
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-import { isGlobalDeclaration } from "../utils/isGlobalDeclaration.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Disallows using `new` with global non-constructor functions like Symbol and BigInt.",
-        id: "newNativeNonConstructors",
-        preset: "untyped",
-    },
-    messages: {
-        noNewNonConstructor: {
-            primary: "{{ name }} cannot be called with `new`.",
-            secondary: [
-                "`Symbol` and `BigInt` are not constructors and will throw a `TypeError` when called with `new`.",
-                "These functions should be called directly without the `new` keyword to create their respective values.",
-            ],
-            suggestions: ["Remove the `new` keyword and call the function directly."],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                NewExpression: (node) => {
-                    if (!ts.isIdentifier(node.expression)) {
-                        return;
-                    }
-                    const name = node.expression.text;
-                    if (!["BigInt", "Symbol"].includes(name) ||
-                        !isGlobalDeclaration(node.expression, context.typeChecker)) {
-                        return;
-                    }
-                    context.report({
-                        data: { name },
-                        fix: {
-                            range: {
-                                begin: node.getStart(context.sourceFile),
-                                end: node.expression.getStart(context.sourceFile),
-                            },
-                            text: "",
-                        },
-                        message: "noNewNonConstructor",
-                        range: getTSNodeRange(node.getChildAt(0, context.sourceFile), context.sourceFile),
-                    });
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclaration, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/newNativeNonConstructors.ts
+var newNativeNonConstructors_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Disallows using `new` with global non-constructor functions like Symbol and BigInt.",
+		id: "newNativeNonConstructors",
+		presets: ["javascript"]
+	},
+	messages: { noNewNonConstructor: {
+		primary: "{{ name }} cannot be called with `new`.",
+		secondary: ["`Symbol` and `BigInt` are not constructors and will throw a `TypeError` when called with `new`.", "These functions should be called directly without the `new` keyword to create their respective values."],
+		suggestions: ["Remove the `new` keyword and call the function directly."]
+	} },
+	setup(context) {
+		return { visitors: { NewExpression: (node, { sourceFile, typeChecker }) => {
+			if (node.expression.kind !== SyntaxKind.Identifier) return;
+			const name = node.expression.text;
+			if (!["BigInt", "Symbol"].includes(name) || !isGlobalDeclaration(node.expression, typeChecker)) return;
+			context.report({
+				data: { name },
+				fix: {
+					range: {
+						begin: node.getStart(sourceFile),
+						end: node.expression.getStart(sourceFile)
+					},
+					text: ""
+				},
+				message: "noNewNonConstructor",
+				range: getTSNodeRange(node.getChildAt(0, sourceFile), sourceFile)
+			});
+		} } };
+	}
 });
+//#endregion
+export { newNativeNonConstructors_default as default };
+
+//# sourceMappingURL=newNativeNonConstructors.js.map

package/lib/rules/nonNullAssertedNullishCoalesces.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports non-null assertions on the left side of nullish coalescing operators.";
+    readonly id: "nonNullAssertedNullishCoalesces";
+    readonly presets: ["logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryNonNullAssertion", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=nonNullAssertedNullishCoalesces.d.ts.map

package/lib/rules/nonNullAssertedNullishCoalesces.js

@@ -0,0 +1,63 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/nonNullAssertedNullishCoalesces.ts
+function hasNoAssignmentBeforeNode(identifier, node, sourceFile, typeChecker) {
+	const symbol = typeChecker.getSymbolAtLocation(identifier);
+	if (!symbol) return false;
+	const declarations = symbol.getDeclarations();
+	if (!declarations?.length) return false;
+	const nodeEnd = node.getEnd();
+	for (const declaration of declarations) {
+		if (declaration.getEnd() >= nodeEnd) continue;
+		if (ts$1.isVariableDeclaration(declaration)) {
+			if (declaration.exclamationToken || declaration.initializer) return false;
+		} else if (ts$1.isParameter(declaration) && declaration.initializer) return false;
+	}
+	const valueDeclaration = symbol.valueDeclaration;
+	if (!valueDeclaration) return true;
+	function findModifyingReference(current) {
+		if (ts$1.isIdentifier(current)) {
+			if (typeChecker.getSymbolAtLocation(current)?.valueDeclaration === valueDeclaration) {
+				const parent = current.parent;
+				if (ts$1.isBinaryExpression(parent) && tsutils.isAssignmentKind(parent.operatorToken.kind) && parent.left === current && parent.getEnd() < nodeEnd) return true;
+				if ((ts$1.isPostfixUnaryExpression(parent) || ts$1.isPrefixUnaryExpression(parent)) && parent.operand === current && parent.getEnd() < nodeEnd) return true;
+			}
+		}
+		return ts$1.forEachChild(current, findModifyingReference) ?? false;
+	}
+	return !findModifyingReference(sourceFile);
+}
+var nonNullAssertedNullishCoalesces_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports non-null assertions on the left side of nullish coalescing operators.",
+		id: "nonNullAssertedNullishCoalesces",
+		presets: ["logicalStrict"]
+	},
+	messages: { unnecessaryNonNullAssertion: {
+		primary: "The nullish coalescing operator handles null and undefined, making this non-null assertion redundant.",
+		secondary: ["The `??` operator returns its right operand when the left operand is null or undefined.", "Applying `!` to assert the value is non-null defeats the purpose of using `??`."],
+		suggestions: ["Remove the non-null assertion."]
+	} },
+	setup(context) {
+		return { visitors: { NonNullExpression: (node, { sourceFile, typeChecker }) => {
+			if (node.parent.kind !== ts$1.SyntaxKind.BinaryExpression || node.parent.operatorToken.kind !== ts$1.SyntaxKind.QuestionQuestionToken || node.parent.left !== node) return;
+			if (node.expression.kind === ts$1.SyntaxKind.Identifier && hasNoAssignmentBeforeNode(node.expression, node, sourceFile, typeChecker)) return;
+			const range = getTSNodeRange(node, sourceFile);
+			context.report({
+				message: "unnecessaryNonNullAssertion",
+				range,
+				suggestions: [{
+					id: "removeNonNullAssertion",
+					range,
+					text: node.expression.getText(sourceFile)
+				}]
+			});
+		} } };
+	}
+});
+//#endregion
+export { nonNullAssertedNullishCoalesces_default as default };
+
+//# sourceMappingURL=nonNullAssertedNullishCoalesces.js.map

package/lib/rules/nonNullAssertedOptionalChains.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports non-null assertions on optional chain expressions.";
+    readonly id: "nonNullAssertedOptionalChains";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "nonNullOptionalChain", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=nonNullAssertedOptionalChains.d.ts.map