diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 085895f3387..887c77d5131 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -2257,7 +2257,7 @@ namespace ts {
         getNonNullableType(type: Type): Type;
         getIntersectionType(types: Type[], aliasSymbol?: Symbol, aliasTypeArguments?: Type[]): Type;
         getUnionType(types: Type[], subtypeReduction?: boolean, aliasSymbol?: Symbol, aliasTypeArguments?: Type[]): Type;
-        
+
         getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
         getSymbolOfNode(node: Node): Symbol;
         getSymbolAtLocation(node: Node): Symbol;
diff --git a/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts b/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts
index 23b10fc91ba..3e501ccbcff 100644
--- a/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts
+++ b/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts
@@ -8,7 +8,7 @@ namespace ts.codefix {
             const token = getTokenAtPosition(sourceFile, start);
             const checker = context.program.getTypeChecker();
 
-            if (token.kind === SyntaxKind.Identifier &&  isClassLike(token.parent)) {
+            if (token.kind === SyntaxKind.Identifier && isClassLike(token.parent)) {
                 const classDeclaration = <ClassDeclaration>token.parent;
                 const startPos = classDeclaration.members.pos;
                 // const abstractClassMembers = ts.map(getNamedAbstractClassMembers(classDeclaration), member => member.name.getText());
@@ -22,9 +22,9 @@ namespace ts.codefix {
                         changes: [{
                             fileName: sourceFile.fileName,
                             textChanges: [{
-                                    span: {start: startPos, length: 0},
-                                    newText: insertion
-                                }]
+                                span: { start: startPos, length: 0 },
+                                newText: insertion
+                            }]
                         }]
                     }];
                 }
