diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 9dc777212b8..05626664a9a 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4826,12 +4826,9 @@ namespace ts {
         }
 
         function getInstantiatedConstructorsForTypeArguments(type: Type, typeArgumentNodes: TypeNode[], location: Node): Signature[] {
-            let signatures = getConstructorsForTypeArguments(type, typeArgumentNodes, location);
-            if (typeArgumentNodes) {
-                const typeArguments = map(typeArgumentNodes, getTypeFromTypeNode);
-                signatures = map(signatures, sig => getSignatureInstantiation(sig, typeArguments));
-            }
-            return signatures;
+            const signatures = getConstructorsForTypeArguments(type, typeArgumentNodes, location);
+            const typeArguments = map(typeArgumentNodes, getTypeFromTypeNode);
+            return sameMap(signatures, sig => some(sig.typeParameters) ? getSignatureInstantiation(sig, typeArguments) : sig);
         }
 
         /**
@@ -20927,7 +20924,7 @@ namespace ts {
                     const staticBaseType = getApparentType(baseConstructorType);
                     checkBaseTypeAccessibility(staticBaseType, baseTypeNode);
                     checkSourceElement(baseTypeNode.expression);
-                    if (baseTypeNode.typeArguments) {
+                    if (some(baseTypeNode.typeArguments)) {
                         forEach(baseTypeNode.typeArguments, checkSourceElement);
                         for (const constructor of getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode)) {
                             if (!checkTypeArgumentConstraints(constructor.typeParameters, baseTypeNode.typeArguments)) {
@@ -23910,6 +23907,11 @@ namespace ts {
                 const sourceFile = getSourceFileOfNode(node);
                 return grammarErrorAtPos(sourceFile, types.pos, 0, Diagnostics._0_list_cannot_be_empty, listType);
             }
+            return forEach(types, checkGrammarExpressionWithTypeArguments);
+        }
+
+        function checkGrammarExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
+            return checkGrammarTypeArguments(node, node.typeArguments);
         }
 
         function checkGrammarClassDeclarationHeritageClauses(node: ClassLikeDeclaration) {
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index eda408c03e5..2854bb8f2ef 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -3625,6 +3625,10 @@
         "category": "Message",
         "code": 90024
     },
+    "Prefix '{0}' with an underscore.": {
+        "category": "Message",
+        "code": 90025
+    },
     
     "Convert function to an ES2015 class": {
         "category": "Message",
diff --git a/src/harness/tsconfig.json b/src/harness/tsconfig.json
index 6553f3667a7..7366df94ef6 100644
--- a/src/harness/tsconfig.json
+++ b/src/harness/tsconfig.json
@@ -80,7 +80,7 @@
         "../services/codefixes/fixConstructorForDerivedNeedSuperCall.ts",
         "../services/codefixes/helpers.ts",
         "../services/codefixes/importFixes.ts",
-        "../services/codefixes/unusedIdentifierFixes.ts",
+        "../services/codefixes/fixUnusedIdentifier.ts",
         "../services/codefixes/disableJsDiagnostics.ts",
 
         "harness.ts",
diff --git a/src/services/codefixes/unusedIdentifierFixes.ts b/src/services/codefixes/fixUnusedIdentifier.ts
similarity index 63%
rename from src/services/codefixes/unusedIdentifierFixes.ts
rename to src/services/codefixes/fixUnusedIdentifier.ts
index 5d85979fcf9..cbe2ba5b1c5 100644
--- a/src/services/codefixes/unusedIdentifierFixes.ts
+++ b/src/services/codefixes/fixUnusedIdentifier.ts
@@ -18,14 +18,14 @@ namespace ts.codefix {
 
             switch (token.kind) {
                 case ts.SyntaxKind.Identifier:
-                    return deleteIdentifier();
+                    return deleteIdentifierOrPrefixWithUnderscore(<Identifier>token);
 
                 case SyntaxKind.PropertyDeclaration:
                 case SyntaxKind.NamespaceImport:
-                    return deleteNode(token.parent);
+                    return [deleteNode(token.parent)];
 
                 default:
-                    return deleteDefault();
+                    return [deleteDefault()];
             }
 
             function deleteDefault() {
@@ -40,61 +40,69 @@ namespace ts.codefix {
                 }
             }
 
-            function deleteIdentifier(): CodeAction[] | undefined {
-                switch (token.parent.kind) {
+            function prefixIdentifierWithUnderscore(identifier: Identifier): CodeAction {
+                const startPosition = identifier.getStart(sourceFile, /*includeJsDocComment*/ false);
+                return {
+                    description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Prefix_0_with_an_underscore), { 0: token.getText() }),
+                    changes: [{
+                        fileName: sourceFile.path,
+                        textChanges: [{
+                            span: { start: startPosition, length: 0 },
+                            newText: "_"
+                        }]
+                    }]
+                };
+            }
+
+            function deleteIdentifierOrPrefixWithUnderscore(identifier: Identifier): CodeAction[] | undefined {
+                const parent = identifier.parent;
+                switch (parent.kind) {
                     case ts.SyntaxKind.VariableDeclaration:
-                        return deleteVariableDeclaration(<ts.VariableDeclaration>token.parent);
+                        return deleteVariableDeclarationOrPrefixWithUnderscore(identifier, <ts.VariableDeclaration>parent);
 
                     case SyntaxKind.TypeParameter:
-                        const typeParameters = (<DeclarationWithTypeParameters>token.parent.parent).typeParameters;
+                        const typeParameters = (<DeclarationWithTypeParameters>parent.parent).typeParameters;
                         if (typeParameters.length === 1) {
                             const previousToken = getTokenAtPosition(sourceFile, typeParameters.pos - 1, /*includeJsDocComment*/ false);
-                            if (!previousToken || previousToken.kind !== SyntaxKind.LessThanToken) {
-                                return deleteRange(typeParameters);
-                            }
                             const nextToken = getTokenAtPosition(sourceFile, typeParameters.end, /*includeJsDocComment*/ false);
-                            if (!nextToken || nextToken.kind !== SyntaxKind.GreaterThanToken) {
-                                return deleteRange(typeParameters);
-                            }
-                            return deleteNodeRange(previousToken, nextToken);
+                            Debug.assert(previousToken.kind === SyntaxKind.LessThanToken);
+                            Debug.assert(nextToken.kind === SyntaxKind.GreaterThanToken);
+
+                            return [deleteNodeRange(previousToken, nextToken)];
                         }
                         else {
-                            return deleteNodeInList(token.parent);
+                            return [deleteNodeInList(parent)];
                         }
 
                     case ts.SyntaxKind.Parameter:
-                        const functionDeclaration = <FunctionDeclaration>token.parent.parent;
-                        if (functionDeclaration.parameters.length === 1) {
-                            return deleteNode(token.parent);
-                        }
-                        else {
-                            return deleteNodeInList(token.parent);
-                        }
+                        const functionDeclaration = <FunctionDeclaration>parent.parent;
+                        return [functionDeclaration.parameters.length === 1 ? deleteNode(parent) : deleteNodeInList(parent),
+                            prefixIdentifierWithUnderscore(identifier)];
 
                     // handle case where 'import a = A;'
                     case SyntaxKind.ImportEqualsDeclaration:
-                        const importEquals = getAncestor(token, SyntaxKind.ImportEqualsDeclaration);
-                        return deleteNode(importEquals);
+                        const importEquals = getAncestor(identifier, SyntaxKind.ImportEqualsDeclaration);
+                        return [deleteNode(importEquals)];
 
                     case SyntaxKind.ImportSpecifier:
-                        const namedImports = <NamedImports>token.parent.parent;
+                        const namedImports = <NamedImports>parent.parent;
                         if (namedImports.elements.length === 1) {
                             // Only 1 import and it is unused. So the entire declaration should be removed.
-                            const importSpec = getAncestor(token, SyntaxKind.ImportDeclaration);
-                            return deleteNode(importSpec);
+                            const importSpec = getAncestor(identifier, SyntaxKind.ImportDeclaration);
+                            return [deleteNode(importSpec)];
                         }
                         else {
                             // delete import specifier
-                            return deleteNodeInList(token.parent);
+                            return [deleteNodeInList(parent)];
                         }
 
                     // handle case where "import d, * as ns from './file'"
                     // or "'import {a, b as ns} from './file'"
                     case SyntaxKind.ImportClause: // this covers both 'import |d|' and 'import |d,| *'
-                        const importClause = <ImportClause>token.parent;
+                        const importClause = <ImportClause>parent;
                         if (!importClause.namedBindings) { // |import d from './file'| or |import * as ns from './file'|
                             const importDecl = getAncestor(importClause, SyntaxKind.ImportDeclaration);
-                            return deleteNode(importDecl);
+                            return [deleteNode(importDecl)];
                         }
                         else {
                             // import |d,| * as ns from './file'
@@ -102,64 +110,62 @@ namespace ts.codefix {
                             const nextToken = getTokenAtPosition(sourceFile, importClause.name.end, /*includeJsDocComment*/ false);
                             if (nextToken && nextToken.kind === SyntaxKind.CommaToken) {
                                 // shift first non-whitespace position after comma to the start position of the node
-                                return deleteRange({ pos: start, end: skipTrivia(sourceFile.text, nextToken.end, /*stopAfterLineBreaks*/ false, /*stopAtComments*/ true) });
+                                return [deleteRange({ pos: start, end: skipTrivia(sourceFile.text, nextToken.end, /*stopAfterLineBreaks*/ false, /*stopAtComments*/ true) })];
                             }
                             else {
-                                return deleteNode(importClause.name);
+                                return [deleteNode(importClause.name)];
                             }
                         }
 
                     case SyntaxKind.NamespaceImport:
-                        const namespaceImport = <NamespaceImport>token.parent;
-                        if (namespaceImport.name === token && !(<ImportClause>namespaceImport.parent).name) {
+                        const namespaceImport = <NamespaceImport>parent;
+                        if (namespaceImport.name === identifier && !(<ImportClause>namespaceImport.parent).name) {
                             const importDecl = getAncestor(namespaceImport, SyntaxKind.ImportDeclaration);
-                            return deleteNode(importDecl);
+                            return [deleteNode(importDecl)];
                         }
                         else {
                             const previousToken = getTokenAtPosition(sourceFile, namespaceImport.pos - 1, /*includeJsDocComment*/ false);
                             if (previousToken && previousToken.kind === SyntaxKind.CommaToken) {
                                 const startPosition = textChanges.getAdjustedStartPosition(sourceFile, previousToken, {}, textChanges.Position.FullStart);
-                                return deleteRange({ pos: startPosition, end: namespaceImport.end });
+                                return [deleteRange({ pos: startPosition, end: namespaceImport.end })];
                             }
-                            return deleteRange(namespaceImport);
+                            return [deleteRange(namespaceImport)];
                         }
 
                     default:
-                        return deleteDefault();
+                        return [deleteDefault()];
                 }
             }
 
             // token.parent is a variableDeclaration
-            function deleteVariableDeclaration(varDecl: ts.VariableDeclaration): CodeAction[] | undefined {
+            function deleteVariableDeclarationOrPrefixWithUnderscore(identifier: Identifier, varDecl: ts.VariableDeclaration): CodeAction[] | undefined {
                 switch (varDecl.parent.parent.kind) {
                     case SyntaxKind.ForStatement:
                         const forStatement = <ForStatement>varDecl.parent.parent;
                         const forInitializer = <VariableDeclarationList>forStatement.initializer;
-                        if (forInitializer.declarations.length === 1) {
-                            return deleteNode(forInitializer);
-                        }
-                        else {
-                            return deleteNodeInList(varDecl);
-                        }
+                        return [forInitializer.declarations.length === 1 ? deleteNode(forInitializer) : deleteNodeInList(varDecl)];
 
                     case SyntaxKind.ForOfStatement:
                         const forOfStatement = <ForOfStatement>varDecl.parent.parent;
                         Debug.assert(forOfStatement.initializer.kind === SyntaxKind.VariableDeclarationList);
                         const forOfInitializer = <VariableDeclarationList>forOfStatement.initializer;
-                        return replaceNode(forOfInitializer.declarations[0], createObjectLiteral());
+                        return [
+                            replaceNode(forOfInitializer.declarations[0], createObjectLiteral()),
+                            prefixIdentifierWithUnderscore(identifier)
+                        ];
 
                     case SyntaxKind.ForInStatement:
                         // There is no valid fix in the case of:
                         //  for .. in
-                        return undefined;
+                        return [prefixIdentifierWithUnderscore(identifier)];
 
                     default:
                         const variableStatement = <VariableStatement>varDecl.parent.parent;
                         if (variableStatement.declarationList.declarations.length === 1) {
-                            return deleteNode(variableStatement);
+                            return [deleteNode(variableStatement)];
                         }
                         else {
-                            return deleteNodeInList(varDecl);
+                            return [deleteNodeInList(varDecl)];
                         }
                 }
             }
@@ -184,11 +190,11 @@ namespace ts.codefix {
                 return makeChange(textChanges.ChangeTracker.fromCodeFixContext(context).replaceNode(sourceFile, n, newNode));
             }
 
-            function makeChange(changeTracker: textChanges.ChangeTracker) {
-                return [{
+            function makeChange(changeTracker: textChanges.ChangeTracker): CodeAction {
+                return {
                     description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Remove_declaration_for_Colon_0), { 0: token.getText() }),
                     changes: changeTracker.getChanges()
-                }];
+                };
             }
         }
     });
