Add assert comments in CodeFixes and Refactors (#33016)

RyanCavanaugh · web-flow · commit 016884d48cc6 · 2019-08-21T14:22:17.000-07:00
* Add comments to assert calls

* Add comments to assert calls in codefixes

* So linty
diff --git a/src/services/codefixes/addConvertToUnknownForNonOverlappingTypes.ts b/src/services/codefixes/addConvertToUnknownForNonOverlappingTypes.ts
@@ -14,7 +14,7 @@ namespace ts.codefix {
 
     function makeChange(changeTracker: textChanges.ChangeTracker, sourceFile: SourceFile, pos: number) {
         const token = getTokenAtPosition(sourceFile, pos);
-        const assertion = Debug.assertDefined(findAncestor(token, (n): n is AsExpression | TypeAssertion => isAsExpression(n) || isTypeAssertion(n)));
+        const assertion = Debug.assertDefined(findAncestor(token, (n): n is AsExpression | TypeAssertion => isAsExpression(n) || isTypeAssertion(n)), "Expected to find an assertion expression");
         const replacement = isAsExpression(assertion)
             ? createAsExpression(assertion.expression, createKeywordTypeNode(SyntaxKind.UnknownKeyword))
             : createTypeAssertion(createKeywordTypeNode(SyntaxKind.UnknownKeyword), assertion.expression);
diff --git a/src/services/codefixes/annotateWithTypeFromJSDoc.ts b/src/services/codefixes/annotateWithTypeFromJSDoc.ts
@@ -60,8 +60,8 @@ namespace ts.codefix {
             }
         }
         else {
-            const jsdocType = Debug.assertDefined(getJSDocType(decl)); // If not defined, shouldn't have been an error to fix
-            Debug.assert(!decl.type); // If defined, shouldn't have been an error to fix.
+            const jsdocType = Debug.assertDefined(getJSDocType(decl), "A JSDocType for this declaration should exist"); // If not defined, shouldn't have been an error to fix
+            Debug.assert(!decl.type, "The JSDocType decl should have a type"); // If defined, shouldn't have been an error to fix.
             changes.tryInsertTypeAnnotation(sourceFile, decl, transformJSDocType(jsdocType));
         }
     }
diff --git a/src/services/codefixes/convertToEs6Module.ts b/src/services/codefixes/convertToEs6Module.ts
@@ -178,7 +178,7 @@ namespace ts.codefix {
                 // `const a = require("b").c` --> `import { c as a } from "./b";
                 return [makeSingleImport(name.text, propertyName, moduleSpecifier, quotePreference)];
             default:
-                return Debug.assertNever(name);
+                return Debug.assertNever(name, `Convert to ES6 module got invalid syntax form ${(name as BindingName).kind}`);
         }
     }
 
@@ -238,7 +238,7 @@ namespace ts.codefix {
                 case SyntaxKind.MethodDeclaration:
                     return !isIdentifier(prop.name) ? undefined : functionExpressionToDeclaration(prop.name.text, [createToken(SyntaxKind.ExportKeyword)], prop);
                 default:
-                    Debug.assertNever(prop);
+                    Debug.assertNever(prop, `Convert to ES6 got invalid prop kind ${(prop as ObjectLiteralElementLike).kind}`);
             }
         });
         return statements && [statements, false];
@@ -375,7 +375,7 @@ namespace ts.codefix {
             case SyntaxKind.Identifier:
                 return convertSingleIdentifierImport(file, name, moduleSpecifier, changes, checker, identifiers, quotePreference);
             default:
-                return Debug.assertNever(name);
+                return Debug.assertNever(name, `Convert to ES6 module got invalid name kind ${(name as BindingName).kind}`);
         }
     }
 
