mirror of
https://github.com/microsoft/TypeScript.git
synced 2026-02-04 21:53:42 -06:00
Merge pull request #626 from Microsoft/typoscript
Corrected some spelling/grammar issues.
This commit is contained in:
Daniel Rosenwasser
commit
66e509fd5f
@ -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,9 +793,9 @@ 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 {
|
||||
// }
|
||||
@ -803,7 +803,7 @@ module ts {
|
||||
// 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;
|
||||
|
||||
@ -266,7 +266,7 @@ module ts {
|
||||
}
|
||||
}
|
||||
else {
|
||||
// Single line comment of styly //....
|
||||
// Single line comment of style //....
|
||||
writer.write(currentSourceFile.text.substring(comment.pos, comment.end));
|
||||
}
|
||||
|
||||
@ -393,7 +393,7 @@ module ts {
|
||||
}
|
||||
|
||||
var prevEncodedEmittedColumn = lastEncodedSourceMapSpan.emittedColumn;
|
||||
// Line/Comma deliminators
|
||||
// Line/Comma delimiters
|
||||
if (lastEncodedSourceMapSpan.emittedLine == lastRecordedSourceMapSpan.emittedLine) {
|
||||
// Emit comma to separate the entry
|
||||
if (sourceMapData.sourceMapMappings) {
|
||||
@ -401,7 +401,7 @@ module ts {
|
||||
}
|
||||
}
|
||||
else {
|
||||
// Emit line deliminators
|
||||
// Emit line delimiters
|
||||
for (var encodedLine = lastEncodedSourceMapSpan.emittedLine; encodedLine < lastRecordedSourceMapSpan.emittedLine; encodedLine++) {
|
||||
sourceMapData.sourceMapMappings += ";";
|
||||
}
|
||||
@ -470,7 +470,7 @@ module ts {
|
||||
var emittedLine = writer.getLine();
|
||||
var emittedColumn = writer.getColumn();
|
||||
|
||||
// If this location wasnt recorded or the location in source is going backwards, record the span
|
||||
// If this location wasn't recorded or the location in source is going backwards, record the span
|
||||
if (!lastRecordedSourceMapSpan ||
|
||||
lastRecordedSourceMapSpan.emittedLine != emittedLine ||
|
||||
lastRecordedSourceMapSpan.emittedColumn != emittedColumn ||
|
||||
@ -516,7 +516,7 @@ module ts {
|
||||
}
|
||||
|
||||
function recordNewSourceFileStart(node: SourceFile) {
|
||||
// Add the the file to tsFilePaths
|
||||
// Add the file to tsFilePaths
|
||||
// If sourceroot option: Use the relative path corresponding to the common directory path
|
||||
// otherwise source locations relative to map file location
|
||||
var sourcesDirectoryPath = compilerOptions.sourceRoot ? program.getCommonSourceDirectory() : sourceMapDir;
|
||||
@ -953,7 +953,7 @@ module ts {
|
||||
write(tokenToString(node.operator));
|
||||
}
|
||||
// In some cases, we need to emit a space between the operator and the operand. One obvious case
|
||||
// is when the operator is an identifer, like delete or typeof. We also need to do this for plus
|
||||
// is when the operator is an identifier, like delete or typeof. We also need to do this for plus
|
||||
// and minus expressions in certain cases. Specifically, consider the following two cases (parens
|
||||
// are just for clarity of exposition, and not part of the source code):
|
||||
//
|
||||
@ -2116,7 +2116,7 @@ module ts {
|
||||
}
|
||||
|
||||
function getLeadingCommentsToEmit(node: Node) {
|
||||
// Emit the leading comments only if the parent's pos doesnt match because parent should take care of emitting these comments
|
||||
// Emit the leading comments only if the parent's pos doesn't match because parent should take care of emitting these comments
|
||||
if (node.parent.kind === SyntaxKind.SourceFile || node.pos !== node.parent.pos) {
|
||||
var leadingComments: Comment[];
|
||||
if (hasDetachedComments(node.pos)) {
|
||||
@ -2139,7 +2139,7 @@ module ts {
|
||||
}
|
||||
|
||||
function emitTrailingDeclarationComments(node: Node) {
|
||||
// Emit the trailing comments only if the parent's end doesnt match
|
||||
// Emit the trailing comments only if the parent's end doesn't match
|
||||
if (node.parent.kind === SyntaxKind.SourceFile || node.end !== node.parent.end) {
|
||||
var trailingComments = getTrailingComments(currentSourceFile.text, node.end);
|
||||
// trailing comments are emitted at space/*trailing comment1 */space/*trailing comment*/
|
||||
@ -2215,7 +2215,7 @@ module ts {
|
||||
return currentSourceFile.text.charCodeAt(comment.pos + 2) === CharacterCodes.exclamation;
|
||||
}
|
||||
// Verify this is /// comment, but do the regexp match only when we first can find /// in the comment text
|
||||
// so that we dont end up computing comment string and doing match for all // comments
|
||||
// so that we don't end up computing comment string and doing match for all // comments
|
||||
else if (currentSourceFile.text.charCodeAt(comment.pos + 1) === CharacterCodes.slash &&
|
||||
comment.pos + 2 < comment.end &&
|
||||
currentSourceFile.text.charCodeAt(comment.pos + 2) === CharacterCodes.slash &&
|
||||
@ -2691,7 +2691,7 @@ module ts {
|
||||
}
|
||||
|
||||
function emitVariableDeclaration(node: VariableDeclaration) {
|
||||
// If we are emitting property it isnt moduleElement and hence we already know it needs to be emitted
|
||||
// If we are emitting property it isn't moduleElement and hence we already know it needs to be emitted
|
||||
// so there is no check needed to see if declaration is visible
|
||||
if (node.kind !== SyntaxKind.VariableDeclaration || resolver.isDeclarationVisible(node)) {
|
||||
emitSourceTextOfNode(node.name);
|
||||
@ -2715,7 +2715,7 @@ module ts {
|
||||
Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 :
|
||||
Diagnostics.Exported_variable_0_has_or_is_using_private_name_1;
|
||||
}
|
||||
// This check is to ensure we dont report error on constructor parameter property as that error would be reported during parameter emit
|
||||
// This check is to ensure we don't report error on constructor parameter property as that error would be reported during parameter emit
|
||||
else if (node.kind === SyntaxKind.Property) {
|
||||
if (node.flags & NodeFlags.Static) {
|
||||
diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
|
||||
@ -2820,7 +2820,7 @@ module ts {
|
||||
}
|
||||
|
||||
function emitFunctionDeclaration(node: FunctionDeclaration) {
|
||||
// If we are emitting Method/Constructor it isnt moduleElement and hence already determined to be emitting
|
||||
// If we are emitting Method/Constructor it isn't moduleElement and hence already determined to be emitting
|
||||
// so no need to verify if the declaration is visible
|
||||
if ((node.kind !== SyntaxKind.FunctionDeclaration || resolver.isDeclarationVisible(node)) &&
|
||||
!resolver.isImplementationOfOverload(node)) {
|
||||
@ -3096,7 +3096,7 @@ module ts {
|
||||
}
|
||||
|
||||
if (root) {
|
||||
// Emiting single file so emit references in this file only
|
||||
// Emitting just a single file, so emit references in this file only
|
||||
if (!compilerOptions.noResolve) {
|
||||
var addedGlobalFileReference = false;
|
||||
forEach(root.referencedFiles, fileReference => {
|
||||
@ -3127,9 +3127,9 @@ module ts {
|
||||
forEach(sourceFile.referencedFiles, fileReference => {
|
||||
var referencedFile = resolveScriptReference(sourceFile, fileReference);
|
||||
|
||||
// If the reference file is declaration file or external module emit that reference
|
||||
// If the reference file is a declaration file or an external module, emit that reference
|
||||
if (isExternalModuleOrDeclarationFile(referencedFile) &&
|
||||
!contains(emittedReferencedFiles, referencedFile)) { // If the file refernece was not already emitted
|
||||
!contains(emittedReferencedFiles, referencedFile)) { // If the file reference was not already emitted
|
||||
|
||||
writeReferencePath(referencedFile);
|
||||
emittedReferencedFiles.push(referencedFile);
|
||||
|
||||
@ -141,11 +141,11 @@ module ts {
|
||||
export function getLeadingCommentsOfNode(node: Node, sourceFileOfNode: SourceFile) {
|
||||
// If parameter/type parameter, the prev token trailing comments are part of this node too
|
||||
if (node.kind === SyntaxKind.Parameter || node.kind === SyntaxKind.TypeParameter) {
|
||||
// eg (/** blah */ a, /** blah */ b);
|
||||
// e.g. (/** blah */ a, /** blah */ b);
|
||||
return concatenate(getTrailingComments(sourceFileOfNode.text, node.pos),
|
||||
// eg: (
|
||||
// /** blah */ a,
|
||||
// /** blah */ b);
|
||||
// e.g.: (
|
||||
// /** blah */ a,
|
||||
// /** blah */ b);
|
||||
getLeadingComments(sourceFileOfNode.text, node.pos));
|
||||
}
|
||||
else {
|
||||
@ -157,7 +157,7 @@ module ts {
|
||||
return filter(getLeadingCommentsOfNode(node, sourceFileOfNode), comment => isJsDocComment(comment));
|
||||
|
||||
function isJsDocComment(comment: Comment) {
|
||||
// js doc is if comment is starting with /** but not if it is /**/
|
||||
// True if the comment starts with '/**' but not if it is '/**/'
|
||||
return sourceFileOfNode.text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk &&
|
||||
sourceFileOfNode.text.charCodeAt(comment.pos + 2) === CharacterCodes.asterisk &&
|
||||
sourceFileOfNode.text.charCodeAt(comment.pos + 3) !== CharacterCodes.slash;
|
||||
@ -661,7 +661,7 @@ module ts {
|
||||
}
|
||||
|
||||
function reportInvalidUseInStrictMode(node: Identifier): void {
|
||||
// identifierToString cannot be used here since it uses backreference to 'parent' that is not yet set
|
||||
// identifierToString cannot be used here since it uses a backreference to 'parent' that is not yet set
|
||||
var name = sourceText.substring(skipTrivia(sourceText, node.pos), node.end);
|
||||
grammarErrorOnNode(node, Diagnostics.Invalid_use_of_0_in_strict_mode, name);
|
||||
}
|
||||
@ -732,7 +732,7 @@ module ts {
|
||||
lookAheadMode = LookAheadMode.NoErrorYet;
|
||||
var result = callback();
|
||||
|
||||
// If we switched from 1 to to -1 then a parse error occurred during the callback.
|
||||
// If we switched from 1 to -1 then a parse error occurred during the callback.
|
||||
// If that's the case, then we want to act as if we never got any result at all.
|
||||
Debug.assert(lookAheadMode === LookAheadMode.Error || lookAheadMode === LookAheadMode.NoErrorYet);
|
||||
if (lookAheadMode === LookAheadMode.Error) {
|
||||
@ -1634,7 +1634,7 @@ module ts {
|
||||
// (i.e. they're both BinaryExpressions with an assignment operator in it).
|
||||
|
||||
// First, check if we have an arrow function (production '4') that starts with a parenthesized
|
||||
// parameter list. If we do, we must *not* recurse for productsion 1, 2 or 3. An ArrowFunction is
|
||||
// parameter list. If we do, we must *not* recurse for productions 1, 2 or 3. An ArrowFunction is
|
||||
// not a LeftHandSideExpression, nor does it start a ConditionalExpression. So we are done
|
||||
// with AssignmentExpression if we see one.
|
||||
var arrowExpression = tryParseParenthesizedArrowFunctionExpression();
|
||||
@ -1822,7 +1822,7 @@ module ts {
|
||||
if (token === SyntaxKind.EqualsGreaterThanToken) {
|
||||
// ERROR RECOVERY TWEAK:
|
||||
// If we see a standalone => try to parse it as an arrow function expression as that's
|
||||
// likely whatthe user intended to write.
|
||||
// likely what the user intended to write.
|
||||
return Tristate.True;
|
||||
}
|
||||
// Definitely not a parenthesized arrow function.
|
||||
@ -2725,8 +2725,8 @@ module ts {
|
||||
switch (token) {
|
||||
case SyntaxKind.SemicolonToken:
|
||||
// If we're in error recovery, then we don't want to treat ';' as an empty statement.
|
||||
// The problem is that ';' can show up in far too many contexts, and if we see one
|
||||
// and assume it's a statement, then we may bail out innapropriately from whatever
|
||||
// The problem is that ';' can show up in far too many contexts, and if we see one
|
||||
// and assume it's a statement, then we may bail out inappropriately from whatever
|
||||
// we're parsing. For example, if we have a semicolon in the middle of a class, then
|
||||
// we really don't want to assume the class is over and we're on a statement in the
|
||||
// outer module. We just want to consume and move on.
|
||||
@ -3286,7 +3286,7 @@ module ts {
|
||||
function isIntegerLiteral(expression: Expression): boolean {
|
||||
function isInteger(literalExpression: LiteralExpression): boolean {
|
||||
// Allows for scientific notation since literalExpression.text was formed by
|
||||
// coercing a number to a string. Sometimes this coersion can yield a string
|
||||
// coercing a number to a string. Sometimes this coercion can yield a string
|
||||
// in scientific notation.
|
||||
// We also don't need special logic for hex because a hex integer is converted
|
||||
// to decimal when it is coerced.
|
||||
@ -3308,7 +3308,7 @@ module ts {
|
||||
|
||||
var inConstantEnumMemberSection = true;
|
||||
// In an ambient declaration, the grammar only allows integer literals as initializers.
|
||||
// In a nonambient declaration, the grammar allows uninitialized members only in a
|
||||
// In a non-ambient declaration, the grammar allows uninitialized members only in a
|
||||
// ConstantEnumMemberSection, which starts at the beginning of an enum declaration
|
||||
// or any time an integer literal initializer is encountered.
|
||||
function parseAndCheckEnumMember(): EnumMember {
|
||||
@ -3848,7 +3848,7 @@ module ts {
|
||||
commonSourceDirectory = getNormalizedPathFromPathCompoments(commonPathComponents);
|
||||
if (commonSourceDirectory) {
|
||||
// Make sure directory path ends with directory separator so this string can directly
|
||||
// used to replace with "" to get the relative path of the source file and the relative path doesnt
|
||||
// used to replace with "" to get the relative path of the source file and the relative path doesn't
|
||||
// start with / making it rooted path
|
||||
commonSourceDirectory += directorySeparator;
|
||||
}
|
||||
|
||||
@ -192,7 +192,7 @@ module ts {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Perform binary search in one of the unicode range maps
|
||||
// Perform binary search in one of the Unicode range maps
|
||||
var lo: number = 0;
|
||||
var hi: number = map.length;
|
||||
var mid: number;
|
||||
@ -281,8 +281,8 @@ module ts {
|
||||
if (lineNumber < 0) {
|
||||
// If the actual position was not found,
|
||||
// the binary search returns the negative value of the next line start
|
||||
// eg. if line starts at [5, 10, 23, 80] and position requested was 20
|
||||
// the search will return -2
|
||||
// e.g. if the line starts at [5, 10, 23, 80] and the position requested was 20
|
||||
// then the search will return -2
|
||||
lineNumber = (~lineNumber) - 1;
|
||||
}
|
||||
return {
|
||||
@ -369,7 +369,7 @@ module ts {
|
||||
// Extract comments from the given source text starting at the given position. If trailing is false, whitespace is skipped until
|
||||
// the first line break and comments between that location and the next token are returned. If trailing is true, comments occurring
|
||||
// between the given position and the next line break are returned. The return value is an array containing a TextRange for each
|
||||
// comment. Single-line comment ranges include the the beginning '//' characters but not the ending line break. Multi-line comment
|
||||
// comment. Single-line comment ranges include the beginning '//' characters but not the ending line break. Multi-line comment
|
||||
// ranges include the beginning '/* and ending '*/' characters. The return value is undefined if no comments were found.
|
||||
function getCommentRanges(text: string, pos: number, trailing: boolean): Comment[] {
|
||||
var result: Comment[];
|
||||
|
||||
@ -648,7 +648,7 @@ module ts {
|
||||
export interface SymbolAccessiblityResult {
|
||||
accessibility: SymbolAccessibility;
|
||||
errorSymbolName?: string // Optional symbol name that results in error
|
||||
errorModuleName?: string // If the symbol is not visibile from module, module's name
|
||||
errorModuleName?: string // If the symbol is not visible from module, module's name
|
||||
aliasesToMakeVisible?: ImportDeclaration[]; // aliases that need to have this symbol visible
|
||||
}
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user