diff --git a/src/services/codefixes/fixes.ts b/src/services/codefixes/fixes.ts
index c2e2509a28e..c38820231b0 100644
--- a/src/services/codefixes/fixes.ts
+++ b/src/services/codefixes/fixes.ts
@@ -6,7 +6,7 @@
 /// <reference path="fixConstructorForDerivedNeedSuperCall.ts" />
 /// <reference path="fixExtendsInterfaceBecomesImplements.ts" />
 /// <reference path="fixForgottenThisPropertyAccess.ts" />
-/// <reference path='unusedIdentifierFixes.ts' />
+/// <reference path='fixUnusedIdentifier.ts' />
 /// <reference path='importFixes.ts' />
 /// <reference path='disableJsDiagnostics.ts' />
 /// <reference path='helpers.ts' />
diff --git a/tests/baselines/reference/genericDefaults.js b/tests/baselines/reference/genericDefaults.js
index 45d889fc49c..06503b89d58 100644
--- a/tests/baselines/reference/genericDefaults.js
+++ b/tests/baselines/reference/genericDefaults.js
@@ -458,6 +458,15 @@ const Derived02c01 = new Derived02(1);
 const Derived02c02 = new Derived02<number>();
 const Derived02c03 = new Derived02<number>(1);
 
+// https://github.com/Microsoft/TypeScript/issues/16211
+interface Base02 {}
+interface Base02Constructor { new <T = A>(a: T): Base02 & T; }
+declare const Base02: Base02Constructor;
+declare class Derived03 extends Base02 {}
+const Derived03c00 = new Derived03(ab);
+const Derived03c01 = Derived03c00.a;
+type DerivedProps = keyof Derived03;
+
 type t00<T = number> = { a: T; }
 const t00c00 = (<t00>x).a;
 const t00c01 = (<t00<number>>x).a;
