Merge branch 'main' into fix-53391

Author: jakebailey

.eslintrc.json

@@ -97,7 +97,7 @@
             "allowDeclarations": true
         }],
         "local/no-double-space": "error",
-        "local/boolean-trivia": "error",
+        "local/argument-trivia": "error",
         "local/no-in-operator": "error",
         "local/simple-indent": "error",
         "local/debug-assert": "error",

.github/pr_owners.txt

@@ -12,3 +12,4 @@ gabritto
 jakebailey
 DanielRosenwasser
 navya9singh
+iisaduan

.github/workflows/ci.yml

@@ -20,7 +20,7 @@ jobs:
     strategy:
       matrix:
         node-version:
-          - "19"
+          - "20"
           - "18"
           - "16"
           - "14"

.github/workflows/new-release-branch.yaml

@@ -37,7 +37,7 @@ jobs:
         git add src/compiler/corePublic.ts
         git add tests/baselines/reference/api/typescript.d.ts
         git add tests/baselines/reference/api/tsserverlibrary.d.ts
-        git add ./lib
+        git add --force ./lib
         git config user.email "typescriptbot@microsoft.com"
         git config user.name "TypeScript Bot"
         git commit -m 'Bump version to ${{ github.event.client_payload.package_version }} and LKG'

.github/workflows/set-version.yaml

@@ -43,7 +43,7 @@ jobs:
         git add src/compiler/corePublic.ts
         git add tests/baselines/reference/api/typescript.d.ts
         git add tests/baselines/reference/api/tsserverlibrary.d.ts
-        git add ./lib
+        git add --force ./lib
         git config user.email "typescriptbot@microsoft.com"
         git config user.name "TypeScript Bot"
         git commit -m 'Bump version to ${{ github.event.client_payload.package_version }} and LKG'

.github/workflows/update-lkg.yml

@@ -25,6 +25,6 @@ jobs:
         npx hereby LKG
         npm test
         git diff
-        git add ./lib
+        git add --force ./lib
         git commit -m "Update LKG"
         git push

Herebyfile.mjs

