microsoft
diff --git a/‎src/compiler/checker.ts
Copy file name to clipboard
+123-7Lines changed: 123 additions & 7 deletions b/‎src/compiler/checker.ts
Copy file name to clipboard
+123-7Lines changed: 123 additions & 7 deletions
diff --git a/‎src/compiler/commandLineParser.ts
Copy file name to clipboard
+10Lines changed: 10 additions & 0 deletions b/‎src/compiler/commandLineParser.ts
Copy file name to clipboard
+10Lines changed: 10 additions & 0 deletions
diff --git a/‎src/compiler/diagnosticMessages.json
Copy file name to clipboard
+12Lines changed: 12 additions & 0 deletions b/‎src/compiler/diagnosticMessages.json
Copy file name to clipboard
+12Lines changed: 12 additions & 0 deletions
diff --git a/‎src/compiler/types.ts
Copy file name to clipboard
+3Lines changed: 3 additions & 0 deletions b/‎src/compiler/types.ts
Copy file name to clipboard
+3Lines changed: 3 additions & 0 deletions
diff --git a/‎src/compiler/utilities.ts
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎src/compiler/utilities.ts
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎tests/baselines/reference/unusedClassesinModule1.errors.txt
Copy file name to clipboard
+13Lines changed: 13 additions & 0 deletions b/‎tests/baselines/reference/unusedClassesinModule1.errors.txt
Copy file name to clipboard
+13Lines changed: 13 additions & 0 deletions
diff --git a/‎tests/baselines/reference/unusedClassesinModule1.js
Copy file name to clipboard
+20Lines changed: 20 additions & 0 deletions b/‎tests/baselines/reference/unusedClassesinModule1.js
Copy file name to clipboard
+20Lines changed: 20 additions & 0 deletions
diff --git a/‎tests/baselines/reference/unusedClassesinNamespace1.errors.txt
Copy file name to clipboard
+12Lines changed: 12 additions & 0 deletions b/‎tests/baselines/reference/unusedClassesinNamespace1.errors.txt
Copy file name to clipboard
+12Lines changed: 12 additions & 0 deletions
diff --git a/‎tests/baselines/reference/unusedClassesinNamespace1.js
Copy file name to clipboard
+17Lines changed: 17 additions & 0 deletions b/‎tests/baselines/reference/unusedClassesinNamespace1.js
Copy file name to clipboard
+17Lines changed: 17 additions & 0 deletions
diff --git a/‎tests/baselines/reference/unusedClassesinNamespace2.errors.txt
Copy file name to clipboard
+16Lines changed: 16 additions & 0 deletions b/‎tests/baselines/reference/unusedClassesinNamespace2.errors.txt
Copy file name to clipboard
+16Lines changed: 16 additions & 0 deletions
@@ -8310,8 +8310,21 @@ namespace ts {
             return container === declarationContainer;
         }
 
+        function updateReferencesForInterfaceHeritiageClauseTargets(node: InterfaceDeclaration): void {
+            const extendedTypeNode = getClassExtendsHeritageClauseElement(node);
+            if (extendedTypeNode) {
+                const t = getTypeFromTypeNode(extendedTypeNode);
+                if (t !== unknownType && t.symbol && (compilerOptions.noUnusedLocals || compilerOptions.noUnusedParameters) && !isInAmbientContext(node)) {
+                    t.symbol.hasReference = true;
+                }
+            }
+        }
+
         function checkIdentifier(node: Identifier): Type {
             const symbol = getResolvedSymbol(node);
+            if (symbol && (compilerOptions.noUnusedLocals || compilerOptions.noUnusedParameters) && !isInAmbientContext(node)) {
+                symbol.hasReference = true;
+            }
 
             // As noted in ECMAScript 6 language spec, arrow functions never have an arguments objects.
             // Although in down-level emit of arrow function, we emit it using function expression which means that
@@ -10226,6 +10239,10 @@ namespace ts {
                 return unknownType;
             }
 
+            if ((compilerOptions.noUnusedLocals || compilerOptions.noUnusedParameters) && !isInAmbientContext(node)) {
+                prop.hasReference = true;
+            }
+
             getNodeLinks(node).resolvedSymbol = prop;
 
             if (prop.parent && prop.parent.flags & SymbolFlags.Class) {
@@ -12168,6 +12185,8 @@ namespace ts {
                         }
                     }
                 }
+                checkUnusedIdentifiers(node);
+                checkUnusedTypeParameters(node);
             }
         }
 
@@ -13238,6 +13257,9 @@ namespace ts {
                         checkAsyncFunctionReturnType(<FunctionLikeDeclaration>node);
                     }
                 }