@@ -478,8 +487,7 @@ const t03c00 = (<t03<number>>x).a;
 const t03c01 = (<t03<1>>x).a;
 const t03c02 = (<t03<number, number>>x).a;
 const t03c03 = (<t03<1, 1>>x).a;
-const t03c04 = (<t03<number, 1>>x).a;
-
+const t03c04 = (<t03<number, 1>>x).a;
 
 //// [genericDefaults.js]
 // no inference
@@ -834,6 +842,8 @@ var Derived02c00 = new Derived02();
 var Derived02c01 = new Derived02(1);
 var Derived02c02 = new Derived02();
 var Derived02c03 = new Derived02(1);
+var Derived03c00 = new Derived03(ab);
+var Derived03c01 = Derived03c00.a;
 var t00c00 = x.a;
 var t00c01 = x.a;
 var t01c00 = x.a;
@@ -977,6 +987,17 @@ declare const Derived02c00: Derived02<string>;
 declare const Derived02c01: Derived02<number>;
 declare const Derived02c02: Derived02<number>;
 declare const Derived02c03: Derived02<number>;
+interface Base02 {
+}
+interface Base02Constructor {
+    new <T = A>(a: T): Base02 & T;
+}
+declare const Base02: Base02Constructor;
+declare class Derived03 extends Base02 {
+}
+declare const Derived03c00: Derived03;
+declare const Derived03c01: number;
+declare type DerivedProps = keyof Derived03;
 declare type t00<T = number> = {
     a: T;
 };
diff --git a/tests/baselines/reference/genericDefaults.symbols b/tests/baselines/reference/genericDefaults.symbols
index 2250e9ea95a..6c9e97b265e 100644
--- a/tests/baselines/reference/genericDefaults.symbols
+++ b/tests/baselines/reference/genericDefaults.symbols
@@ -2123,135 +2123,171 @@ const Derived02c03 = new Derived02<number>(1);
 >Derived02c03 : Symbol(Derived02c03, Decl(genericDefaults.ts, 457, 5))
 >Derived02 : Symbol(Derived02, Decl(genericDefaults.ts, 451, 46))
 