diff --git a/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts b/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts
index 940452b687f..e935dd55607 100644
--- a/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts
+++ b/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts
@@ -14,7 +14,7 @@ namespace ts.codefix {
 
                 const insertion = getMissingInterfaceMembersInsertion(classDeclaration, checker, context.newLineCharacter);
 
-                if(insertion && insertion.length) {
+                if (insertion && insertion.length) {
                     return [{
                         description: getLocaleSpecificMessage(Diagnostics.Implement_interface_on_class),
                         changes: [{
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
index 7e5a8c78c98..95794e3aaee 100644
--- a/src/services/utilities.ts
+++ b/src/services/utilities.ts
@@ -1364,22 +1364,12 @@ namespace ts {
         if (!baseTypeNode) {
             return "";
         }
-        
+
         const classSymbol = checker.getSymbolOfNode(classDecl);
 
         const InstantiatedExtendsType = <InterfaceType>checker.getTypeFromTypeReference(getClassExtendsHeritageClauseElement(classDecl));
         const resolvedExtendsType = checker.resolveStructuredTypeMembers(InstantiatedExtendsType);
 
-        // TODO: (arozga) Should we use the above or this to get the type of the extended class?
-        /*
-        const classType = <InterfaceType>checker.getTypeOfSymbol(classSymbol);
-        let baseType = checker.getBaseTypes(classType)[0];
-        const resolvedBaseType = checker.resolveStructuredTypeMembers(baseType);
-        if (baseType.objectFlags & ObjectFlags.Reference) {
-            baseType = checker.getTypeFromTypeReference(<TypeReference>baseType);
-        }
-        */
-
         const missingMembers = filterMissingMembers(filterAbstract(filterNonPrivate(resolvedExtendsType.members)), classSymbol.members);
 
         return getInsertionsForMembers(missingMembers, classDecl, checker, newlineChar);
@@ -1394,14 +1384,14 @@ namespace ts {
         const classSymbol = checker.getSymbolOfNode(classDecl);
 
         let implementsIntersectionType: IntersectionType | InterfaceType;
-        if(implementedTypeNodes.length > 1) {
+        if (implementedTypeNodes.length > 1) {
             implementsIntersectionType = <IntersectionType>checker.getIntersectionType(implementedTypeNodes.map(checker.getTypeFromTypeReference));
         }
         else {
             implementsIntersectionType = <InterfaceType>checker.getTypeFromTypeReference(implementedTypeNodes[0]);
         }
 
-        const structuredType = checker.resolveStructuredTypeMembers(<IntersectionType | InterfaceType>implementsIntersectionType);        
+        const structuredType = checker.resolveStructuredTypeMembers(<IntersectionType | InterfaceType>implementsIntersectionType);
         const missingMembers = filterMissingMembers(filterNonPrivate(structuredType.members), classSymbol.members);
         return getInsertionsForMembers(missingMembers, classDecl, checker, newlineChar);
     }
@@ -1410,11 +1400,11 @@ namespace ts {
      * Finds the symbols in source but not target, generating a new map with the differences.
      */
     function filterMissingMembers(sourceSymbols: Map<Symbol>, targetSymbols: Map<Symbol>): Map<Symbol> {
-        let result: Map<Symbol> = createMap<Symbol>();
+        const result: Map<Symbol> = createMap<Symbol>();
         outer:
-        for(const sourceName in sourceSymbols) {
-            for(const targetName in targetSymbols) {
-                if(sourceName === targetName) {
+        for (const sourceName in sourceSymbols) {
+            for (const targetName in targetSymbols) {
+                if (sourceName === targetName) {
                     continue outer;
                 }
             }
@@ -1424,7 +1414,7 @@ namespace ts {
     }
 
     function filterSymbolMapByDecl(symbolMap: Map<Symbol>, pred: (decl: Declaration) => boolean): Map<Symbol> {
-        let result = createMap<Symbol>();
+        const result = createMap<Symbol>();
         for (const key in symbolMap) {
             const decl = symbolMap[key].getDeclarations();
             Debug.assert(!!(decl && decl.length));
@@ -1436,8 +1426,6 @@ namespace ts {
     }
 
     function filterAbstract(symbolMap: Map<Symbol>) {
-        // TODO: (arozga) use first or second?
-        // return mapObject(symbolMap, (key, val) => getModifierFlags(val.getDeclarations()[0]) & ModifierFlags.Abstract ? [key, val]: [undefined, undefined] );
         return filterSymbolMapByDecl(symbolMap, decl => !!(getModifierFlags(decl) & ModifierFlags.Abstract));
     }
 
@@ -1447,7 +1435,7 @@ namespace ts {
 
     function getInsertionsForMembers(symbolMap: MapLike<Symbol>, enclosingDeclaration: ClassDeclaration, checker: TypeChecker, newlineChar: string): string {
         let insertion = "";
-        
+
         for (const symbolName in symbolMap) {
             insertion = insertion.concat(getInsertionForMemberSymbol(symbolMap[symbolName], enclosingDeclaration, checker, newlineChar));
         }
@@ -1455,9 +1443,9 @@ namespace ts {
     }
 
     function getInsertionForMemberSymbol(symbol: Symbol, enclosingDeclaration: ClassDeclaration, checker: TypeChecker, newlineChar: string): string {
-       const name = symbol.getName();
-       const type = checker.getTypeOfSymbol(symbol);
-        
+        const name = symbol.getName();
+        const type = checker.getTypeOfSymbol(symbol);
+
         const decls = symbol.getDeclarations();
         if (!(decls && decls.length)) {
             return "";
@@ -1473,7 +1461,7 @@ namespace ts {
             case SyntaxKind.MethodSignature:
             case SyntaxKind.MethodDeclaration:
                 const sigs = checker.getSignaturesOfType(type, SignatureKind.Call);
-                if(!(sigs && sigs.length > 0)) {
+                if (!(sigs && sigs.length > 0)) {
                     return "";
                 }
                 // TODO: (arozga) Deal with multiple signatures.
@@ -1489,20 +1477,6 @@ namespace ts {
         return `{${newLineChar}throw new Error('Method not Implemented');${newLineChar}}${newLineChar}`;
     }
 
-    /**
-     * Flattens params into a comma-separated list, sandwiched by prefix
-     * and suffix on either end.
-     */
-    /*
-    function getCommaSeparatedString(params: string[], prefix: string, suffix: string) {
-        let result = prefix;
-        for (let i = 0; params && i < params.length; ++i) {
-            result += (i > 0 ? "," : "") + params[i];
-        }
-        return result + suffix;
-    }
-    */
-
     function getVisibilityPrefix(flags: ModifierFlags): string {
         if (flags & ModifierFlags.Public) {
             return "public ";
@@ -1517,4 +1491,4 @@ namespace ts {
         // First token is the open curly, this is where we want to put the 'super' call.
         return constructor.body.getFirstToken(sourceFile).getEnd();
     }
-}
+}
\ No newline at end of file