+                if (!(<FunctionDeclaration>node).body) {
+                    checkUnusedTypeParameters(node);
+                }
             }
         }
 
@@ -13390,6 +13412,8 @@ namespace ts {
             checkGrammarConstructorTypeParameters(node) || checkGrammarConstructorTypeAnnotation(node);
 
             checkSourceElement(node.body);
+            checkUnusedIdentifiers(node);
+            checkUnusedTypeParameters(node);
 
             const symbol = getSymbolOfNode(node);
             const firstDeclaration = getDeclarationOfKind(symbol, node.kind);
@@ -13582,13 +13606,18 @@ namespace ts {
         function checkTypeReferenceNode(node: TypeReferenceNode | ExpressionWithTypeArguments) {
             checkGrammarTypeArguments(node, node.typeArguments);
             const type = getTypeFromTypeReference(node);
-            if (type !== unknownType && node.typeArguments) {
-                // Do type argument local checks only if referenced type is successfully resolved
-                forEach(node.typeArguments, checkSourceElement);
-                if (produceDiagnostics) {
-                    const symbol = getNodeLinks(node).resolvedSymbol;
-                    const typeParameters = symbol.flags & SymbolFlags.TypeAlias ? getSymbolLinks(symbol).typeParameters : (<TypeReference>type).target.localTypeParameters;
-                    checkTypeArgumentConstraints(typeParameters, node.typeArguments);
+            if (type !== unknownType) {
+                if (type.symbol && (compilerOptions.noUnusedLocals || compilerOptions.noUnusedParameters) && !isInAmbientContext(node)) {
+                    type.symbol.hasReference = true;
+                }
+                if (node.typeArguments) {
+                    // Do type argument local checks only if referenced type is successfully resolved
+                    forEach(node.typeArguments, checkSourceElement);
+                    if (produceDiagnostics) {
+                        const symbol = getNodeLinks(node).resolvedSymbol;
+                        const typeParameters = symbol.flags & SymbolFlags.TypeAlias ? getSymbolLinks(symbol).typeParameters : (<TypeReference>type).target.localTypeParameters;
+                        checkTypeArgumentConstraints(typeParameters, node.typeArguments);
+                    }
                 }
             }
         }
@@ -14431,6 +14460,8 @@ namespace ts {
             }
 
             checkSourceElement(node.body);
+            checkUnusedIdentifiers(node);
+            checkUnusedTypeParameters(node);
             if (!node.asteriskToken) {
                 const returnOrPromisedType = node.type && (isAsync ? checkAsyncFunctionReturnType(node) : getTypeFromTypeNode(node.type));
                 checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrPromisedType);
@@ -14452,12 +14483,83 @@ namespace ts {
             }
         }
 
+        function checkUnusedIdentifiers(node: FunctionDeclaration | MethodDeclaration | ConstructorDeclaration | FunctionExpression | ArrowFunction | ForInStatement | Block | CatchClause): void {
+            if (node.parent.kind !== SyntaxKind.InterfaceDeclaration && (compilerOptions.noUnusedLocals || compilerOptions.noUnusedParameters) && !isInAmbientContext(node)) {
+                for (const key in node.locals) {
+                    if (hasProperty(node.locals, key)) {
+                        const local = node.locals[key];
+                        if (!local.hasReference && local.valueDeclaration) {
+                            if (local.valueDeclaration.kind !== SyntaxKind.Parameter && compilerOptions.noUnusedLocals) {
+                                error(local.valueDeclaration.name, Diagnostics._0_is_declared_but_never_used, local.name);
+                            }
+                            else if (local.valueDeclaration.kind === SyntaxKind.Parameter && compilerOptions.noUnusedParameters) {
+                                if (local.valueDeclaration.flags === 0) {
+                                    error(local.valueDeclaration.name, Diagnostics._0_is_declared_but_never_used, local.name);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        function checkUnusedClassLocals(node: ClassDeclaration): void {
+            if (compilerOptions.noUnusedLocals && !isInAmbientContext(node)) {
+                if (node.members) {
+                    for (const member of node.members) {
+                        if (member.kind === SyntaxKind.MethodDeclaration || member.kind === SyntaxKind.PropertyDeclaration) {
+                            if (isPrivateNode(member) && !member.symbol.hasReference) {
+                                error(member.name, Diagnostics._0_is_declared_but_never_used, member.symbol.name);
+                            }
+                        }
+                        else if (member.kind === SyntaxKind.Constructor) {
+                            for (const parameter of (<ConstructorDeclaration>member).parameters) {
+                                if (isPrivateNode(parameter) && !parameter.symbol.hasReference) {
+                                    error(parameter.name, Diagnostics._0_is_declared_but_never_used, parameter.symbol.name);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        function checkUnusedTypeParameters(node: ClassDeclaration | FunctionDeclaration | MethodDeclaration | FunctionExpression | ArrowFunction | ConstructorDeclaration | SignatureDeclaration | InterfaceDeclaration) {
+            if (compilerOptions.noUnusedLocals && !isInAmbientContext(node)) {
+                if (node.typeParameters) {
+                    for (const typeParameter of node.typeParameters) {
+                        if (!typeParameter.symbol.hasReference) {
+                            error(typeParameter.name, Diagnostics._0_is_declared_but_never_used, typeParameter.symbol.name);
+                        }
+                    }
+                }
+            }
+        }
+
+        function isPrivateNode(node: Node): boolean {
+            return (node.flags & NodeFlags.Private) !== 0;
+        }
+
+        function checkUnusedModuleLocals(node: ModuleDeclaration | SourceFile): void {
+            if (compilerOptions.noUnusedLocals && !isInAmbientContext(node)) {
+                for (const key in node.locals) {
+                    if (hasProperty(node.locals, key)) {
+                        const local = node.locals[key];
+                        if (!local.hasReference && !local.exportSymbol) {
+                            forEach(local.declarations, d => error(d.name, Diagnostics._0_is_declared_but_never_used, local.name));
+                        }
+                    }
+                }
+            }
+        }
+
         function checkBlock(node: Block) {
             // Grammar checking for SyntaxKind.Block
             if (node.kind === SyntaxKind.Block) {
                 checkGrammarStatementInAmbientContext(node);
             }
             forEach(node.statements, checkSourceElement);
+            checkUnusedIdentifiers(node);
         }
 
         function checkCollisionWithArgumentsInGeneratedCode(node: SignatureDeclaration) {
@@ -14962,6 +15064,7 @@ namespace ts {
             }
 
             checkSourceElement(node.statement);
+            checkUnusedIdentifiers(node);
         }
 
         function checkForInStatement(node: ForInStatement) {
@@ -15009,6 +15112,7 @@ namespace ts {
             }
 
             checkSourceElement(node.statement);
+            checkUnusedIdentifiers(node);
         }
 
         function checkForInOrForOfVariableDeclaration(iterationStatement: ForInStatement | ForOfStatement): void {
@@ -15448,6 +15552,7 @@ namespace ts {
                 }
 
                 checkBlock(catchClause.block);
+                checkUnusedIdentifiers(catchClause);
             }
 
             if (node.finallyBlock) {
@@ -15609,6 +15714,8 @@ namespace ts {
             }
             checkClassLikeDeclaration(node);
             forEach(node.members, checkSourceElement);
+            checkUnusedClassLocals(node);
+            checkUnusedTypeParameters(node);
         }
 
         function checkClassLikeDeclaration(node: ClassLikeDeclaration) {
@@ -15918,6 +16025,8 @@ namespace ts {
 
             if (produceDiagnostics) {
                 checkTypeForDuplicateIndexSignatures(node);
+                updateReferencesForInterfaceHeritiageClauseTargets(node);
+                checkUnusedTypeParameters(node);
             }
         }
 
@@ -16314,6 +16423,7 @@ namespace ts {
 
             if (node.body) {
                 checkSourceElement(node.body);
+                checkUnusedModuleLocals(node);
             }
         }
 
@@ -16494,6 +16604,9 @@ namespace ts {
                         if (target.flags & SymbolFlags.Type) {
                             checkTypeNameIsReserved(node.name, Diagnostics.Import_name_cannot_be_0);
                         }
+                        if ((compilerOptions.noUnusedLocals || compilerOptions.noUnusedParameters) && !isInAmbientContext(node)) {
+                            target.hasReference = true;
+                        }
                     }
                 }
                 else {
@@ -16836,6 +16949,9 @@ namespace ts {
 
                 deferredNodes = [];
                 forEach(node.statements, checkSourceElement);
+                if (isExternalModule(node)) {
+                    checkUnusedModuleLocals(node);
+                }
                 checkDeferredNodes();
                 deferredNodes = undefined;
 
 
@@ -132,6 +132,16 @@ namespace ts {
             type: "boolean",
             description: Diagnostics.Raise_error_on_this_expressions_with_an_implied_any_type,
         },
+        {
+            name: "noUnusedLocals",
+            type: "boolean",
+            description: Diagnostics.Report_Errors_on_Unused_Locals,
+        },
+        {
+            name: "noUnusedParameters",
+            type: "boolean",
+            description: Diagnostics.Report_Errors_on_Unused_Parameters
+        },
         {
             name: "noLib",
             type: "boolean",
 
@@ -2792,6 +2792,18 @@
         "category": "Message",
         "code": 6132
     },
+    "'{0}' is declared but never used.": {
+        "category": "Error",
+        "code": 6133
+    },
+    "Report Errors on Unused Locals.": {
+        "category": "Message",
+        "code": 6134
+    },
+    "Report Errors on Unused Parameters.": {
+        "category": "Message",
+        "code": 6135
+    },
 
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
 
@@ -2127,6 +2127,7 @@ namespace ts {
         /* @internal */ parent?: Symbol;        // Parent symbol
         /* @internal */ exportSymbol?: Symbol;  // Exported symbol associated with this symbol
         /* @internal */ constEnumOnlyModule?: boolean; // True if module contains only const enums or other modules with only const enums
+        /* @internal */ hasReference?: boolean; // True if the symbol is referenced elsewhere
     }
 
     /* @internal */
@@ -2557,6 +2558,8 @@ namespace ts {
         noImplicitAny?: boolean;
         noImplicitReturns?: boolean;
         noImplicitThis?: boolean;
+        noUnusedLocals?: boolean;
+        noUnusedParameters?: boolean;
         noImplicitUseStrict?: boolean;
         noLib?: boolean;
         noResolve?: boolean;
 
@@ -1702,7 +1702,7 @@ namespace ts {
             node.kind === SyntaxKind.ExportAssignment && (<ExportAssignment>node).expression.kind === SyntaxKind.Identifier;
     }
 
-    export function getClassExtendsHeritageClauseElement(node: ClassLikeDeclaration) {
+    export function getClassExtendsHeritageClauseElement(node: ClassLikeDeclaration | InterfaceDeclaration) {
         const heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ExtendsKeyword);
         return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined;
     }
 
@@ -0,0 +1,13 @@
+tests/cases/compiler/unusedClassesinModule1.ts(3,11): error TS6133: 'Calculator' is declared but never used.
+
+
+==== tests/cases/compiler/unusedClassesinModule1.ts (1 errors) ====
+    
+    module A {
+        class Calculator {
+              ~~~~~~~~~~
+!!! error TS6133: 'Calculator' is declared but never used.
+            public handelChar() {
+            }
+        }
+    }
@@ -0,0 +1,20 @@
+//// [unusedClassesinModule1.ts]
+
+module A {
+    class Calculator {
+        public handelChar() {
+        }
+    }
+}
+
+//// [unusedClassesinModule1.js]
+var A;
+(function (A) {
+    var Calculator = (function () {
+        function Calculator() {
+        }
+        Calculator.prototype.handelChar = function () {
+        };
+        return Calculator;
+    }());
+})(A || (A = {}));
@@ -0,0 +1,12 @@
+tests/cases/compiler/unusedClassesinNamespace1.ts(3,11): error TS6133: 'c1' is declared but never used.
+
+
+==== tests/cases/compiler/unusedClassesinNamespace1.ts (1 errors) ====
+    
+    namespace Validation {
+        class c1 {
+              ~~
+!!! error TS6133: 'c1' is declared but never used.
+    
+        }
+    }
@@ -0,0 +1,17 @@
+//// [unusedClassesinNamespace1.ts]
+
+namespace Validation {
+    class c1 {
+
+    }
+}
+
+//// [unusedClassesinNamespace1.js]
+var Validation;
+(function (Validation) {
+    var c1 = (function () {
+        function c1() {
+        }
+        return c1;
+    }());
+})(Validation || (Validation = {}));
@@ -0,0 +1,16 @@
+tests/cases/compiler/unusedClassesinNamespace2.ts(3,11): error TS6133: 'c1' is declared but never used.
+
+
+==== tests/cases/compiler/unusedClassesinNamespace2.ts (1 errors) ====
+    
+    namespace Validation {
+        class c1 {
+              ~~
+!!! error TS6133: 'c1' is declared but never used.
+    
+        }
+    
+        export class c2 {
+    
+        }
+    }
Original file line number	Diff line number	Diff line change
`@@ -1702,7 +1702,7 @@ namespace ts {`
`1702`	`1702`	`node.kind === SyntaxKind.ExportAssignment && (<ExportAssignment>node).expression.kind === SyntaxKind.Identifier;`
`1703`	`1703`	`}`
`1704`	`1704`
`1705`		`- export function getClassExtendsHeritageClauseElement(node: ClassLikeDeclaration) {`
	`1705`	`+ export function getClassExtendsHeritageClauseElement(node: ClassLikeDeclaration \| InterfaceDeclaration) {`
`1706`	`1706`	`const heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ExtendsKeyword);`
`1707`	`1707`	`return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined;`
`1708`	`1708`	`}`