+// https://github.com/Microsoft/TypeScript/issues/16211
+interface Base02 {}
+>Base02 : Symbol(Base02, Decl(genericDefaults.ts, 457, 46), Decl(genericDefaults.ts, 462, 13))
+
+interface Base02Constructor { new <T = A>(a: T): Base02 & T; }
+>Base02Constructor : Symbol(Base02Constructor, Decl(genericDefaults.ts, 460, 19))
+>T : Symbol(T, Decl(genericDefaults.ts, 461, 35))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 461, 42))
+>T : Symbol(T, Decl(genericDefaults.ts, 461, 35))
+>Base02 : Symbol(Base02, Decl(genericDefaults.ts, 457, 46), Decl(genericDefaults.ts, 462, 13))
+>T : Symbol(T, Decl(genericDefaults.ts, 461, 35))
+
+declare const Base02: Base02Constructor;
+>Base02 : Symbol(Base02, Decl(genericDefaults.ts, 457, 46), Decl(genericDefaults.ts, 462, 13))
+>Base02Constructor : Symbol(Base02Constructor, Decl(genericDefaults.ts, 460, 19))
+
+declare class Derived03 extends Base02 {}
+>Derived03 : Symbol(Derived03, Decl(genericDefaults.ts, 462, 40))
+>Base02 : Symbol(Base02, Decl(genericDefaults.ts, 457, 46), Decl(genericDefaults.ts, 462, 13))
+
+const Derived03c00 = new Derived03(ab);
+>Derived03c00 : Symbol(Derived03c00, Decl(genericDefaults.ts, 464, 5))
+>Derived03 : Symbol(Derived03, Decl(genericDefaults.ts, 462, 40))
+>ab : Symbol(ab, Decl(genericDefaults.ts, 11, 13))
+
+const Derived03c01 = Derived03c00.a;
+>Derived03c01 : Symbol(Derived03c01, Decl(genericDefaults.ts, 465, 5))
+>Derived03c00.a : Symbol(A.a, Decl(genericDefaults.ts, 0, 13))
+>Derived03c00 : Symbol(Derived03c00, Decl(genericDefaults.ts, 464, 5))
+>a : Symbol(A.a, Decl(genericDefaults.ts, 0, 13))
+
+type DerivedProps = keyof Derived03;
+>DerivedProps : Symbol(DerivedProps, Decl(genericDefaults.ts, 465, 36))
+>Derived03 : Symbol(Derived03, Decl(genericDefaults.ts, 462, 40))
+
 type t00<T = number> = { a: T; }
->t00 : Symbol(t00, Decl(genericDefaults.ts, 457, 46))
->T : Symbol(T, Decl(genericDefaults.ts, 459, 9))
->a : Symbol(a, Decl(genericDefaults.ts, 459, 24))
->T : Symbol(T, Decl(genericDefaults.ts, 459, 9))
+>t00 : Symbol(t00, Decl(genericDefaults.ts, 466, 36))
+>T : Symbol(T, Decl(genericDefaults.ts, 468, 9))
+>a : Symbol(a, Decl(genericDefaults.ts, 468, 24))
+>T : Symbol(T, Decl(genericDefaults.ts, 468, 9))
 
 const t00c00 = (<t00>x).a;
->t00c00 : Symbol(t00c00, Decl(genericDefaults.ts, 460, 5))
->(<t00>x).a : Symbol(a, Decl(genericDefaults.ts, 459, 24))
->t00 : Symbol(t00, Decl(genericDefaults.ts, 457, 46))
+>t00c00 : Symbol(t00c00, Decl(genericDefaults.ts, 469, 5))
+>(<t00>x).a : Symbol(a, Decl(genericDefaults.ts, 468, 24))
+>t00 : Symbol(t00, Decl(genericDefaults.ts, 466, 36))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 459, 24))
+>a : Symbol(a, Decl(genericDefaults.ts, 468, 24))
 
 const t00c01 = (<t00<number>>x).a;
->t00c01 : Symbol(t00c01, Decl(genericDefaults.ts, 461, 5))
->(<t00<number>>x).a : Symbol(a, Decl(genericDefaults.ts, 459, 24))
->t00 : Symbol(t00, Decl(genericDefaults.ts, 457, 46))
+>t00c01 : Symbol(t00c01, Decl(genericDefaults.ts, 470, 5))
+>(<t00<number>>x).a : Symbol(a, Decl(genericDefaults.ts, 468, 24))
+>t00 : Symbol(t00, Decl(genericDefaults.ts, 466, 36))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 459, 24))
+>a : Symbol(a, Decl(genericDefaults.ts, 468, 24))
 
 type t01<T, U = T> = { a: [T, U]; }
->t01 : Symbol(t01, Decl(genericDefaults.ts, 461, 34))
->T : Symbol(T, Decl(genericDefaults.ts, 463, 9))
->U : Symbol(U, Decl(genericDefaults.ts, 463, 11))
->T : Symbol(T, Decl(genericDefaults.ts, 463, 9))
->a : Symbol(a, Decl(genericDefaults.ts, 463, 22))
->T : Symbol(T, Decl(genericDefaults.ts, 463, 9))
->U : Symbol(U, Decl(genericDefaults.ts, 463, 11))
+>t01 : Symbol(t01, Decl(genericDefaults.ts, 470, 34))
+>T : Symbol(T, Decl(genericDefaults.ts, 472, 9))
+>U : Symbol(U, Decl(genericDefaults.ts, 472, 11))
+>T : Symbol(T, Decl(genericDefaults.ts, 472, 9))
+>a : Symbol(a, Decl(genericDefaults.ts, 472, 22))
+>T : Symbol(T, Decl(genericDefaults.ts, 472, 9))
+>U : Symbol(U, Decl(genericDefaults.ts, 472, 11))
 
 const t01c00 = (<t01<number>>x).a;
->t01c00 : Symbol(t01c00, Decl(genericDefaults.ts, 464, 5))
->(<t01<number>>x).a : Symbol(a, Decl(genericDefaults.ts, 463, 22))
->t01 : Symbol(t01, Decl(genericDefaults.ts, 461, 34))
+>t01c00 : Symbol(t01c00, Decl(genericDefaults.ts, 473, 5))
+>(<t01<number>>x).a : Symbol(a, Decl(genericDefaults.ts, 472, 22))
+>t01 : Symbol(t01, Decl(genericDefaults.ts, 470, 34))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 463, 22))
+>a : Symbol(a, Decl(genericDefaults.ts, 472, 22))
 
 const t01c01 = (<t01<number, string>>x).a;
