Fix JSON.stringify return type (#18879), reduce usage of any in JSON.parse

CONTRIBUTING.md

@@ -144,6 +144,8 @@ gulp
 
 The files in `lib/` are used to bootstrap compilation and usually **should not** be updated unless publishing a new version or updating the LKG.
 
+NOTE: Although LKG isn't updated on every change, CI will still verify that changes work if LKG is regenerated. So, you may want to run `gulp lkg` and `gulp local` as part of testing to uncover potential bugs.
+
 ### Modifying generated library files
 
 The files `src/lib/dom.generated.d.ts` and `src/lib/webworker.generated.d.ts` both represent type declarations for the DOM and are auto-generated. To make any modifications to them, you will have to direct changes to https://github.com/Microsoft/TSJS-lib-generator

src/harness/fourslashImpl.ts

@@ -1341,7 +1341,7 @@ namespace FourSlash {
             }));
         }
 
-        public verifyQuickInfoAt(markerName: string | Range, expectedText: string, expectedDocumentation?: string, expectedTags?: {name: string; text: string;}[]) {
+        public verifyQuickInfoAt(markerName: string | Range, expectedText: string, expectedDocumentation?: string, expectedTags?: { name: string; text: string; }[]) {
             if (typeof markerName === "string") this.goToMarker(markerName);
             else this.goToRangeStart(markerName);
 
@@ -2622,7 +2622,7 @@ namespace FourSlash {
             Harness.IO.log(this.spanInfoToString(this.getNameOrDottedNameSpan(pos)!, "**"));
         }
 
-        private classificationToIdentifier(classification: number){
+        private classificationToIdentifier(classification: number) {
 
             const tokenTypes: string[] = [];
             tokenTypes[ts.classifier.v2020.TokenType.class] = "class";
@@ -2664,7 +2664,7 @@ namespace FourSlash {
             return [tokenTypes[typeIdx], ...tokenModifiers.filter((_, i) => modSet & 1 << i)].join(".");
         }
 
-        private verifyClassifications(expected: { classificationType: string | number, text?: string; textSpan?: TextSpan }[], actual: (ts.ClassifiedSpan | ts.ClassifiedSpan2020)[] , sourceFileText: string) {
+        private verifyClassifications(expected: { classificationType: string | number, text?: string; textSpan?: TextSpan }[], actual: (ts.ClassifiedSpan | ts.ClassifiedSpan2020)[], sourceFileText: string) {
             if (actual.length !== expected.length) {
                 this.raiseError("verifyClassifications failed - expected total classifications to be " + expected.length +
                     ", but was " + actual.length +
@@ -2673,7 +2673,7 @@ namespace FourSlash {
 
             ts.zipWith(expected, actual, (expectedClassification, actualClassification) => {
                 const expectedType = expectedClassification.classificationType;
-                const actualType = typeof actualClassification.classificationType === "number"  ? this.classificationToIdentifier(actualClassification.classificationType) : actualClassification.classificationType;
+                const actualType = typeof actualClassification.classificationType === "number" ? this.classificationToIdentifier(actualClassification.classificationType) : actualClassification.classificationType;
 
                 if (expectedType !== actualType) {
                     this.raiseError("verifyClassifications failed - expected classifications type to be " +
@@ -2732,7 +2732,7 @@ namespace FourSlash {
         public replaceWithSemanticClassifications(format: ts.SemanticClassificationFormat.TwentyTwenty) {
             const actual = this.languageService.getSemanticClassifications(this.activeFile.fileName,
                 ts.createTextSpan(0, this.activeFile.content.length), format);
-            const replacement = [`const c2 = classification("2020");`,`verify.semanticClassificationsAre("2020",`];
+            const replacement = [`const c2 = classification("2020");`, `verify.semanticClassificationsAre("2020",`];
             for (const a of actual) {
                 const identifier = this.classificationToIdentifier(a.classificationType as number);
                 const text = this.activeFile.content.slice(a.textSpan.start, a.textSpan.start + a.textSpan.length);
@@ -2786,7 +2786,7 @@ namespace FourSlash {
 
             const reverseSpans = allSpanInsets.sort((l, r) => r.pos - l.pos);
             ts.forEach(reverseSpans, span => {
-               annotated = annotated.slice(0, span.pos) + span.text + annotated.slice(span.pos);
+                annotated = annotated.slice(0, span.pos) + span.text + annotated.slice(span.pos);
             });
             Harness.IO.log(`\nMockup:\n${annotated}`);
         }
@@ -3088,9 +3088,9 @@ namespace FourSlash {
 
                 // Undo changes to perform next fix
                 const span = change.textChanges[0].span;
-                 const deletedText = originalContent.substr(span.start, change.textChanges[0].span.length);
-                 const insertedText = change.textChanges[0].newText;
-                 this.editScriptAndUpdateMarkers(fileName, span.start, span.start + insertedText.length, deletedText);
+                const deletedText = originalContent.substr(span.start, change.textChanges[0].span.length);
+                const insertedText = change.textChanges[0].newText;
+                this.editScriptAndUpdateMarkers(fileName, span.start, span.start + insertedText.length, deletedText);
             }
             if (expectedTextArray.length !== actualTextArray.length) {
                 this.raiseError(`Expected ${expectedTextArray.length} import fixes, got ${actualTextArray.length}:\n\n${actualTextArray.join("\n\n" + "-".repeat(20) + "\n\n")}`);
@@ -4504,8 +4504,8 @@ namespace FourSlash {
         };
     }
 
-    function stringify(data: any, replacer?: (key: string, value: any) => any): string {
-        return JSON.stringify(data, replacer, 2);
+    function stringify(data: unknown, replacer?: (key: string, value: unknown) => unknown): string {
+        return JSON.stringify(data, replacer, 2) ?? "undefined";
     }
 
     /** Collects an array of unique outputs. */
@@ -4575,13 +4575,13 @@ namespace FourSlash {
                 if (doesAddToIndex) {
                     closestIndex.length = closestIndex.length + 1;
                 }
+                else {
+                    ranges.push({ start: index - 1, length: 1 });
+                }
+            }
             else {
                 ranges.push({ start: index - 1, length: 1 });
             }
-          }
-          else {
-                ranges.push({ start: index - 1, length: 1 });
-          }
         };
 
         for (let index = 0; index < Math.max(source.length, target.length); index++) {
@@ -4591,10 +4591,10 @@ namespace FourSlash {
         }
 
         return ranges;
-      }
+    }
 
-      // Adds an _ when the source string and the target string have a whitespace difference
-      function highlightDifferenceBetweenStrings(source: string, target: string) {
+    // Adds an _ when the source string and the target string have a whitespace difference
+    function highlightDifferenceBetweenStrings(source: string, target: string) {
         const ranges = rangesOfDiffBetweenTwoStrings(source, target);
         let emTarget = target;
         ranges.forEach((range, index) => {
@@ -4606,9 +4606,9 @@ namespace FourSlash {
                 range.start + 1 + additionalOffset,
                 range.start + range.length + 1 + additionalOffset
             );
-             const after = emTarget.slice(range.start + range.length + 1 + additionalOffset, emTarget.length);
+            const after = emTarget.slice(range.start + range.length + 1 + additionalOffset, emTarget.length);
             emTarget = before + lhs + between + rhs + after;
         });
         return emTarget;
-      }
+    }
 }

src/harness/harnessUtils.ts

@@ -148,7 +148,7 @@ namespace Utils {
         }
     }
 
-    function isNodeOrArray(a: any): boolean {
+    function isNodeOrArray(a: any): a is ts.Node {
         return a !== undefined && typeof a.pos === "number";
     }
 

src/lib/es5.d.ts

@@ -204,7 +204,7 @@ interface ObjectConstructor {
      * Prevents the modification of existing property attributes and values, and prevents the addition of new properties.
      * @param o Object on which to lock the attributes.
      */
-    freeze<T extends {[idx: string]: U | null | undefined | object}, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>;
+    freeze<T extends { [idx: string]: U | null | undefined | object }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>;
 
     /**
      * Prevents the modification of existing property attributes and values, and prevents the addition of new properties.
@@ -1111,21 +1111,35 @@ interface JSON {
      * @param reviver A function that transforms the results. This function is called for each member of the object.
      * If a member contains nested objects, the nested objects are transformed before the parent object is.
      */
-    parse(text: string, reviver?: (this: any, key: string, value: any) => any): any;
+    parse(text: string, reviver?: (this: unknown, key: string, value: unknown) => unknown): any;
     /**
-     * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
-     * @param value A JavaScript value, usually an object or array, to be converted.
+     * Converts a JSON-representable value to a JavaScript Object Notation (JSON) string.
+     * @param value A JSON-representable value, usually an object or array, to be converted.
      * @param replacer A function that transforms the results.
      * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
      */
-    stringify(value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+    stringify(value: boolean | number | string | object, replacer?: (this: unknown, key: string, value: unknown) => unknown, space?: string | number): string;
     /**
-     * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
-     * @param value A JavaScript value, usually an object or array, to be converted.
+     * Converts a JSON-representable value to a JavaScript Object Notation (JSON) string.
+     * @param value A JSON-representable value, usually an object or array, to be converted.
      * @param replacer An array of strings and numbers that acts as an approved list for selecting the object properties that will be stringified.
      * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
      */
-    stringify(value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+    stringify(value: boolean | number | string | object, replacer?: (number | string)[] | null, space?: string | number): string;
+    /**
+     * Converts a JavaScript value to a JavaScript Object Notation (JSON) string or undefined.
+     * @param value A JavaScript value to be converted, which could potentially be a non-JSON-representable value.
+     * @param replacer A function that transforms the results.
+     * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+     */
+    stringify(value: unknown, replacer?: (this: unknown, key: string, value: unknown) => unknown, space?: string | number): string | undefined;
+    /**
+     * Converts a JavaScript value to a JavaScript Object Notation (JSON) string or undefined.
+     * @param value A JavaScript value to be converted, which could potentially be a non-JSON-representable value.
+     * @param replacer An array of strings and numbers that acts as an approved list for selecting the object properties that will be stringified.
+     * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+     */
+    stringify(value: unknown, replacer?: (number | string)[] | null, space?: string | number): string | undefined;
 }
 
 /**
@@ -1520,11 +1534,11 @@ interface Promise<T> {
  */
 type Awaited<T> =
     T extends null | undefined ? T : // special case for `null | undefined` when not in `--strictNullChecks` mode
-        T extends object & { then(onfulfilled: infer F, ...args: infer _): any } ? // `await` only unwraps object types with a callable `then`. Non-object types are not unwrapped
-            F extends ((value: infer V, ...args: infer _) => any) ? // if the argument to `then` is callable, extracts the first argument
-                Awaited<V> : // recursively unwrap the value
-                never : // the argument to `then` was not callable
-        T; // non-object or non-thenable
+    T extends object & { then(onfulfilled: infer F, ...args: infer _): any } ? // `await` only unwraps object types with a callable `then`. Non-object types are not unwrapped
+    F extends ((value: infer V, ...args: infer _) => any) ? // if the argument to `then` is callable, extracts the first argument
+    Awaited<V> : // recursively unwrap the value
+    never : // the argument to `then` was not callable
+    T; // non-object or non-thenable
 
 interface ArrayLike<T> {
     readonly length: number;

src/services/shims.ts

@@ -487,7 +487,7 @@ namespace ts {
                 this.shimHost.useCaseSensitiveFileNames!(), this.shimHost.getCurrentDirectory()); // TODO: GH#18217
             return JSON.parse(this.shimHost.readDirectory(
                 path,
-                JSON.stringify(extensions),
+                JSON.stringify(extensions ?? []),
                 JSON.stringify(pattern.basePaths),
                 pattern.excludePattern,
                 pattern.includeFilePattern,
@@ -585,15 +585,18 @@ namespace ts {
     function forwardCall<T>(logger: Logger, actionDescription: string, returnJson: boolean, action: () => T, logPerformance: boolean): T | string {
         try {
             const result = simpleForwardCall(logger, actionDescription, action, logPerformance);
-            return returnJson ? JSON.stringify({ result }) : result as T;
+            const resultObj = { result };
+            return returnJson ? JSON.stringify(resultObj) : result as T;
         }
         catch (err) {
             if (err instanceof OperationCanceledException) {
-                return JSON.stringify({ canceled: true });
+                const canceledObj = { canceled: true };
+                return JSON.stringify(canceledObj);
             }
             logInternalError(logger, err);
             err.description = actionDescription;
-            return JSON.stringify({ error: err });
+            const errorObj = { error: err };
+            return JSON.stringify(errorObj);
         }
     }
 

src/testRunner/unittests/config/convertCompilerOptionsFromJson.ts

@@ -31,14 +31,15 @@ namespace ts {
             const { options: actualCompilerOptions, errors: actualErrors } = convertCompilerOptionsFromJson(json.compilerOptions, "/apath/", configFileName);
 
             const parsedCompilerOptions = JSON.stringify(actualCompilerOptions);
-            const expectedCompilerOptions = JSON.stringify({ ...expectedResult.compilerOptions, configFilePath: configFileName });
+            const expectedCompilerOptionsObj = { ...expectedResult.compilerOptions, configFilePath: configFileName };
+            const expectedCompilerOptions = JSON.stringify(expectedCompilerOptionsObj);
             assert.equal(parsedCompilerOptions, expectedCompilerOptions);
 
             verifyErrors(actualErrors, expectedResult.errors, /*ignoreLocation*/ true);
         }
 
         function assertCompilerOptionsWithJsonNode(json: any, configFileName: string, expectedResult: ExpectedResultWithParsingSuccess) {
-            assertCompilerOptionsWithJsonText(JSON.stringify(json), configFileName, expectedResult);
+            assertCompilerOptionsWithJsonText(JSON.stringify(json as object), configFileName, expectedResult);
         }
 
         function assertCompilerOptionsWithJsonText(fileText: string, configFileName: string, expectedResult: ExpectedResult) {
@@ -657,15 +658,15 @@ namespace ts {
   }
 }
 `,
-            "tsconfig.json",
-            {
-                compilerOptions: {
-                    target: undefined,
-                    module: ModuleKind.ESNext,
-                    experimentalDecorators: true,
-                },
-                hasParseErrors: true
-            });
+                "tsconfig.json",
+                {
+                    compilerOptions: {
+                        target: undefined,
+                        module: ModuleKind.ESNext,
+                        experimentalDecorators: true,
+                    },
+                    hasParseErrors: true
+                });
         });
 
         it("Convert a tsconfig file with stray trailing characters", () => {

src/testRunner/unittests/tsbuildWatch/programUpdates.ts

@@ -182,12 +182,13 @@ export class someClass2 { }`),
                     "with circular project reference",
                     () => {
                         const [coreTsconfig, ...otherCoreFiles] = core;
+                        const circularCoreObj = {
+                            compilerOptions: { composite: true, declaration: true },
+                            references: [{ path: "../tests", circular: true }]
+                        };
                         const circularCoreConfig: File = {
                             path: coreTsconfig.path,
-                            content: JSON.stringify({
-                                compilerOptions: { composite: true, declaration: true },
-                                references: [{ path: "../tests", circular: true }]
-                            })
+                            content: JSON.stringify(circularCoreObj)
                         };
                         return [libFile, circularCoreConfig, ...otherCoreFiles, ...logic, ...tests];
                     }
@@ -240,18 +241,20 @@ export class someClass2 { }`),
                 subScenario: "when referenced using prepend builds referencing project even for non local change",
                 commandLineArgs: ["-b", "-w", `sample1/${SubProject.logic}`],
                 sys: () => {
+                    const coreTsConfigObj = {
+                        compilerOptions: { composite: true, declaration: true, outFile: "index.js" }
+                    };
                     const coreTsConfig: File = {
                         path: core[0].path,
-                        content: JSON.stringify({
-                            compilerOptions: { composite: true, declaration: true, outFile: "index.js" }
-                        })
+                        content: JSON.stringify(coreTsConfigObj)
+                    };
+                    const logicTsConfigObj = {
+                        compilerOptions: { composite: true, declaration: true, outFile: "index.js" },
+                        references: [{ path: "../core", prepend: true }]
                     };
                     const logicTsConfig: File = {
                         path: logic[0].path,
-                        content: JSON.stringify({
-                            compilerOptions: { composite: true, declaration: true, outFile: "index.js" },
-                            references: [{ path: "../core", prepend: true }]
-                        })
+                        content: JSON.stringify(logicTsConfigObj)
                     };
                     const logicIndex: File = {
                         path: logic[1].path,
@@ -743,4 +746,4 @@ export function someFn() { }`),
             changes: emptyArray
         });
     });
-}
+}