@@ -171,7 +171,7 @@ function createBundler(entrypoint, outfile, taskOptions = {}) {
             bundle: true,
             outfile,
             platform: "node",
-            target: "es2018",
+            target: ["es2020", "node14.17"],
             format: "cjs",
             sourcemap: "linked",
             sourcesContent: false,
@@ -616,7 +616,6 @@ export const runTestsAndWatch = task({
         });
 
         process.on("SIGINT", endWatchMode);
-        process.on("SIGKILL", endWatchMode);
         process.on("beforeExit", endWatchMode);
         watchTestsEmitter.on("rebuild", onRebuild);
         testCaseWatcher.on("all", onChange);

package-lock.json

@@ -26,7 +26,7 @@
         "tsserver": "./bin/tsserver"
     },
     "engines": {
-        "node": ">=12.20"
+        "node": ">=14.17"
     },
     "files": [
         "bin",
@@ -54,7 +54,7 @@
         "@typescript-eslint/eslint-plugin": "^5.33.1",
         "@typescript-eslint/parser": "^5.33.1",
         "@typescript-eslint/utils": "^5.33.1",
-        "azure-devops-node-api": "^11.2.0",
+        "azure-devops-node-api": "^12.0.0",
         "chai": "^4.3.7",
         "chalk": "^4.1.2",
         "chokidar": "^3.5.3",
@@ -83,7 +83,9 @@
         "which": "^2.0.2"
     },
     "overrides": {
-        "typescript@*": "$typescript"
+        "typescript@*": "$typescript",
+        "@octokit/types": "9.0.0",
+        "@octokit/openapi-types": "16.0.0"
     },
     "scripts": {
         "test": "hereby runtests-parallel --light=false",

package.json

@@ -0,0 +1,203 @@
+const { AST_NODE_TYPES, TSESTree, ESLintUtils } = require("@typescript-eslint/utils");
+const { createRule } = require("./utils.cjs");
+const ts = require("typescript");
+
+const unset = Symbol();
+/**
+ * @template T
+ * @param {() => T} fn
+ * @returns {() => T}
+ */
+function memoize(fn) {
+    /** @type {T | unset} */
+    let value = unset;
+    return () => {
+        if (value === unset) {
+            value = fn();
+        }
+        return value;
+    };
+}
+
+
+module.exports = createRule({
+    name: "argument-trivia",
+    meta: {
+        docs: {
+            description: ``,
+            recommended: "error",
+        },
+        messages: {
+            argumentTriviaArgumentError: `Tag argument with parameter name`,
+            argumentTriviaArgumentSpaceError: `There should be 1 space between an argument and its comment`,
+            argumentTriviaArgumentNameError: `Argument name "{{ got }}" does not match expected name "{{ want }}"`,
+        },
+        schema: [],
+        type: "problem",
+        fixable: "code",
+    },
+    defaultOptions: [],
+
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        const sourceCodeText = sourceCode.getText();
+
+        /** @type {(name: string) => boolean} */
+        const isSetOrAssert = (name) => name.startsWith("set") || name.startsWith("assert");
+        /** @type {(node: TSESTree.Node) => boolean} */
+        const isTrivia = (node) => {
+            if (node.type === AST_NODE_TYPES.Identifier) {
+                return node.name === "undefined";
+            }
+
+            if (node.type === AST_NODE_TYPES.Literal) {
+                // eslint-disable-next-line no-null/no-null
+                return node.value === null || node.value === true || node.value === false;
+            }
+
+            return false;
+        };
+
+        /** @type {(node: TSESTree.CallExpression | TSESTree.NewExpression) => boolean} */
+        const shouldIgnoreCalledExpression = (node) => {
+            if (node.callee && node.callee.type === AST_NODE_TYPES.MemberExpression) {
+                const methodName = node.callee.property.type === AST_NODE_TYPES.Identifier
+                    ? node.callee.property.name
+                    : "";
+
+                if (isSetOrAssert(methodName)) {
+                    return true;
+                }
+
+                switch (methodName) {
+                    case "apply":
+                    case "call":
+                    case "equal":
+                    case "stringify":
+                    case "push":
+                        return true;
+                }
+
+                return false;
+            }
+
+            if (node.callee && node.callee.type === AST_NODE_TYPES.Identifier) {
+                const functionName = node.callee.name;
+
+                if (isSetOrAssert(functionName)) {
+                    return true;
+                }
+
+                switch (functionName) {
+                    case "contains":
+                        return true;
+                }
+
+                return false;
+            }
+
+            return false;
+        };
+
+
+        /** @type {(node: TSESTree.Node, i: number, getSignature: () => ts.Signature | undefined) => void} */
+        const checkArg = (node, i, getSignature) => {
+            if (!isTrivia(node)) {
+                return;
+            }
+
+            const getExpectedName = memoize(() => {
+                const signature = getSignature();
+                if (signature) {
+                    const expectedName = signature.parameters[i]?.escapedName;
+                    if (expectedName) {
+                        const name = ts.unescapeLeadingUnderscores(expectedName);
+                        // If a parameter is unused, we prepend an underscore. Ignore this
+                        // so that we can switch between used and unused without modifying code,
+                        // requiring that arugments are tagged with the non-underscored name.
+                        return name.startsWith("_") ? name.slice(1) : name;
+                    }
+                }
+                return undefined;
+            });
+
+            const comments = sourceCode.getCommentsBefore(node);
+            /** @type {TSESTree.Comment | undefined} */
+            const comment = comments[comments.length - 1];
+
+            if (!comment || comment.type !== "Block") {
+                const expectedName = getExpectedName();
+                if (expectedName) {
+                    context.report({
+                        messageId: "argumentTriviaArgumentError",
+                        node,
+                        fix: (fixer) => {
+                            return fixer.insertTextBefore(node, `/*${expectedName}*/ `);
+                        }
+                    });
+                }
+                else {
+                    context.report({ messageId: "argumentTriviaArgumentError", node });
+                }
+                return;
+            }
+
+            const argRangeStart = node.range[0];
+            const commentRangeEnd = comment.range[1];
+            const expectedName = getExpectedName();
+            if (expectedName) {
+                const got = comment.value;
+                if (got !== expectedName) {
+                    context.report({
+                        messageId: "argumentTriviaArgumentNameError",
+                        data: { got, want: expectedName },
+                        node: comment,
+                        fix: (fixer) => {
+                            return fixer.replaceText(comment, `/*${expectedName}*/`);
+                        },
+                    });
+                    return;
+                }
+            }
+
+            const hasNewLine = sourceCodeText.slice(commentRangeEnd, argRangeStart).indexOf("\n") >= 0;
+            if (argRangeStart !== commentRangeEnd + 1 && !hasNewLine) {
+                // TODO(jakebailey): range should be whitespace
+                context.report({
+                    messageId: "argumentTriviaArgumentSpaceError",
+                    node,
+                    fix: (fixer) => {
+                        return fixer.replaceTextRange([commentRangeEnd, argRangeStart], " ");
+                    }
+                });
+            }
+        };
+
+        /** @type {(node: TSESTree.CallExpression | TSESTree.NewExpression) => void} */
+        const checkArgumentTrivia = (node) => {
+            if (shouldIgnoreCalledExpression(node)) {
+                return;
+            }
+
+            const getSignature = memoize(() => {
+                if (context.parserServices?.hasFullTypeInformation) {
+                    const parserServices = ESLintUtils.getParserServices(context);
+                    const checker = parserServices.program.getTypeChecker();
+                    const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+                    return checker.getResolvedSignature(tsNode);
+                }
+                return undefined;
+            });
+
+            for (let i = 0; i < node.arguments.length; i++) {
+                const arg = node.arguments[i];
+                checkArg(arg, i, getSignature);
+            }
+        };
+
+        return {
+            CallExpression: checkArgumentTrivia,
+            NewExpression: checkArgumentTrivia,
+        };
+    },
+});