->t01c01 : Symbol(t01c01, Decl(genericDefaults.ts, 465, 5))
->(<t01<number, string>>x).a : Symbol(a, Decl(genericDefaults.ts, 463, 22))
->t01 : Symbol(t01, Decl(genericDefaults.ts, 461, 34))
+>t01c01 : Symbol(t01c01, Decl(genericDefaults.ts, 474, 5))
+>(<t01<number, string>>x).a : Symbol(a, Decl(genericDefaults.ts, 472, 22))
+>t01 : Symbol(t01, Decl(genericDefaults.ts, 470, 34))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 463, 22))
+>a : Symbol(a, Decl(genericDefaults.ts, 472, 22))
 
 type t02<T extends number, U = T> = { a: [T, U]; }
->t02 : Symbol(t02, Decl(genericDefaults.ts, 465, 42))
->T : Symbol(T, Decl(genericDefaults.ts, 467, 9))
->U : Symbol(U, Decl(genericDefaults.ts, 467, 26))
->T : Symbol(T, Decl(genericDefaults.ts, 467, 9))
->a : Symbol(a, Decl(genericDefaults.ts, 467, 37))
->T : Symbol(T, Decl(genericDefaults.ts, 467, 9))
->U : Symbol(U, Decl(genericDefaults.ts, 467, 26))
+>t02 : Symbol(t02, Decl(genericDefaults.ts, 474, 42))
+>T : Symbol(T, Decl(genericDefaults.ts, 476, 9))
+>U : Symbol(U, Decl(genericDefaults.ts, 476, 26))
+>T : Symbol(T, Decl(genericDefaults.ts, 476, 9))
+>a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>T : Symbol(T, Decl(genericDefaults.ts, 476, 9))
+>U : Symbol(U, Decl(genericDefaults.ts, 476, 26))
 
 const t02c00 = (<t02<number>>x).a;
->t02c00 : Symbol(t02c00, Decl(genericDefaults.ts, 468, 5))
->(<t02<number>>x).a : Symbol(a, Decl(genericDefaults.ts, 467, 37))
->t02 : Symbol(t02, Decl(genericDefaults.ts, 465, 42))
+>t02c00 : Symbol(t02c00, Decl(genericDefaults.ts, 477, 5))
+>(<t02<number>>x).a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>t02 : Symbol(t02, Decl(genericDefaults.ts, 474, 42))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 467, 37))
+>a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
 
 const t02c01 = (<t02<1>>x).a;
->t02c01 : Symbol(t02c01, Decl(genericDefaults.ts, 469, 5))
->(<t02<1>>x).a : Symbol(a, Decl(genericDefaults.ts, 467, 37))
->t02 : Symbol(t02, Decl(genericDefaults.ts, 465, 42))
+>t02c01 : Symbol(t02c01, Decl(genericDefaults.ts, 478, 5))
+>(<t02<1>>x).a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>t02 : Symbol(t02, Decl(genericDefaults.ts, 474, 42))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 467, 37))
+>a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
 
 const t02c02 = (<t02<number, number>>x).a;
->t02c02 : Symbol(t02c02, Decl(genericDefaults.ts, 470, 5))
->(<t02<number, number>>x).a : Symbol(a, Decl(genericDefaults.ts, 467, 37))
->t02 : Symbol(t02, Decl(genericDefaults.ts, 465, 42))
+>t02c02 : Symbol(t02c02, Decl(genericDefaults.ts, 479, 5))
+>(<t02<number, number>>x).a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>t02 : Symbol(t02, Decl(genericDefaults.ts, 474, 42))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 467, 37))
+>a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
 
 const t02c03 = (<t02<1, number>>x).a;
->t02c03 : Symbol(t02c03, Decl(genericDefaults.ts, 471, 5))
->(<t02<1, number>>x).a : Symbol(a, Decl(genericDefaults.ts, 467, 37))
->t02 : Symbol(t02, Decl(genericDefaults.ts, 465, 42))
+>t02c03 : Symbol(t02c03, Decl(genericDefaults.ts, 480, 5))
+>(<t02<1, number>>x).a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>t02 : Symbol(t02, Decl(genericDefaults.ts, 474, 42))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 467, 37))
+>a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
 
 const t02c04 = (<t02<number, 1>>x).a;
->t02c04 : Symbol(t02c04, Decl(genericDefaults.ts, 472, 5))
->(<t02<number, 1>>x).a : Symbol(a, Decl(genericDefaults.ts, 467, 37))
->t02 : Symbol(t02, Decl(genericDefaults.ts, 465, 42))
+>t02c04 : Symbol(t02c04, Decl(genericDefaults.ts, 481, 5))
+>(<t02<number, 1>>x).a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
+>t02 : Symbol(t02, Decl(genericDefaults.ts, 474, 42))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 467, 37))
+>a : Symbol(a, Decl(genericDefaults.ts, 476, 37))
 
 type t03<T extends number, U extends T = T> = { a: [T, U]; }
->t03 : Symbol(t03, Decl(genericDefaults.ts, 472, 37))
->T : Symbol(T, Decl(genericDefaults.ts, 474, 9))
->U : Symbol(U, Decl(genericDefaults.ts, 474, 26))
->T : Symbol(T, Decl(genericDefaults.ts, 474, 9))
->T : Symbol(T, Decl(genericDefaults.ts, 474, 9))
->a : Symbol(a, Decl(genericDefaults.ts, 474, 47))
->T : Symbol(T, Decl(genericDefaults.ts, 474, 9))
->U : Symbol(U, Decl(genericDefaults.ts, 474, 26))
+>t03 : Symbol(t03, Decl(genericDefaults.ts, 481, 37))
+>T : Symbol(T, Decl(genericDefaults.ts, 483, 9))
+>U : Symbol(U, Decl(genericDefaults.ts, 483, 26))
+>T : Symbol(T, Decl(genericDefaults.ts, 483, 9))
+>T : Symbol(T, Decl(genericDefaults.ts, 483, 9))
+>a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>T : Symbol(T, Decl(genericDefaults.ts, 483, 9))
+>U : Symbol(U, Decl(genericDefaults.ts, 483, 26))
 
 const t03c00 = (<t03<number>>x).a;
