From a1877ef336c23459f6326f0f3e488820dc3ab571 Mon Sep 17 00:00:00 2001
From: Arthur Ozga <aozgaa@umich.edu>
Date: Wed, 1 Jul 2015 10:46:10 -0700
Subject: [PATCH] fexed comment and initialization

---
 src/compiler/checker.ts | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 5bf0488e6a8..5c5cc36f5ce 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -3734,12 +3734,12 @@ namespace ts {
                 // We only support expressions that are simple qualified names. For other expressions this produces undefined.
                 let typeNameOrExpression = node.kind === SyntaxKind.TypeReference ? (<TypeReferenceNode>node).typeName :
                     isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node) ? (<ExpressionWithTypeArguments>node).expression :
-                        undefined;
+                    undefined;
                 let symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, SymbolFlags.Type) || unknownSymbol;
                 let type = symbol === unknownSymbol ? unknownType :
                     symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) ? getTypeFromClassOrInterfaceReference(node, symbol) :
-                        symbol.flags & SymbolFlags.TypeAlias ? getTypeFromTypeAliasReference(node, symbol) :
-                            getTypeFromNonGenericTypeReference(node, symbol);
+                    symbol.flags & SymbolFlags.TypeAlias ? getTypeFromTypeAliasReference(node, symbol) :
+                    getTypeFromNonGenericTypeReference(node, symbol);
                 // Cache both the resolved symbol and the resolved type. The resolved symbol is needed in when we check the
                 // type reference in checkTypeReferenceOrExpressionWithTypeArguments.
                 links.resolvedSymbol = symbol;
@@ -4641,8 +4641,6 @@ namespace ts {
                     let sourceProp = getPropertyOfType(source, targetProp.name);
 
                     if (sourceProp !== targetProp) {
-                        // sourceProp !== targetProp -- ie: source and target have distinct declarations with the same name
-                        
                         if (!sourceProp) {
                             if (!(targetProp.flags & SymbolFlags.Optional) || requireOptionalProperties) {
                                 if (reportErrors) {
@@ -7216,7 +7214,7 @@ namespace ts {
                 }
 
                 if (flags & NodeFlags.Abstract) {
-                    // A method cannot be accessed in a super call if the method is abstract.
+                    // A method cannot be accessed in a super property access if the method is abstract.
                     // This error could mask a private property access error. But, a member 
                     // cannot simultaneously be private and abstract, so this will trigger an
                     // additional error elsewhere.