@@ -399,7 +399,7 @@ namespace ts.codefix {
             const { parent } = use;
             if (isPropertyAccessExpression(parent)) {
                 const { expression, name: { text: propertyName } } = parent;
-                Debug.assert(expression === use); // Else shouldn't have been in `collectIdentifiers`
+                Debug.assert(expression === use, "Didn't expect expression === use"); // Else shouldn't have been in `collectIdentifiers`
                 let idName = namedBindingsNames.get(propertyName);
                 if (idName === undefined) {
                     idName = makeUniqueName(propertyName, identifiers);
diff --git a/src/services/codefixes/fixAddModuleReferTypeMissingTypeof.ts b/src/services/codefixes/fixAddModuleReferTypeMissingTypeof.ts
@@ -19,8 +19,8 @@ namespace ts.codefix {
 
     function getImportTypeNode(sourceFile: SourceFile, pos: number): ImportTypeNode {
         const token = getTokenAtPosition(sourceFile, pos);
-        Debug.assert(token.kind === SyntaxKind.ImportKeyword);
-        Debug.assert(token.parent.kind === SyntaxKind.ImportType);
+        Debug.assert(token.kind === SyntaxKind.ImportKeyword, "This token should be an ImportKeyword");
+        Debug.assert(token.parent.kind === SyntaxKind.ImportType, "Token parent should be an ImportType");
         return <ImportTypeNode>token.parent;
     }
 
diff --git a/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts b/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts
@@ -28,7 +28,7 @@ namespace ts.codefix {
     });
 
     function getClass(sourceFile: SourceFile, pos: number): ClassLikeDeclaration {
-        return Debug.assertDefined(getContainingClass(getTokenAtPosition(sourceFile, pos)));
+        return Debug.assertDefined(getContainingClass(getTokenAtPosition(sourceFile, pos)), "There should be a containing class");
     }
 
     function symbolPointsToNonPrivateMember (symbol: Symbol) {
diff --git a/src/services/codefixes/fixConstructorForDerivedNeedSuperCall.ts b/src/services/codefixes/fixConstructorForDerivedNeedSuperCall.ts
@@ -17,7 +17,7 @@ namespace ts.codefix {
 
     function getNode(sourceFile: SourceFile, pos: number): ConstructorDeclaration {
         const token = getTokenAtPosition(sourceFile, pos);
-        Debug.assert(token.kind === SyntaxKind.ConstructorKeyword);
+        Debug.assert(token.kind === SyntaxKind.ConstructorKeyword, "token should be at the constructor keyword");
         return token.parent as ConstructorDeclaration;
     }
 
diff --git a/src/services/codefixes/fixSpelling.ts b/src/services/codefixes/fixSpelling.ts
@@ -36,12 +36,12 @@ namespace ts.codefix {
 
         let suggestion: string | undefined;
         if (isPropertyAccessExpression(node.parent) && node.parent.name === node) {
-            Debug.assert(node.kind === SyntaxKind.Identifier);
+            Debug.assert(node.kind === SyntaxKind.Identifier, "Expected an identifier for spelling (property access)");
             const containingType = checker.getTypeAtLocation(node.parent.expression);
             suggestion = checker.getSuggestionForNonexistentProperty(node as Identifier, containingType);
         }
         else if (isImportSpecifier(node.parent) && node.parent.name === node) {
-            Debug.assert(node.kind === SyntaxKind.Identifier);
+            Debug.assert(node.kind === SyntaxKind.Identifier, "Expected an identifier for spelling (import)");
             const importDeclaration = findAncestor(node, isImportDeclaration)!;
             const resolvedSourceFile = getResolvedSourceFileFromImportDeclaration(sourceFile, context, importDeclaration);
             if (resolvedSourceFile && resolvedSourceFile.symbol) {
diff --git a/src/services/codefixes/fixUnreachableCode.ts b/src/services/codefixes/fixUnreachableCode.ts
@@ -15,7 +15,7 @@ namespace ts.codefix {
     function doChange(changes: textChanges.ChangeTracker, sourceFile: SourceFile, start: number, length: number): void {
         const token = getTokenAtPosition(sourceFile, start);
         const statement = findAncestor(token, isStatement)!;
-        Debug.assert(statement.getStart(sourceFile) === token.getStart(sourceFile));
+        Debug.assert(statement.getStart(sourceFile) === token.getStart(sourceFile), "token and statement should start at the same point");
 
         const container = (isBlock(statement.parent) ? statement.parent : statement).parent;
         if (!isBlock(statement.parent) || statement === first(statement.parent.statements)) {
@@ -40,7 +40,7 @@ namespace ts.codefix {
 
         if (isBlock(statement.parent)) {
             const end = start + length;
-            const lastStatement = Debug.assertDefined(lastWhere(sliceAfter(statement.parent.statements, statement), s => s.pos < end));
+            const lastStatement = Debug.assertDefined(lastWhere(sliceAfter(statement.parent.statements, statement), s => s.pos < end), "Some statement should be last");
             changes.deleteNodeRange(sourceFile, statement, lastStatement);
         }
         else {
diff --git a/src/services/codefixes/fixUnusedIdentifier.ts b/src/services/codefixes/fixUnusedIdentifier.ts
@@ -117,7 +117,7 @@ namespace ts.codefix {
     }
 
     function deleteTypeParameters(changes: textChanges.ChangeTracker, sourceFile: SourceFile, token: Node): void {
-        changes.delete(sourceFile, Debug.assertDefined(cast(token.parent, isDeclarationWithTypeParameterChildren).typeParameters));
+        changes.delete(sourceFile, Debug.assertDefined(cast(token.parent, isDeclarationWithTypeParameterChildren).typeParameters, "The type parameter to delete should exist"));
     }
 
     // Sometimes the diagnostic span is an entire ImportDeclaration, so we should remove the whole thing.
@@ -231,7 +231,7 @@ namespace ts.codefix {
                 // Can't remove a non-last parameter in a callback. Can remove a parameter in code-fix-all if future parameters are also unused.
                 const { parameters } = parent;
                 const index = parameters.indexOf(p);
-                Debug.assert(index !== -1);
+                Debug.assert(index !== -1, "The parameter should already be in the list");
                 return isFixAll
                     ? parameters.slice(index + 1).every(p => p.name.kind === SyntaxKind.Identifier && !p.symbol.isReferenced)
                     : index === parameters.length - 1;
diff --git a/src/services/codefixes/helpers.ts b/src/services/codefixes/helpers.ts
@@ -87,7 +87,7 @@ namespace ts.codefix {
                             ambient ? undefined : createStubbedMethodBody(preferences)));
                     }
                     else {
-                        Debug.assertNode(accessor, isSetAccessorDeclaration);
+                        Debug.assertNode(accessor, isSetAccessorDeclaration, "The counterpart to a getter should be a setter");
                         const parameter = getSetAccessorValueParameter(accessor);
                         const parameterName = parameter && isIdentifier(parameter.name) ? idText(parameter.name) : undefined;
                         out(createSetAccessor(
@@ -115,7 +115,7 @@ namespace ts.codefix {
                 }
 
                 if (declarations.length === 1) {
-                    Debug.assert(signatures.length === 1);
+                    Debug.assert(signatures.length === 1, "One declaration implies one signature");
                     const signature = signatures[0];
                     outputMethod(signature, modifiers, name, ambient ? undefined : createStubbedMethodBody(preferences));
                     break;
@@ -132,7 +132,7 @@ namespace ts.codefix {
                         outputMethod(signature, modifiers, name, createStubbedMethodBody(preferences));
                     }
                     else {
-                        Debug.assert(declarations.length === signatures.length);
+                        Debug.assert(declarations.length === signatures.length, "Declarations and signatures should match count");
                         out(createMethodImplementingSignatures(signatures, name, optional, modifiers, preferences));
                     }
                 }
diff --git a/src/services/codefixes/importFixes.ts b/src/services/codefixes/importFixes.ts
@@ -57,7 +57,7 @@ namespace ts.codefix {
                             pushIfUnique(entry.namedImports, symbolName);
                         }
                         else {
-                            Debug.assert(entry.defaultImport === undefined || entry.defaultImport === symbolName);
+                            Debug.assert(entry.defaultImport === undefined || entry.defaultImport === symbolName, "(Add to Existing) Default import should be missing or match symbolName");
                             entry.defaultImport = symbolName;
                         }
                         break;
@@ -70,22 +70,22 @@ namespace ts.codefix {
                         }
                         switch (importKind) {
                             case ImportKind.Default:
-                                Debug.assert(entry.defaultImport === undefined || entry.defaultImport === symbolName);
+                                Debug.assert(entry.defaultImport === undefined || entry.defaultImport === symbolName, "(Add new) Default import should be missing or match symbolName");
                                 entry.defaultImport = symbolName;
                                 break;
                             case ImportKind.Named:
                                 pushIfUnique(entry.namedImports, symbolName);
                                 break;
                             case ImportKind.Equals:
                             case ImportKind.Namespace:
-                                Debug.assert(entry.namespaceLikeImport === undefined || entry.namespaceLikeImport.name === symbolName);
+                                Debug.assert(entry.namespaceLikeImport === undefined || entry.namespaceLikeImport.name === symbolName, "Namespacelike import shoudl be missing or match symbolName");
                                 entry.namespaceLikeImport = { importKind, name: symbolName };
                                 break;
                         }
                         break;
                     }
                     default:
-                        Debug.assertNever(fix);
+                        Debug.assertNever(fix, `fix wasn't never - got kind ${(fix as ImportFix).kind}`);
                 }
             });
 
@@ -165,7 +165,7 @@ namespace ts.codefix {
         preferences: UserPreferences,
     ): { readonly moduleSpecifier: string, readonly codeAction: CodeAction } {
         const exportInfos = getAllReExportingModules(sourceFile, exportedSymbol, moduleSymbol, symbolName, sourceFile, program.getCompilerOptions(), program.getTypeChecker(), program.getSourceFiles());
-        Debug.assert(exportInfos.some(info => info.moduleSymbol === moduleSymbol));
+        Debug.assert(exportInfos.some(info => info.moduleSymbol === moduleSymbol), "Some exportInfo should match the specified moduleSymbol");
         // We sort the best codefixes first, so taking `first` is best for completions.
         const moduleSpecifier = first(getNewImportInfos(program, sourceFile, position, exportInfos, host, preferences)).moduleSpecifier;
         const fix = first(getFixForImport(exportInfos, symbolName, position, program, sourceFile, host, preferences));
@@ -288,7 +288,7 @@ namespace ts.codefix {
             moduleSpecifiers.getModuleSpecifiers(moduleSymbol, program.getCompilerOptions(), sourceFile, host, program.getSourceFiles(), preferences, program.redirectTargetsMap)
             .map((moduleSpecifier): FixAddNewImport | FixUseImportType =>
                 // `position` should only be undefined at a missing jsx namespace, in which case we shouldn't be looking for pure types.
-                exportedSymbolIsTypeOnly && isJs ? { kind: ImportFixKind.ImportType, moduleSpecifier, position: Debug.assertDefined(position) } : { kind: ImportFixKind.AddNew, moduleSpecifier, importKind }));
+                exportedSymbolIsTypeOnly && isJs ? { kind: ImportFixKind.ImportType, moduleSpecifier, position: Debug.assertDefined(position, "position should be defined") } : { kind: ImportFixKind.AddNew, moduleSpecifier, importKind }));
         // Sort to keep the shortest paths first
         return sort(choicesForEachExportingModule, (a, b) => a.moduleSpecifier.length - b.moduleSpecifier.length);
     }
@@ -369,7 +369,7 @@ namespace ts.codefix {
                 // Fall back to the `import * as ns` style import.
                 return ImportKind.Namespace;
             default:
-                return Debug.assertNever(moduleKind);
+                return Debug.assertNever(moduleKind, `Unexpected moduleKind ${moduleKind}`);
         }
     }
 
@@ -382,7 +382,7 @@ namespace ts.codefix {
             ? checker.getJsxNamespace(sourceFile)
             : symbolToken.text;
         // "default" is a keyword and not a legal identifier for the import, so we don't expect it here
-        Debug.assert(symbolName !== InternalSymbolName.Default);
+        Debug.assert(symbolName !== InternalSymbolName.Default, "'default' isn't a legal identifier and couldn't occur here");
 
         const fixes = arrayFrom(flatMapIterator(getExportInfos(symbolName, getMeaningFromLocation(symbolToken), cancellationToken, sourceFile, checker, program).entries(), ([_, exportInfos]) =>
             getFixForImport(exportInfos, symbolName, symbolToken.getStart(sourceFile), program, sourceFile, host, preferences)));
@@ -468,7 +468,7 @@ namespace ts.codefix {
 
         if (defaultExport.flags & SymbolFlags.Alias) {
             const aliased = checker.getImmediateAliasedSymbol(defaultExport);
-            return aliased && getDefaultExportInfoWorker(aliased, Debug.assertDefined(aliased.parent), checker, compilerOptions);
+            return aliased && getDefaultExportInfoWorker(aliased, Debug.assertDefined(aliased.parent, "Alias targets of default exports must have a parent"), checker, compilerOptions);
         }
 
         if (defaultExport.escapedName !== InternalSymbolName.Default &&
@@ -486,7 +486,7 @@ namespace ts.codefix {
                 }
             }
             else if (isExportSpecifier(declaration)) {
-                Debug.assert(declaration.name.text === InternalSymbolName.Default);
+                Debug.assert(declaration.name.text === InternalSymbolName.Default, "Expected the specifier to be a default export");
                 return declaration.propertyName && declaration.propertyName.text;
             }
         });
@@ -521,13 +521,13 @@ namespace ts.codefix {
                 return [importKind === ImportKind.Default ? Diagnostics.Import_default_0_from_module_1 : Diagnostics.Import_0_from_module_1, symbolName, moduleSpecifier];
             }
             default:
-                return Debug.assertNever(fix);
+                return Debug.assertNever(fix, `Unexpected fix kind ${(fix as ImportFix).kind}`);
         }
     }
 
     function doAddExistingFix(changes: textChanges.ChangeTracker, sourceFile: SourceFile, clause: ImportClause, defaultImport: string | undefined, namedImports: ReadonlyArray<string>): void {
         if (defaultImport) {
-            Debug.assert(!clause.name);
+            Debug.assert(!clause.name, "Default imports can't have names");
             changes.insertNodeAt(sourceFile, clause.getStart(sourceFile), createIdentifier(defaultImport), { suffix: ", " });
         }
 
@@ -545,7 +545,7 @@ namespace ts.codefix {
                         changes.replaceNode(sourceFile, clause.namedBindings, namedImports);
                     }
                     else {
-                        changes.insertNodeAfter(sourceFile, Debug.assertDefined(clause.name), namedImports);
+                        changes.insertNodeAfter(sourceFile, Debug.assertDefined(clause.name, "Named import specifiers must have names"), namedImports);
                     }
                 }
             }
diff --git a/src/services/codefixes/inferFromUsage.ts b/src/services/codefixes/inferFromUsage.ts
@@ -211,7 +211,7 @@ namespace ts.codefix {
                 declaration: p,
                 type: isIdentifier(p.name) ? inferTypeForVariableFromUsage(p.name, program, cancellationToken) : program.getTypeChecker().getAnyType()
             }));
-        Debug.assert(containingFunction.parameters.length === parameterInferences.length);
+        Debug.assert(containingFunction.parameters.length === parameterInferences.length, "Parameter count and inference count should match");
 
         if (isInJSFile(containingFunction)) {
             annotateJSDocParameters(changes, sourceFile, parameterInferences, program, host);
@@ -741,7 +741,7 @@ namespace ts.codefix {
             for (const i of inferences) {
                 for (const { high, low } of priorities) {
                     if (high(i)) {
-                        Debug.assert(!low(i));
+                        Debug.assert(!low(i), "Priority can't have both low and high");
                         toRemove.push(low);
                     }
                 }
diff --git a/src/services/refactors/convertExport.ts b/src/services/refactors/convertExport.ts
diff --git a/src/services/refactors/convertImport.ts b/src/services/refactors/convertImport.ts
diff --git a/src/services/refactors/convertParamsToDestructuredObject.ts b/src/services/refactors/convertParamsToDestructuredObject.ts
diff --git a/src/services/refactors/extractSymbol.ts b/src/services/refactors/extractSymbol.ts
diff --git a/src/services/refactors/extractType.ts b/src/services/refactors/extractType.ts
diff --git a/src/services/refactors/moveToNewFile.ts b/src/services/refactors/moveToNewFile.ts

Original file line number	Diff line number	Diff line change
`@@ -60,8 +60,8 @@ namespace ts.codefix {`
`60`	`60`	`}`
`61`	`61`	`}`
`62`	`62`	`else {`
`63`		`- const jsdocType = Debug.assertDefined(getJSDocType(decl)); // If not defined, shouldn't have been an error to fix`
`64`		`- Debug.assert(!decl.type); // If defined, shouldn't have been an error to fix.`
	`63`	`+ const jsdocType = Debug.assertDefined(getJSDocType(decl), "A JSDocType for this declaration should exist"); // If not defined, shouldn't have been an error to fix`
	`64`	`+ Debug.assert(!decl.type, "The JSDocType decl should have a type"); // If defined, shouldn't have been an error to fix.`
`65`	`65`	`changes.tryInsertTypeAnnotation(sourceFile, decl, transformJSDocType(jsdocType));`
`66`	`66`	`}`
`67`	`67`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,8 @@ namespace ts.codefix {`
`19`	`19`
`20`	`20`	`function getImportTypeNode(sourceFile: SourceFile, pos: number): ImportTypeNode {`
`21`	`21`	`const token = getTokenAtPosition(sourceFile, pos);`
`22`		`- Debug.assert(token.kind === SyntaxKind.ImportKeyword);`
`23`		`- Debug.assert(token.parent.kind === SyntaxKind.ImportType);`
	`22`	`+ Debug.assert(token.kind === SyntaxKind.ImportKeyword, "This token should be an ImportKeyword");`
	`23`	`+ Debug.assert(token.parent.kind === SyntaxKind.ImportType, "Token parent should be an ImportType");`
`24`	`24`	`return <ImportTypeNode>token.parent;`
`25`	`25`	`}`
`26`	`26`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ namespace ts.codefix {`
`28`	`28`	`});`
`29`	`29`
`30`	`30`	`function getClass(sourceFile: SourceFile, pos: number): ClassLikeDeclaration {`
`31`		`- return Debug.assertDefined(getContainingClass(getTokenAtPosition(sourceFile, pos)));`
	`31`	`+ return Debug.assertDefined(getContainingClass(getTokenAtPosition(sourceFile, pos)), "There should be a containing class");`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`function symbolPointsToNonPrivateMember (symbol: Symbol) {`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ namespace ts.codefix {`
`17`	`17`
`18`	`18`	`function getNode(sourceFile: SourceFile, pos: number): ConstructorDeclaration {`
`19`	`19`	`const token = getTokenAtPosition(sourceFile, pos);`
`20`		`- Debug.assert(token.kind === SyntaxKind.ConstructorKeyword);`
	`20`	`+ Debug.assert(token.kind === SyntaxKind.ConstructorKeyword, "token should be at the constructor keyword");`
`21`	`21`	`return token.parent as ConstructorDeclaration;`
`22`	`22`	`}`
`23`	`23`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ namespace ts.codefix {`
`87`	`87`	`ambient ? undefined : createStubbedMethodBody(preferences)));`
`88`	`88`	`}`
`89`	`89`	`else {`
`90`		`- Debug.assertNode(accessor, isSetAccessorDeclaration);`
	`90`	`+ Debug.assertNode(accessor, isSetAccessorDeclaration, "The counterpart to a getter should be a setter");`
`91`	`91`	`const parameter = getSetAccessorValueParameter(accessor);`
`92`	`92`	`const parameterName = parameter && isIdentifier(parameter.name) ? idText(parameter.name) : undefined;`
`93`	`93`	`out(createSetAccessor(`
`@@ -115,7 +115,7 @@ namespace ts.codefix {`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`if (declarations.length === 1) {`
`118`		`- Debug.assert(signatures.length === 1);`
	`118`	`+ Debug.assert(signatures.length === 1, "One declaration implies one signature");`
`119`	`119`	`const signature = signatures[0];`
`120`	`120`	`outputMethod(signature, modifiers, name, ambient ? undefined : createStubbedMethodBody(preferences));`
`121`	`121`	`break;`
`@@ -132,7 +132,7 @@ namespace ts.codefix {`
`132`	`132`	`outputMethod(signature, modifiers, name, createStubbedMethodBody(preferences));`
`133`	`133`	`}`
`134`	`134`	`else {`
`135`		`- Debug.assert(declarations.length === signatures.length);`
	`135`	`+ Debug.assert(declarations.length === signatures.length, "Declarations and signatures should match count");`
`136`	`136`	`out(createMethodImplementingSignatures(signatures, name, optional, modifiers, preferences));`
`137`	`137`	`}`
`138`	`138`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ namespace ts.codefix {`
`57`	`57`	`pushIfUnique(entry.namedImports, symbolName);`
`58`	`58`	`}`
`59`	`59`	`else {`
`60`		`- Debug.assert(entry.defaultImport === undefined \|\| entry.defaultImport === symbolName);`
	`60`	`+ Debug.assert(entry.defaultImport === undefined \|\| entry.defaultImport === symbolName, "(Add to Existing) Default import should be missing or match symbolName");`
`61`	`61`	`entry.defaultImport = symbolName;`
`62`	`62`	`}`
`63`	`63`	`break;`
`@@ -70,22 +70,22 @@ namespace ts.codefix {`
`70`	`70`	`}`
`71`	`71`	`switch (importKind) {`
`72`	`72`	`case ImportKind.Default:`
`73`		`- Debug.assert(entry.defaultImport === undefined \|\| entry.defaultImport === symbolName);`
	`73`	`+ Debug.assert(entry.defaultImport === undefined \|\| entry.defaultImport === symbolName, "(Add new) Default import should be missing or match symbolName");`
`74`	`74`	`entry.defaultImport = symbolName;`
`75`	`75`	`break;`
`76`	`76`	`case ImportKind.Named:`
`77`	`77`	`pushIfUnique(entry.namedImports, symbolName);`
`78`	`78`	`break;`
`79`	`79`	`case ImportKind.Equals:`
`80`	`80`	`case ImportKind.Namespace:`
`81`		`- Debug.assert(entry.namespaceLikeImport === undefined \|\| entry.namespaceLikeImport.name === symbolName);`
	`81`	`+ Debug.assert(entry.namespaceLikeImport === undefined \|\| entry.namespaceLikeImport.name === symbolName, "Namespacelike import shoudl be missing or match symbolName");`
`82`	`82`	`entry.namespaceLikeImport = { importKind, name: symbolName };`
`83`	`83`	`break;`
`84`	`84`	`}`
`85`	`85`	`break;`
`86`	`86`	`}`
`87`	`87`	`default:`
`88`		`- Debug.assertNever(fix);`
	`88`	+ Debug.assertNever(fix, `fix wasn't never - got kind ${(fix as ImportFix).kind}`);
`89`	`89`	`}`
`90`	`90`	`});`
`91`	`91`
`@@ -165,7 +165,7 @@ namespace ts.codefix {`
`165`	`165`	`preferences: UserPreferences,`
`166`	`166`	`): { readonly moduleSpecifier: string, readonly codeAction: CodeAction } {`
`167`	`167`	`const exportInfos = getAllReExportingModules(sourceFile, exportedSymbol, moduleSymbol, symbolName, sourceFile, program.getCompilerOptions(), program.getTypeChecker(), program.getSourceFiles());`
`168`		`- Debug.assert(exportInfos.some(info => info.moduleSymbol === moduleSymbol));`
	`168`	`+ Debug.assert(exportInfos.some(info => info.moduleSymbol === moduleSymbol), "Some exportInfo should match the specified moduleSymbol");`
`169`	`169`	// We sort the best codefixes first, so taking `first` is best for completions.
`170`	`170`	`const moduleSpecifier = first(getNewImportInfos(program, sourceFile, position, exportInfos, host, preferences)).moduleSpecifier;`
`171`	`171`	`const fix = first(getFixForImport(exportInfos, symbolName, position, program, sourceFile, host, preferences));`
`@@ -288,7 +288,7 @@ namespace ts.codefix {`
`288`	`288`	`moduleSpecifiers.getModuleSpecifiers(moduleSymbol, program.getCompilerOptions(), sourceFile, host, program.getSourceFiles(), preferences, program.redirectTargetsMap)`
`289`	`289`	`.map((moduleSpecifier): FixAddNewImport \| FixUseImportType =>`
`290`	`290`	// `position` should only be undefined at a missing jsx namespace, in which case we shouldn't be looking for pure types.
`291`		`- exportedSymbolIsTypeOnly && isJs ? { kind: ImportFixKind.ImportType, moduleSpecifier, position: Debug.assertDefined(position) } : { kind: ImportFixKind.AddNew, moduleSpecifier, importKind }));`
	`291`	`+ exportedSymbolIsTypeOnly && isJs ? { kind: ImportFixKind.ImportType, moduleSpecifier, position: Debug.assertDefined(position, "position should be defined") } : { kind: ImportFixKind.AddNew, moduleSpecifier, importKind }));`
`292`	`292`	`// Sort to keep the shortest paths first`
`293`	`293`	`return sort(choicesForEachExportingModule, (a, b) => a.moduleSpecifier.length - b.moduleSpecifier.length);`
`294`	`294`	`}`
`@@ -369,7 +369,7 @@ namespace ts.codefix {`
`369`	`369`	// Fall back to the `import * as ns` style import.
`370`	`370`	`return ImportKind.Namespace;`
`371`	`371`	`default:`
`372`		`- return Debug.assertNever(moduleKind);`
	`372`	+ return Debug.assertNever(moduleKind, `Unexpected moduleKind ${moduleKind}`);
`373`	`373`	`}`
`374`	`374`	`}`
`375`	`375`
`@@ -382,7 +382,7 @@ namespace ts.codefix {`
`382`	`382`	`? checker.getJsxNamespace(sourceFile)`
`383`	`383`	`: symbolToken.text;`
`384`	`384`	`// "default" is a keyword and not a legal identifier for the import, so we don't expect it here`
`385`		`- Debug.assert(symbolName !== InternalSymbolName.Default);`
	`385`	`+ Debug.assert(symbolName !== InternalSymbolName.Default, "'default' isn't a legal identifier and couldn't occur here");`
`386`	`386`
`387`	`387`	`const fixes = arrayFrom(flatMapIterator(getExportInfos(symbolName, getMeaningFromLocation(symbolToken), cancellationToken, sourceFile, checker, program).entries(), ([_, exportInfos]) =>`
`388`	`388`	`getFixForImport(exportInfos, symbolName, symbolToken.getStart(sourceFile), program, sourceFile, host, preferences)));`
`@@ -468,7 +468,7 @@ namespace ts.codefix {`
`468`	`468`
`469`	`469`	`if (defaultExport.flags & SymbolFlags.Alias) {`
`470`	`470`	`const aliased = checker.getImmediateAliasedSymbol(defaultExport);`
`471`		`- return aliased && getDefaultExportInfoWorker(aliased, Debug.assertDefined(aliased.parent), checker, compilerOptions);`
	`471`	`+ return aliased && getDefaultExportInfoWorker(aliased, Debug.assertDefined(aliased.parent, "Alias targets of default exports must have a parent"), checker, compilerOptions);`
`472`	`472`	`}`
`473`	`473`
`474`	`474`	`if (defaultExport.escapedName !== InternalSymbolName.Default &&`
`@@ -486,7 +486,7 @@ namespace ts.codefix {`
`486`	`486`	`}`
`487`	`487`	`}`
`488`	`488`	`else if (isExportSpecifier(declaration)) {`
`489`		`- Debug.assert(declaration.name.text === InternalSymbolName.Default);`
	`489`	`+ Debug.assert(declaration.name.text === InternalSymbolName.Default, "Expected the specifier to be a default export");`
`490`	`490`	`return declaration.propertyName && declaration.propertyName.text;`
`491`	`491`	`}`
`492`	`492`	`});`
`@@ -521,13 +521,13 @@ namespace ts.codefix {`
`521`	`521`	`return [importKind === ImportKind.Default ? Diagnostics.Import_default_0_from_module_1 : Diagnostics.Import_0_from_module_1, symbolName, moduleSpecifier];`
`522`	`522`	`}`
`523`	`523`	`default:`
`524`		`- return Debug.assertNever(fix);`
	`524`	+ return Debug.assertNever(fix, `Unexpected fix kind ${(fix as ImportFix).kind}`);
`525`	`525`	`}`
`526`	`526`	`}`
`527`	`527`
`528`	`528`	`function doAddExistingFix(changes: textChanges.ChangeTracker, sourceFile: SourceFile, clause: ImportClause, defaultImport: string \| undefined, namedImports: ReadonlyArray<string>): void {`
`529`	`529`	`if (defaultImport) {`
`530`		`- Debug.assert(!clause.name);`
	`530`	`+ Debug.assert(!clause.name, "Default imports can't have names");`
`531`	`531`	`changes.insertNodeAt(sourceFile, clause.getStart(sourceFile), createIdentifier(defaultImport), { suffix: ", " });`
`532`	`532`	`}`
`533`	`533`
`@@ -545,7 +545,7 @@ namespace ts.codefix {`
`545`	`545`	`changes.replaceNode(sourceFile, clause.namedBindings, namedImports);`
`546`	`546`	`}`
`547`	`547`	`else {`
`548`		`- changes.insertNodeAfter(sourceFile, Debug.assertDefined(clause.name), namedImports);`
	`548`	`+ changes.insertNodeAfter(sourceFile, Debug.assertDefined(clause.name, "Named import specifiers must have names"), namedImports);`
`549`	`549`	`}`
`550`	`550`	`}`
`551`	`551`	`}`