->t03c00 : Symbol(t03c00, Decl(genericDefaults.ts, 475, 5))
->(<t03<number>>x).a : Symbol(a, Decl(genericDefaults.ts, 474, 47))
->t03 : Symbol(t03, Decl(genericDefaults.ts, 472, 37))
+>t03c00 : Symbol(t03c00, Decl(genericDefaults.ts, 484, 5))
+>(<t03<number>>x).a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>t03 : Symbol(t03, Decl(genericDefaults.ts, 481, 37))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 474, 47))
+>a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
 
 const t03c01 = (<t03<1>>x).a;
->t03c01 : Symbol(t03c01, Decl(genericDefaults.ts, 476, 5))
->(<t03<1>>x).a : Symbol(a, Decl(genericDefaults.ts, 474, 47))
->t03 : Symbol(t03, Decl(genericDefaults.ts, 472, 37))
+>t03c01 : Symbol(t03c01, Decl(genericDefaults.ts, 485, 5))
+>(<t03<1>>x).a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>t03 : Symbol(t03, Decl(genericDefaults.ts, 481, 37))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 474, 47))
+>a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
 
 const t03c02 = (<t03<number, number>>x).a;
->t03c02 : Symbol(t03c02, Decl(genericDefaults.ts, 477, 5))
->(<t03<number, number>>x).a : Symbol(a, Decl(genericDefaults.ts, 474, 47))
->t03 : Symbol(t03, Decl(genericDefaults.ts, 472, 37))
+>t03c02 : Symbol(t03c02, Decl(genericDefaults.ts, 486, 5))
+>(<t03<number, number>>x).a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>t03 : Symbol(t03, Decl(genericDefaults.ts, 481, 37))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 474, 47))
+>a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
 
 const t03c03 = (<t03<1, 1>>x).a;
->t03c03 : Symbol(t03c03, Decl(genericDefaults.ts, 478, 5))
->(<t03<1, 1>>x).a : Symbol(a, Decl(genericDefaults.ts, 474, 47))
->t03 : Symbol(t03, Decl(genericDefaults.ts, 472, 37))
+>t03c03 : Symbol(t03c03, Decl(genericDefaults.ts, 487, 5))
+>(<t03<1, 1>>x).a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>t03 : Symbol(t03, Decl(genericDefaults.ts, 481, 37))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 474, 47))
+>a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
 
 const t03c04 = (<t03<number, 1>>x).a;
->t03c04 : Symbol(t03c04, Decl(genericDefaults.ts, 479, 5))
->(<t03<number, 1>>x).a : Symbol(a, Decl(genericDefaults.ts, 474, 47))
->t03 : Symbol(t03, Decl(genericDefaults.ts, 472, 37))
+>t03c04 : Symbol(t03c04, Decl(genericDefaults.ts, 488, 5))
+>(<t03<number, 1>>x).a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
+>t03 : Symbol(t03, Decl(genericDefaults.ts, 481, 37))
 >x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
->a : Symbol(a, Decl(genericDefaults.ts, 474, 47))
+>a : Symbol(a, Decl(genericDefaults.ts, 483, 47))
 
diff --git a/tests/baselines/reference/genericDefaults.types b/tests/baselines/reference/genericDefaults.types
index ef97847cc73..739588badb9 100644
--- a/tests/baselines/reference/genericDefaults.types
+++ b/tests/baselines/reference/genericDefaults.types
@@ -2446,6 +2446,43 @@ const Derived02c03 = new Derived02<number>(1);
 >Derived02 : typeof Derived02
 >1 : 1
 
+// https://github.com/Microsoft/TypeScript/issues/16211
+interface Base02 {}
+>Base02 : Base02
+
+interface Base02Constructor { new <T = A>(a: T): Base02 & T; }
+>Base02Constructor : Base02Constructor
+>T : T
+>A : A
+>a : T
+>T : T
+>Base02 : Base02
+>T : T
+
+declare const Base02: Base02Constructor;
+>Base02 : Base02Constructor
+>Base02Constructor : Base02Constructor
+
+declare class Derived03 extends Base02 {}
+>Derived03 : Derived03
+>Base02 : Base02 & A
+
+const Derived03c00 = new Derived03(ab);
+>Derived03c00 : Derived03
+>new Derived03(ab) : Derived03
+>Derived03 : typeof Derived03
+>ab : AB
+
+const Derived03c01 = Derived03c00.a;
+>Derived03c01 : number
+>Derived03c00.a : number
+>Derived03c00 : Derived03
+>a : number
+
+type DerivedProps = keyof Derived03;
+>DerivedProps : "a"
+>Derived03 : Derived03
+
 type t00<T = number> = { a: T; }
 >t00 : t00<T>
 >T : T
diff --git a/tests/cases/compiler/genericDefaults.ts b/tests/cases/compiler/genericDefaults.ts
index bba6549cfc1..624b44c0829 100644
--- a/tests/cases/compiler/genericDefaults.ts
+++ b/tests/cases/compiler/genericDefaults.ts
@@ -458,6 +458,15 @@ const Derived02c01 = new Derived02(1);
 const Derived02c02 = new Derived02<number>();
 const Derived02c03 = new Derived02<number>(1);
 
+// https://github.com/Microsoft/TypeScript/issues/16211
+interface Base02 {}
+interface Base02Constructor { new <T = A>(a: T): Base02 & T; }
+declare const Base02: Base02Constructor;
+declare class Derived03 extends Base02 {}
+const Derived03c00 = new Derived03(ab);
+const Derived03c01 = Derived03c00.a;
+type DerivedProps = keyof Derived03;
+
 type t00<T = number> = { a: T; }
 const t00c00 = (<t00>x).a;
 const t00c01 = (<t00<number>>x).a;
@@ -478,4 +487,4 @@ const t03c00 = (<t03<number>>x).a;
 const t03c01 = (<t03<1>>x).a;
 const t03c02 = (<t03<number, number>>x).a;
 const t03c03 = (<t03<1, 1>>x).a;
