@typescript-eslint/no-unnecessary-type-assertion

a-tarasyuk · a-tarasyuk · commit 62119ec9ccf2 · 2019-06-19T18:45:02.000+03:00
diff --git a/.eslintrc b/.eslintrc
@@ -38,7 +38,7 @@
         "@typescript-eslint/no-this-alias": "error",
         "@typescript-eslint/no-triple-slash-reference": "off",
         "@typescript-eslint/no-unnecessary-qualifier": "error",
-        "@typescript-eslint/no-unnecessary-type-assertion": "off",
+        "@typescript-eslint/no-unnecessary-type-assertion": "error",
         "@typescript-eslint/no-use-before-define": "off",
         "@typescript-eslint/no-var-requires": "off",
         "@typescript-eslint/prefer-for-of": "error",
diff --git a/scripts/buildProtocol.ts b/scripts/buildProtocol.ts
@@ -30,7 +30,7 @@ class DeclarationsWalker {
             text += "\ndeclare namespace ts {\n";
             text += "    // these types are empty stubs for types from services and should not be used directly\n";
             for (const type of walker.removedTypes) {
-                text += `    export type ${type.symbol!.name} = never;\n`;
+                text += `    export type ${type.symbol.name} = never;\n`;
             }
             text += "}";
         }
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -4093,7 +4093,7 @@ namespace ts {
                 let typeParameters: TypeParameterDeclaration[] | undefined;
                 let typeArguments: TypeNode[] | undefined;
                 if (context.flags & NodeBuilderFlags.WriteTypeArgumentsOfSignature && signature.target && signature.mapper && signature.target.typeParameters) {
-                    typeArguments = signature.target.typeParameters.map(parameter => typeToTypeNodeHelper(instantiateType(parameter, signature.mapper!), context));
+                    typeArguments = signature.target.typeParameters.map(parameter => typeToTypeNodeHelper(instantiateType(parameter, signature.mapper), context));
                 }
                 else {
                     typeParameters = signature.typeParameters && signature.typeParameters.map(parameter => typeParameterToDeclaration(parameter, context));
@@ -5893,7 +5893,7 @@ namespace ts {
                 if (!pushTypeResolution(symbol, TypeSystemPropertyName.Type)) {
                     return links.type = errorType;
                 }
-                let type = instantiateType(getTypeOfSymbol(links.target!), links.mapper!);
+                let type = instantiateType(getTypeOfSymbol(links.target!), links.mapper);
                 if (!popTypeResolution()) {
                     type = reportCircularityError(symbol);
                 }
@@ -7006,7 +7006,7 @@ namespace ts {
                 const minTypeArgumentCount = getMinTypeArgumentCount(baseSig.typeParameters);
                 const typeParamCount = length(baseSig.typeParameters);
                 if (isJavaScript || typeArgCount >= minTypeArgumentCount && typeArgCount <= typeParamCount) {
-                    const sig = typeParamCount ? createSignatureInstantiation(baseSig, fillMissingTypeArguments(typeArguments, baseSig.typeParameters, minTypeArgumentCount, isJavaScript)!) : cloneSignature(baseSig);
+                    const sig = typeParamCount ? createSignatureInstantiation(baseSig, fillMissingTypeArguments(typeArguments, baseSig.typeParameters, minTypeArgumentCount, isJavaScript)) : cloneSignature(baseSig);
                     sig.typeParameters = classType.localTypeParameters;
                     sig.resolvedReturnType = classType;
                     result.push(sig);
@@ -7903,7 +7903,7 @@ namespace ts {
             if (!typeParameter.default) {
                 if (typeParameter.target) {
                     const targetDefault = getResolvedTypeParameterDefault(typeParameter.target);
-                    typeParameter.default = targetDefault ? instantiateType(targetDefault, typeParameter.mapper!) : noConstraintType;
+                    typeParameter.default = targetDefault ? instantiateType(targetDefault, typeParameter.mapper) : noConstraintType;
                 }
                 else {
                     // To block recursion, set the initial value to the resolvingDefaultType.
@@ -8563,7 +8563,7 @@ namespace ts {
                 if (!pushTypeResolution(signature, TypeSystemPropertyName.ResolvedReturnType)) {
                     return errorType;
                 }
-                let type = signature.target ? instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper!) :
+                let type = signature.target ? instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper) :
                     signature.unionSignatures ? getUnionType(map(signature.unionSignatures, getReturnTypeOfSignature), UnionReduction.Subtype) :
                     getReturnTypeFromAnnotation(signature.declaration!) ||
                     isJSConstructor(signature.declaration) && getJSClassType(getSymbolOfNode(signature.declaration!)) ||
@@ -8815,7 +8815,7 @@ namespace ts {
             if (!typeParameter.constraint) {
                 if (typeParameter.target) {
                     const targetConstraint = getConstraintOfTypeParameter(typeParameter.target);
-                    typeParameter.constraint = targetConstraint ? instantiateType(targetConstraint, typeParameter.mapper!) : noConstraintType;
+                    typeParameter.constraint = targetConstraint ? instantiateType(targetConstraint, typeParameter.mapper) : noConstraintType;
                 }
                 else {
                     const constraintDeclaration = getConstraintDeclaration(typeParameter);
@@ -11175,7 +11175,7 @@ namespace ts {
                 // type mappers. This ensures that original type identities are properly preserved and that aliases
                 // always reference a non-aliases.
                 symbol = links.target!;
-                mapper = combineTypeMappers(links.mapper!, mapper);
+                mapper = combineTypeMappers(links.mapper, mapper);
             }
             // Keep the flags from the symbol we're instantiating.  Mark that is instantiated, and
             // also transient so that we can just store data on it directly.
@@ -11232,7 +11232,7 @@ namespace ts {
                 // We are instantiating an anonymous type that has one or more type parameters in scope. Apply the
                 // mapper to the type parameters to produce the effective list of type arguments, and compute the
                 // instantiation cache key from the type IDs of the type arguments.
-                const combinedMapper = type.objectFlags & ObjectFlags.Instantiated ? combineTypeMappers(type.mapper!, mapper) : mapper;
+                const combinedMapper = type.objectFlags & ObjectFlags.Instantiated ? combineTypeMappers(type.mapper, mapper) : mapper;
                 const typeArguments: Type[] = map(typeParameters, combinedMapper);
                 const id = getTypeListId(typeArguments);
                 let result = links.instantiations!.get(id);
@@ -18951,7 +18951,7 @@ namespace ts {
                     return createTypeReference((declaredManagedType as GenericType), args);
                 }
                 else if (length(declaredManagedType.aliasTypeArguments) >= 2) {
-                    const args = fillMissingTypeArguments([ctorType, attributesType], declaredManagedType.aliasTypeArguments!, 2, isInJSFile(context));
+                    const args = fillMissingTypeArguments([ctorType, attributesType], declaredManagedType.aliasTypeArguments, 2, isInJSFile(context));
                     return getTypeAliasInstantiation(declaredManagedType.aliasSymbol!, args);
                 }
             }
@@ -25194,7 +25194,7 @@ namespace ts {
                     }
                     result = result && checkTypeAssignableTo(
                         typeArguments[i],
-                        instantiateType(constraint, mapper!),
+                        instantiateType(constraint, mapper),
                         node.typeArguments![i],
                         Diagnostics.Type_0_does_not_satisfy_the_constraint_1);
                 }
@@ -25486,7 +25486,7 @@ namespace ts {
                             return;
                         }
                         else if (nodeIsPresent((<FunctionLikeDeclaration>subsequentNode).body)) {
-                            error(errorNode, Diagnostics.Function_implementation_name_must_be_0, declarationNameToString(node.name!));
+                            error(errorNode, Diagnostics.Function_implementation_name_must_be_0, declarationNameToString(node.name));
                             return;
                         }
                     }
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
@@ -2661,7 +2661,7 @@ namespace ts {
             writeKeyword("function");
             emit(node.asteriskToken);
             writeSpace();
-            emitIdentifierName(node.name!); // TODO: GH#18217
+            emitIdentifierName(node.name); // TODO: GH#18217
             emitSignatureAndBody(node, emitSignatureHead);
         }
 
@@ -3490,7 +3490,7 @@ namespace ts {
                     if (shouldEmitPrologueDirective) {
                         if (needsToSetSourceFile) {
                             needsToSetSourceFile = false;
-                            setSourceFile(sourceFile!);
+                            setSourceFile(sourceFile);
                         }
                         writeLine();
                         const pos = writer.getTextPos();
diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts
@@ -936,7 +936,7 @@ namespace ts {
             //      x = %sent%;
 
             const resumeLabel = defineLabel();
-            const expression = visitNode(node.expression!, visitor, isExpression);
+            const expression = visitNode(node.expression, visitor, isExpression);
             if (node.asteriskToken) {
                 const iterator = (getEmitFlags(node.expression!) & EmitFlags.Iterator) === 0
                     ? createValuesHelper(context, expression, /*location*/ node)
@@ -1262,7 +1262,7 @@ namespace ts {
             while (variablesWritten < numVariables) {
                 for (let i = variablesWritten; i < numVariables; i++) {
                     const variable = variables[i];
-                    if (containsYield(variable.initializer!) && pendingExpressions.length > 0) {
+                    if (containsYield(variable.initializer) && pendingExpressions.length > 0) {
                         break;
                     }
 
@@ -1283,7 +1283,7 @@ namespace ts {
             return setSourceMapRange(
                 createAssignment(
                     setSourceMapRange(<Identifier>getSynthesizedClone(node.name), node.name),
-                    visitNode(node.initializer!, visitor, isExpression)
+                    visitNode(node.initializer, visitor, isExpression)
                 ),
                 node
             );
@@ -1868,7 +1868,7 @@ namespace ts {
 
         function transformAndEmitThrowStatement(node: ThrowStatement): void {
             emitThrow(
-                visitNode(node.expression!, visitor, isExpression),
+                visitNode(node.expression, visitor, isExpression),
                 /*location*/ node
             );
         }
diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts
@@ -621,7 +621,7 @@ namespace ts {
             if (hasAssociatedEndOfDeclarationMarker(node)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id]!, node);
+                deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id], node);
             }
             else {
                 statements = appendExportsOfImportEqualsDeclaration(statements, node);
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
@@ -1271,7 +1271,7 @@ namespace ts {
             const propertyName = isComputedPropertyName(property.name) && !isSimpleInlineableExpression(property.name.expression)
                 ? updateComputedPropertyName(property.name, getGeneratedNameForNode(property.name))
                 : property.name;
-            const initializer = visitNode(property.initializer!, visitor, isExpression);
+            const initializer = visitNode(property.initializer, visitor, isExpression);
             const memberAccess = createMemberAccessForPropertyName(receiver, propertyName, /*location*/ propertyName);
 
             return createAssignment(memberAccess, initializer);
@@ -2477,7 +2477,7 @@ namespace ts {
                 return setTextRange(
                     createAssignment(
                         getNamespaceMemberNameWithSourceMapsAndWithoutComments(name),
-                        visitNode(node.initializer!, visitor, isExpression)
+                        visitNode(node.initializer, visitor, isExpression)
                     ),
                     /*location*/ node
                 );
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -2201,13 +2201,13 @@ namespace ts {
         let result: (JSDoc | JSDocTag)[] | undefined;
         // Pull parameter comments from declaring function as well
         if (isVariableLike(hostNode) && hasInitializer(hostNode) && hasJSDocNodes(hostNode.initializer!)) {
-            result = addRange(result, (hostNode.initializer as HasJSDoc).jsDoc!);
+            result = addRange(result, (hostNode.initializer as HasJSDoc).jsDoc);
         }
 
         let node: Node | undefined = hostNode;
         while (node && node.parent) {
             if (hasJSDocNodes(node)) {
-                result = addRange(result, node.jsDoc!);
+                result = addRange(result, node.jsDoc);
             }
 
             if (node.kind === SyntaxKind.Parameter) {
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
@@ -334,7 +334,7 @@ namespace ts {
                     nodesVisitor((<IndexSignatureDeclaration>node).decorators, visitor, isDecorator),
                     nodesVisitor((<IndexSignatureDeclaration>node).modifiers, visitor, isModifier),
                     nodesVisitor((<IndexSignatureDeclaration>node).parameters, visitor, isParameterDeclaration),
-                    visitNode((<IndexSignatureDeclaration>node).type!, visitor, isTypeNode));
+                    visitNode((<IndexSignatureDeclaration>node).type, visitor, isTypeNode));
 
             // Types
 
@@ -564,7 +564,7 @@ namespace ts {
             case SyntaxKind.YieldExpression:
                 return updateYield(<YieldExpression>node,
                     visitNode((<YieldExpression>node).asteriskToken, tokenVisitor, isToken),
-                    visitNode((<YieldExpression>node).expression!, visitor, isExpression));
+                    visitNode((<YieldExpression>node).expression, visitor, isExpression));
 
             case SyntaxKind.SpreadElement:
                 return updateSpread(<SpreadElement>node,
@@ -683,7 +683,7 @@ namespace ts {
 
             case SyntaxKind.ThrowStatement:
                 return updateThrow(<ThrowStatement>node,
-                    visitNode((<ThrowStatement>node).expression!, visitor, isExpression));
+                    visitNode((<ThrowStatement>node).expression, visitor, isExpression));
 
             case SyntaxKind.TryStatement:
                 return updateTry(<TryStatement>node,
@@ -857,7 +857,7 @@ namespace ts {
             case SyntaxKind.JsxAttribute:
                 return updateJsxAttribute(<JsxAttribute>node,
                     visitNode((<JsxAttribute>node).name, visitor, isIdentifier),
-                    visitNode((<JsxAttribute>node).initializer!, visitor, isStringLiteralOrJsxExpression));
+                    visitNode((<JsxAttribute>node).initializer, visitor, isStringLiteralOrJsxExpression));
 
             case SyntaxKind.JsxAttributes:
                 return updateJsxAttributes(<JsxAttributes>node,
diff --git a/src/harness/harness.ts b/src/harness/harness.ts
@@ -833,7 +833,7 @@ namespace Harness {
                 setCompilerOptionsFromHarnessSetting(harnessSettings, options);
             }
             if (options.rootDirs) {
-                options.rootDirs = ts.map(options.rootDirs, d => ts.getNormalizedAbsolutePath(d, currentDirectory!));
+                options.rootDirs = ts.map(options.rootDirs, d => ts.getNormalizedAbsolutePath(d, currentDirectory));
             }
 
             const useCaseSensitiveFileNames = options.useCaseSensitiveFileNames !== undefined ? options.useCaseSensitiveFileNames : true;
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
@@ -1784,7 +1784,7 @@ namespace ts.server {
             }
             project.enablePluginsWithOptions(compilerOptions, this.currentPluginConfigOverrides);
             const filesToAdd = parsedCommandLine.fileNames.concat(project.getExternalFiles());
-            this.updateRootAndOptionsOfNonInferredProject(project, filesToAdd, fileNamePropertyReader, compilerOptions, parsedCommandLine.typeAcquisition!, parsedCommandLine.compileOnSave!); // TODO: GH#18217
+            this.updateRootAndOptionsOfNonInferredProject(project, filesToAdd, fileNamePropertyReader, compilerOptions, parsedCommandLine.typeAcquisition!, parsedCommandLine.compileOnSave); // TODO: GH#18217
         }
 
         private updateNonInferredProjectFiles<T>(project: ExternalProject | ConfiguredProject, files: T[], propertyReader: FilePropertyReader<T>) {
diff --git a/src/services/codefixes/convertToEs6Module.ts b/src/services/codefixes/convertToEs6Module.ts
@@ -355,7 +355,9 @@ namespace ts.codefix {
                 const importSpecifiers = mapAllOrFail(name.elements, e =>
                     e.dotDotDotToken || e.initializer || e.propertyName && !isIdentifier(e.propertyName) || !isIdentifier(e.name)
                         ? undefined
-                        : makeImportSpecifier(e.propertyName && (e.propertyName as Identifier).text, e.name.text)); // tslint:disable-line no-unnecessary-type-assertion (TODO: GH#18217)
+                        // (TODO: GH#18217)
+                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+                        : makeImportSpecifier(e.propertyName && (e.propertyName as Identifier).text, e.name.text));
                 if (importSpecifiers) {
                     return [makeImport(/*name*/ undefined, importSpecifiers, moduleSpecifier, quotePreference)];
                 }
diff --git a/src/services/documentHighlights.ts b/src/services/documentHighlights.ts
diff --git a/src/services/refactors/extractSymbol.ts b/src/services/refactors/extractSymbol.ts
diff --git a/src/testRunner/compilerRunner.ts b/src/testRunner/compilerRunner.ts
diff --git a/src/testRunner/unittests/tscWatch/helpers.ts b/src/testRunner/unittests/tscWatch/helpers.ts

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ class DeclarationsWalker {`
`30`	`30`	`text += "\ndeclare namespace ts {\n";`
`31`	`31`	`text += " // these types are empty stubs for types from services and should not be used directly\n";`
`32`	`32`	`for (const type of walker.removedTypes) {`
`33`		- text += ` export type ${type.symbol!.name} = never;\n`;
	`33`	+ text += ` export type ${type.symbol.name} = never;\n`;
`34`	`34`	`}`
`35`	`35`	`text += "}";`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -621,7 +621,7 @@ namespace ts {`
`621`	`621`	`if (hasAssociatedEndOfDeclarationMarker(node)) {`
`622`	`622`	`// Defer exports until we encounter an EndOfDeclarationMarker node`
`623`	`623`	`const id = getOriginalNodeId(node);`
`624`		`- deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id]!, node);`
	`624`	`+ deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id], node);`
`625`	`625`	`}`
`626`	`626`	`else {`
`627`	`627`	`statements = appendExportsOfImportEqualsDeclaration(statements, node);`
Original file line number	Diff line number	Diff line change
`@@ -2201,13 +2201,13 @@ namespace ts {`
`2201`	`2201`	`let result: (JSDoc \| JSDocTag)[] \| undefined;`
`2202`	`2202`	`// Pull parameter comments from declaring function as well`
`2203`	`2203`	`if (isVariableLike(hostNode) && hasInitializer(hostNode) && hasJSDocNodes(hostNode.initializer!)) {`
`2204`		`- result = addRange(result, (hostNode.initializer as HasJSDoc).jsDoc!);`
	`2204`	`+ result = addRange(result, (hostNode.initializer as HasJSDoc).jsDoc);`
`2205`	`2205`	`}`
`2206`	`2206`
`2207`	`2207`	`let node: Node \| undefined = hostNode;`
`2208`	`2208`	`while (node && node.parent) {`
`2209`	`2209`	`if (hasJSDocNodes(node)) {`
`2210`		`- result = addRange(result, node.jsDoc!);`
	`2210`	`+ result = addRange(result, node.jsDoc);`
`2211`	`2211`	`}`
`2212`	`2212`
`2213`	`2213`	`if (node.kind === SyntaxKind.Parameter) {`
Original file line number	Diff line number	Diff line change
`@@ -833,7 +833,7 @@ namespace Harness {`
`833`	`833`	`setCompilerOptionsFromHarnessSetting(harnessSettings, options);`
`834`	`834`	`}`
`835`	`835`	`if (options.rootDirs) {`
`836`		`- options.rootDirs = ts.map(options.rootDirs, d => ts.getNormalizedAbsolutePath(d, currentDirectory!));`
	`836`	`+ options.rootDirs = ts.map(options.rootDirs, d => ts.getNormalizedAbsolutePath(d, currentDirectory));`
`837`	`837`	`}`
`838`	`838`
`839`	`839`	`const useCaseSensitiveFileNames = options.useCaseSensitiveFileNames !== undefined ? options.useCaseSensitiveFileNames : true;`