Merge pull request #626 from Microsoft/typoscript

Corrected some spelling/grammar issues.

Author: DanielRosenwasser

src/compiler/checker.ts

@@ -24,9 +24,9 @@ module ts {
     }
 
     /// fullTypeCheck denotes if this instance of the typechecker will be used to get semantic diagnostics.
-    /// If fullTypeCheck === true - then typechecker should do every possible check to produce all errors
-    /// If fullTypeCheck === false - typechecker can shortcut and skip checks that only produce errors.
-    /// NOTE: checks that somehow affects decisions being made during typechecking should be executed in both cases.
+    /// If fullTypeCheck === true,  then the typechecker should do every possible check to produce all errors
+    /// If fullTypeCheck === false, the typechecker can take shortcuts and skip checks that only produce errors.
+    /// NOTE: checks that somehow affect decisions being made during typechecking should be executed in both cases.
     export function createTypeChecker(program: Program, fullTypeCheck: boolean): TypeChecker {
 
         var Symbol = objectAllocator.getSymbolConstructor();
@@ -573,7 +573,7 @@ module ts {
                 return (resolveImport(symbol).flags & SymbolFlags.Value) !== 0;
             }
 
-            // If it is an instantiated symbol, then it is a value if hte symbol it is an 
+            // If it is an instantiated symbol, then it is a value if the symbol it is an
             // instantiation of is a value.
             if (symbol.flags & SymbolFlags.Instantiated) {
                 return (getSymbolLinks(symbol).target.flags & SymbolFlags.Value) !== 0;
@@ -697,7 +697,7 @@ module ts {
         function getAccessibleSymbolChain(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): Symbol[] {
             function getAccessibleSymbolChainFromSymbolTable(symbols: SymbolTable): Symbol[] {
                 function canQualifySymbol(symbolFromSymbolTable: Symbol, meaning: SymbolFlags) {
-                    // If the symbol is equivalent and doesnt need futher qualification, this symbol is accessible
+                    // If the symbol is equivalent and doesn't need further qualification, this symbol is accessible
                     if (!needsQualification(symbolFromSymbolTable, enclosingDeclaration, meaning)) {
                         return true;
                     }
@@ -793,17 +793,17 @@ module ts {
                         return { accessibility: SymbolAccessibility.Accessible, aliasesToMakeVisible: hasAccessibleDeclarations.aliasesToMakeVisible };
                     }
 
-                    // If we havent got the accessible symbol doesnt mean the symbol is actually inaccessible. 
-                    // It could be qualified symbol and hence verify the path
-                    // eg:
+                    // If we haven't got the accessible symbol, it doesn't mean the symbol is actually inaccessible.
+                    // It could be a qualified symbol and hence verify the path
+                    // e.g.:
                     // module m {
                     //     export class c {
                     //     }
                     // }
                     // var x: typeof m.c
                     // In the above example when we start with checking if typeof m.c symbol is accessible,
                     // we are going to see if c can be accessed in scope directly. 
-                    // But it cant, hence the accessible is going to be undefined, but that doesnt mean m.c is accessible
+                    // But it can't, hence the accessible is going to be undefined, but that doesn't mean m.c is inaccessible
                     // It is accessible if the parent m is accessible because then m.c can be accessed through qualification
                     meaningToLook = getQualifiedLeftMeaning(meaning);
                     symbol = getParentOfSymbol(symbol);
@@ -815,7 +815,7 @@ module ts {
                 if (symbolExternalModule) {
                     var enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration);
                     if (symbolExternalModule !== enclosingExternalModule) {
-                        // name from different external module that is not visibile
+                        // name from different external module that is not visible
                         return {
                             accessibility: SymbolAccessibility.CannotBeNamed,
                             errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning),
@@ -892,7 +892,7 @@ module ts {
                 { accessibility: SymbolAccessibility.NotAccessible, errorSymbolName: firstIdentifierName };
         }
 
-        // Enclosing declaration is optional when we dont want to get qualified name in the enclosing declaration scope
+        // Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
         // Meaning needs to be specified if the enclosing declaration is given
         function symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) {
             function getSymbolName(symbol: Symbol) {
@@ -919,7 +919,7 @@ module ts {
                         currentSymbolName = ts.map(accessibleSymbolChain, accessibleSymbol => getSymbolName(accessibleSymbol)).join(".");
                     }
                     else {
-                        // If we didnt find accessible symbol chain for this symbol, break if this is external module
+                        // If we didn't find accessible symbol chain for this symbol, break if this is external module
                         if (!isFirstName && ts.forEach(symbol.declarations, declaration => hasExternalModuleSymbol(declaration))) {
                             break;
                         }
@@ -991,7 +991,7 @@ module ts {
             function writeTypeReference(type: TypeReference) {
                 if (type.target === globalArrayType && !(flags & TypeFormatFlags.WriteArrayAsGenericType)) {
                     // If we are writing array element type the arrow style signatures are not allowed as 
-                    // we need to surround it by curlies, eg. { (): T; }[]; as () => T[] would mean something different
+                    // we need to surround it by curlies, e.g. { (): T; }[]; as () => T[] would mean something different
                     writeType(type.typeArguments[0], /*allowFunctionOrConstructorTypeLiteral*/ false);
                     writer.write("[]");
                 }
@@ -1244,7 +1244,7 @@ module ts {
                             !(node.kind !== SyntaxKind.ImportDeclaration && parent.kind !== SyntaxKind.SourceFile && isInAmbientContext(parent))) {
                             return isGlobalSourceFile(parent) || isUsedInExportAssignment(node);
                         }
-                        // Exported members/ambient module elements (exception import declaraiton) are visible if parent is visible
+                        // Exported members/ambient module elements (exception import declaration) are visible if parent is visible
                         return isDeclarationVisible(parent);
 
                     case SyntaxKind.Property:
@@ -4032,7 +4032,7 @@ module ts {
                     }
                     else {
                         // current declaration belongs to a different symbol
-                        // set cutoffPos so reorderings in the future won't change result set from 0 to cutoffPos
+                        // set cutoffPos so re-orderings in the future won't change result set from 0 to cutoffPos
                         pos = cutoffPos = result.length;
                         lastParent = parent;
                     }
@@ -4782,7 +4782,7 @@ module ts {
                     var ok = checkReferenceExpression(node.left, Diagnostics.Invalid_left_hand_side_of_assignment_expression);
                     // Use default messages
                     if (ok) {
-                        // to avoid cascading errors check assignability only if 'isReference' check succeded and no errors were reported
+                        // to avoid cascading errors check assignability only if 'isReference' check succeeded and no errors were reported
                         checkTypeAssignableTo(valueType, leftType, node.left, /*chainedMessage*/ undefined, /*terminalMessage*/ undefined);
                     }
                 }
@@ -4828,7 +4828,7 @@ module ts {
         // Checks an expression and returns its type. The contextualMapper parameter serves two purposes: When
         // contextualMapper is not undefined and not equal to the identityMapper function object it indicates that the
         // expression is being inferentially typed (section 4.12.2 in spec) and provides the type mapper to use in
-        // conjuction with the generic contextual type. When contextualMapper is equal to the identityMapper function
+        // conjunction with the generic contextual type. When contextualMapper is equal to the identityMapper function
         // object, it serves as an indicator that all contained function and arrow expressions should be considered to
         // have the wildcard function type; this form of type check is used during overload resolution to exclude
         // contextually typed function and arrow expressions in the initial phase.
@@ -4933,7 +4933,7 @@ module ts {
                                 // legal case - parameter initializer references some parameter strictly on left of current parameter declaration
                                 return;
                             }
-                            // fallthrough to error reporting
+                            // fall through to error reporting
                         }
 
                         error(n, Diagnostics.Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it, identifierToString(parameterDeclaration.name), identifierToString(<Identifier>n));
@@ -5325,7 +5325,7 @@ module ts {
             }
 
             // when checking exported function declarations across modules check only duplicate implementations
-            // names and consistensy of modifiers are verified when we check local symbol
+            // names and consistency of modifiers are verified when we check local symbol
             var isExportSymbolInsideModule = symbol.parent && symbol.parent.flags & SymbolFlags.Module;
             for (var i = 0; i < declarations.length; i++) {
                 var node = <FunctionDeclaration>declarations[i];
@@ -5421,7 +5421,7 @@ module ts {
             var symbol: Symbol;
 
             // Exports should be checked only if enclosing module contains both exported and non exported declarations.
-            // In case if all declarations are non-exported check is unnecesary.
+            // In case if all declarations are non-exported check is unnecessary.
 
             // if localSymbol is defined on node then node itself is exported - check is required
             var symbol = node.localSymbol;
@@ -5866,7 +5866,7 @@ module ts {
                             checkTypeAssignableTo(checkExpression(node.expression), returnType, node.expression, /*chainedMessage*/ undefined, /*terminalMessage*/ undefined);
                         }
                         else if (func.kind == SyntaxKind.Constructor) {
-                            // constructor doesn't have explicit return type annontation and yet its return type is known - declaring type
+                            // constructor doesn't have explicit return type annotation and yet its return type is known - declaring type
                             // handle constructors and issue specialized error message for them.
                             if (!isTypeAssignableTo(checkExpression(node.expression), returnType)) {
                                 error(node.expression, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
@@ -6113,7 +6113,7 @@ module ts {
                     }
 
                     if ((base.flags & derived.flags & SymbolFlags.Method) || ((base.flags & SymbolFlags.PropertyOrAccessor) && (derived.flags & SymbolFlags.PropertyOrAccessor))) {
-                        // method is overridden with method or property\accessor is overridden with property\accessor - correct case
+                        // method is overridden with method or property/accessor is overridden with property/accessor - correct case
                         continue;
                     }
 
@@ -6965,7 +6965,7 @@ module ts {
                         return moduleType ? moduleType.symbol : undefined;
                     }
 
-                // Intentinal fallthrough
+                // Intentional fall-through
                 case SyntaxKind.NumericLiteral:
                     // index access
                     if (node.parent.kind == SyntaxKind.IndexedAccess && (<IndexedAccess>node.parent).index === node) {
@@ -7030,7 +7030,7 @@ module ts {
             var apparentType = getApparentType(type);
 
             if (apparentType.flags & TypeFlags.ObjectType) {
-                // Augment the apprent type with Function and Object memeber as applicaple
+                // Augment the apparent type with Function and Object members as applicable
                 var propertiesByName: Map<Symbol> = {};
                 var results: Symbol[] = [];
 
@@ -7187,17 +7187,17 @@ module ts {
                 var symbol = getSymbolOfNode(node);
                 var signaturesOfSymbol = getSignaturesOfSymbol(symbol);
                 // If this function body corresponds to function with multiple signature, it is implementation of overload
-                // eg: function foo(a: string): string;
-                //     function foo(a: number): number;
-                //     function foo(a: any) { // This is implementation of the overloads
-                //         return a;
-                //     }
+                // e.g.: function foo(a: string): string;
+                //       function foo(a: number): number;
+                //       function foo(a: any) { // This is implementation of the overloads
+                //           return a;
+                //       }
                 return signaturesOfSymbol.length > 1 ||
-                    // If there is single signature for the symbol, it is overload if that signature isnt coming from the node
-                    // eg: function foo(a: string): string;
-                    //     function foo(a: any) { // This is implementation of the overloads
-                    //         return a;
-                    //     }
+                    // If there is single signature for the symbol, it is overload if that signature isn't coming from the node
+                    // e.g.: function foo(a: string): string;
+                    //       function foo(a: any) { // This is implementation of the overloads
+                    //           return a;
+                    //       }
                     (signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node);
             }
             return false;