-const t03c04 = (<t03<number, 1>>x).a;
+const t03c04 = (<t03<number, 1>>x).a;
\ No newline at end of file
diff --git a/tests/cases/fourslash/unusedClassInNamespaceWithTrivia.ts b/tests/cases/fourslash/unusedClassInNamespaceWithTrivia.ts
new file mode 100644
index 00000000000..cae0c52ac79
--- /dev/null
+++ b/tests/cases/fourslash/unusedClassInNamespaceWithTrivia.ts
@@ -0,0 +1,11 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+//// [| namespace greeter {
+////   /* comment1 */
+////   class /* comment2 */ class1 {
+////   }
+//// } |]
+
+verify.rangeAfterCodeFix(`namespace greeter {
+}`);
diff --git a/tests/cases/fourslash/unusedLocalsInFunction3.ts b/tests/cases/fourslash/unusedLocalsInFunction3.ts
index 0164873acd8..ec5d72d83b6 100644
--- a/tests/cases/fourslash/unusedLocalsInFunction3.ts
+++ b/tests/cases/fourslash/unusedLocalsInFunction3.ts
@@ -7,4 +7,4 @@
 ////    z+1;
 ////}
 
-verify.rangeAfterCodeFix("var x,z = 1;", /*includeWhiteSpace*/ undefined, 6133);
+verify.rangeAfterCodeFix("var x,z = 1;", /*includeWhiteSpace*/ undefined, /*errorCode*/ 6133);
diff --git a/tests/cases/fourslash/unusedParameterInConstructor1.ts b/tests/cases/fourslash/unusedParameterInConstructor1.ts
index 36539e6649b..33fe34c7e61 100644
--- a/tests/cases/fourslash/unusedParameterInConstructor1.ts
+++ b/tests/cases/fourslash/unusedParameterInConstructor1.ts
@@ -5,4 +5,4 @@
 ////    [|constructor(private p1: string, public p2: boolean, public p3: any, p5)|] { p5; }
 //// }
 
-verify.rangeAfterCodeFix("constructor(public p2: boolean, public p3: any, p5)");
\ No newline at end of file
+verify.rangeAfterCodeFix("constructor(public p2: boolean, public p3: any, p5)", /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 0);
\ No newline at end of file
diff --git a/tests/cases/fourslash/unusedParameterInConstructor1AddUnderscore.ts b/tests/cases/fourslash/unusedParameterInConstructor1AddUnderscore.ts
new file mode 100644
index 00000000000..31882978951
--- /dev/null
+++ b/tests/cases/fourslash/unusedParameterInConstructor1AddUnderscore.ts
@@ -0,0 +1,8 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+//// class C1 {
+////    [|constructor(private p1: string, public p2: boolean, public p3: any, p5) |] { p5; }
+//// }
+
+verify.rangeAfterCodeFix("constructor(private _p1: string, public p2: boolean, public p3: any, p5)", /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 1);
\ No newline at end of file
diff --git a/tests/cases/fourslash/unusedParameterInConstructor2.ts b/tests/cases/fourslash/unusedParameterInConstructor2.ts
index e822a2f248d..71595a9c81c 100644
--- a/tests/cases/fourslash/unusedParameterInConstructor2.ts
+++ b/tests/cases/fourslash/unusedParameterInConstructor2.ts
@@ -5,4 +5,4 @@
 ////    [|constructor(public p1: string, private p2: boolean, public p3: any, p5)|] { p5; }
 //// }
 
-verify.rangeAfterCodeFix("constructor(public p1: string, public p3: any, p5)");
\ No newline at end of file
+verify.rangeAfterCodeFix("constructor(public p1: string, public p3: any, p5)", /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 0);
\ No newline at end of file
diff --git a/tests/cases/fourslash/unusedParameterInConstructor3.ts b/tests/cases/fourslash/unusedParameterInConstructor3.ts
index 1a9682aece3..3da0e85407f 100644
--- a/tests/cases/fourslash/unusedParameterInConstructor3.ts
+++ b/tests/cases/fourslash/unusedParameterInConstructor3.ts
@@ -5,4 +5,4 @@
 ////    [|constructor(public p1: string, public p2: boolean, private p3: any, p5)|] { p5; }
 //// }
 
-verify.rangeAfterCodeFix("constructor(public p1: string, public p2: boolean, p5)");
\ No newline at end of file
+verify.rangeAfterCodeFix("constructor(public p1: string, public p2: boolean, p5)", /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 0);
\ No newline at end of file
diff --git a/tests/cases/fourslash/unusedParameterInConstructor4.ts b/tests/cases/fourslash/unusedParameterInConstructor4.ts
index 01df43718da..860a7befa9b 100644
--- a/tests/cases/fourslash/unusedParameterInConstructor4.ts
+++ b/tests/cases/fourslash/unusedParameterInConstructor4.ts
@@ -5,4 +5,4 @@
 ////    [|constructor(private readonly p2: boolean, p5)|] { p5; }
 //// }
 
-verify.rangeAfterCodeFix("constructor(p5)");
\ No newline at end of file
+verify.rangeAfterCodeFix("constructor(p5)", /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 0);
\ No newline at end of file
diff --git a/tests/cases/fourslash/unusedParameterInFunction1.ts b/tests/cases/fourslash/unusedParameterInFunction1.ts
index baaccbbd20f..bc6f081ecaa 100644
--- a/tests/cases/fourslash/unusedParameterInFunction1.ts
+++ b/tests/cases/fourslash/unusedParameterInFunction1.ts
@@ -4,4 +4,4 @@
 ////function [|greeter( x)|] {
 ////}
 
-verify.rangeAfterCodeFix("greeter()");
+verify.rangeAfterCodeFix("greeter()", /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 0);
diff --git a/tests/cases/fourslash/unusedParameterInFunction1AddUnderscore.ts b/tests/cases/fourslash/unusedParameterInFunction1AddUnderscore.ts
new file mode 100644
index 00000000000..137625869c8
--- /dev/null
+++ b/tests/cases/fourslash/unusedParameterInFunction1AddUnderscore.ts
@@ -0,0 +1,7 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedParameters: true
+////function [|greeter( x) |] {
+////}
+
+verify.rangeAfterCodeFix("greeter( _x)", /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 1);
diff --git a/tests/cases/fourslash/unusedParameterInFunction2.ts b/tests/cases/fourslash/unusedParameterInFunction2.ts
index 0e448c98fcc..81e73450622 100644
--- a/tests/cases/fourslash/unusedParameterInFunction2.ts
+++ b/tests/cases/fourslash/unusedParameterInFunction2.ts
@@ -5,4 +5,4 @@
 ////    x++;
 ////}
 
-verify.rangeAfterCodeFix("greeter(x)");
\ No newline at end of file
+verify.rangeAfterCodeFix("greeter(x)", /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 0);
\ No newline at end of file
diff --git a/tests/cases/fourslash/unusedParameterInFunction3.ts b/tests/cases/fourslash/unusedParameterInFunction3.ts
index 23f45475950..dcbe53163db 100644
--- a/tests/cases/fourslash/unusedParameterInFunction3.ts
+++ b/tests/cases/fourslash/unusedParameterInFunction3.ts
@@ -5,4 +5,4 @@
 ////    y++;
 ////}
 
-verify.rangeAfterCodeFix("greeter(y)");
\ No newline at end of file
+verify.rangeAfterCodeFix("greeter(y)", /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 0);
\ No newline at end of file
diff --git a/tests/cases/fourslash/unusedParameterInFunction4.ts b/tests/cases/fourslash/unusedParameterInFunction4.ts
index 1f98238d647..4ea96b3bd18 100644
--- a/tests/cases/fourslash/unusedParameterInFunction4.ts
+++ b/tests/cases/fourslash/unusedParameterInFunction4.ts
@@ -6,4 +6,4 @@
 ////    z++;
 ////}
 
-verify.rangeAfterCodeFix("function greeter(x,z)");
\ No newline at end of file
+verify.rangeAfterCodeFix("function greeter(x,z)", /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 0);
\ No newline at end of file
diff --git a/tests/cases/fourslash/unusedParameterInLambda1.ts b/tests/cases/fourslash/unusedParameterInLambda1.ts
index 166d250fee7..a5f735c7016 100644
--- a/tests/cases/fourslash/unusedParameterInLambda1.ts
+++ b/tests/cases/fourslash/unusedParameterInLambda1.ts
@@ -6,4 +6,4 @@
 ////     [|return (x:number) => {}|]
 //// }
 
-verify.rangeAfterCodeFix("return () => {}");
+verify.rangeAfterCodeFix("return () => {}", /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 0);
diff --git a/tests/cases/fourslash/unusedParameterInLambda1AddUnderscore.ts b/tests/cases/fourslash/unusedParameterInLambda1AddUnderscore.ts
new file mode 100644
index 00000000000..916c32d82eb
--- /dev/null
+++ b/tests/cases/fourslash/unusedParameterInLambda1AddUnderscore.ts
@@ -0,0 +1,9 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+// @noUnusedParameters: true
+//// function f1() {
+////     [|return (x:number) => {} |]
+//// }
+
+verify.rangeAfterCodeFix("return (_x:number) => {}", /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 1);
diff --git a/tests/cases/fourslash/unusedVariableInForLoop5FS.ts b/tests/cases/fourslash/unusedVariableInForLoop5FS.ts
deleted file mode 100644
index 23df03480e3..00000000000
--- a/tests/cases/fourslash/unusedVariableInForLoop5FS.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-/// <reference path='fourslash.ts' />
-
-// @noUnusedLocals: true
-//// function f1 () {
-////     for (const elem in ["a", "b", "c"]) {
-////
-////     }
-//// }
-
-verify.not.codeFixAvailable();
-
diff --git a/tests/cases/fourslash/unusedVariableInForLoop5FSAddUnderscore.ts b/tests/cases/fourslash/unusedVariableInForLoop5FSAddUnderscore.ts
new file mode 100644
index 00000000000..2948bfab207
--- /dev/null
+++ b/tests/cases/fourslash/unusedVariableInForLoop5FSAddUnderscore.ts
@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+//// function f1 () {
+////     [|for (const elem in ["a", "b", "c"]) |]{
+////
+////     }
+//// }
+
+verify.rangeAfterCodeFix(`for (const _elem in ["a", "b", "c"])`, /*includeWhiteSpace*/ true, /*errorCode*/ 0);
diff --git a/tests/cases/fourslash/unusedVariableInForLoop6FS.ts b/tests/cases/fourslash/unusedVariableInForLoop6FS.ts
index a7b8fbfb7c8..fa1948438bc 100644
--- a/tests/cases/fourslash/unusedVariableInForLoop6FS.ts
+++ b/tests/cases/fourslash/unusedVariableInForLoop6FS.ts
@@ -7,5 +7,5 @@
 ////     }
 //// }
 
-verify.rangeAfterCodeFix("const {} of ");
+verify.rangeAfterCodeFix("const {} of ", /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 0);
 
diff --git a/tests/cases/fourslash/unusedVariableInForLoop6FSAddUnderscore.ts b/tests/cases/fourslash/unusedVariableInForLoop6FSAddUnderscore.ts
new file mode 100644
index 00000000000..4faa6893b7f
--- /dev/null
+++ b/tests/cases/fourslash/unusedVariableInForLoop6FSAddUnderscore.ts
@@ -0,0 +1,11 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+//// function f1 () {
+////     for ([|const elem of |]["a", "b", "c"]) {
+////
+////     }
+//// }
+
+verify.rangeAfterCodeFix("const _elem of", /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 1);
+
diff --git a/tests/cases/fourslash/unusedVariableInModule4.ts b/tests/cases/fourslash/unusedVariableInModule4.ts
index 8f23d56b03c..6d80d59c2ce 100644
--- a/tests/cases/fourslash/unusedVariableInModule4.ts
+++ b/tests/cases/fourslash/unusedVariableInModule4.ts
@@ -7,4 +7,4 @@
 //// x;
 //// export var y: string;
 
-verify.rangeAfterCodeFix(`var x = function f1() {}`);
+verify.rangeAfterCodeFix(`var x = function f1() {}`, /*includeWhiteSpace*/ false, /*errorCode*/ undefined, /*index*/ 0);