for (let i = 1; i < types.length; i++) {

const currentType = types[i];

if (expectedStart !== currentType.pos || currentType.getLeadingTriviaWidth() !== 1) {

}

expectedStart = currentType.end + 2;

}

}

else {

forEachChild(node, bind);

bindAssignmentTargetFlow(node.operand);

}

}

function hasExportDeclarations(node: ModuleDeclaration | SourceFile): boolean {

const body = node.kind === SyntaxKind.SourceFile ? node : (<ModuleDeclaration>node).body;

if (body && (body.kind === SyntaxKind.SourceFile || body.kind === SyntaxKind.ModuleBlock)) {

if (stat.kind === SyntaxKind.ExportDeclaration || stat.kind === SyntaxKind.ExportAssignment) {

return true;

}

if (!links.declaredType) {

const enumType = <EnumType>getDeclaredTypeOfEnum(getParentOfSymbol(symbol));

links.declaredType = enumType.flags & TypeFlags.Union ?

enumType;

}

return links.declaredType;

return !node.typeParameters && areAllParametersUntyped && !isNullaryArrow;

}

return (isFunctionExpressionOrArrowFunction(func) || isObjectLiteralMethod(func)) && isContextSensitiveFunctionLikeDeclaration(func);

}

}

}

return node.kind === SyntaxKind.FunctionExpression || node.kind === SyntaxKind.ArrowFunction;

}

: undefined;

}

return isObjectLiteralMethod(node) ?

getContextualTypeForObjectLiteralMethod(node) :

getApparentTypeOfContextualType(node);

// If the contextual type is a union type, get the signature from each type possible and if they are

// all identical ignoring their return type, the result is same signature but with return type as

// union type of return types from these signatures

Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node));

const type = getContextualTypeForFunctionLikeDeclaration(node);

if (!type) {

argCount = getEffectiveArgumentCount(node, /*args*/ undefined, signature);

}

else {

if (!callExpression.arguments) {

// This only happens when we have something of the form: 'new C'

Debug.assert(callExpression.kind === SyntaxKind.NewExpression);

argCount = signatureHelpTrailingComma ? args.length + 1 : args.length;

// If we are missing the close paren, the call is incomplete.

typeArguments = callExpression.typeArguments;

spreadArgIndex = getSpreadArgumentIndex(args);

* @param node The call/new expression to be checked.

* @returns On success, the expression's signature's return type. On failure, anyType.

*/

// Grammar checking; stop grammar-checking if checkGrammarTypeArguments return true

checkGrammarTypeArguments(node, node.typeArguments) || checkGrammarArguments(node, node.arguments);

}

}

checkCollisionWithCapturedSuperVariable(node, (<FunctionExpression>node).name);

checkCollisionWithCapturedThisVariable(node, (<FunctionExpression>node).name);

}

}

}

checkExportsOnMergedDeclarations(node);

const symbol = getSymbolOfNode(node);

return undefined;

}

if (isConst(node)) {

const type = getTypeOfSymbol(getSymbolOfNode(node));

return !!(type.flags & TypeFlags.StringOrNumberLiteral && type.flags & TypeFlags.FreshLiteral);

}

return false;

}

const type = getTypeOfSymbol(getSymbolOfNode(node));

writer.writeStringLiteral(literalTypeToString(<LiteralType>type));

}

checkGrammarForAtLeastOneTypeArgument(node, typeArguments);

}

if (args) {

const sourceFile = getSourceFileOfNode(node);

for (const arg of args) {

}

}

return checkGrammarForOmittedArgument(node, args);

}

for (const prop of node.properties) {

const name = prop.name;

// If the name is not a ComputedPropertyName, the grammar checking will skip it

checkGrammarComputedPropertyName(<ComputedPropertyName>name);

}

currentKind = SetAccessor;

}

else {

}

const effectiveName = getPropertyNameForPropertyNameNode(name);

export interface ObjectAllocator {

getNodeConstructor(): new (kind: SyntaxKind, pos?: number, end?: number) => Node;

getSymbolConstructor(): new (flags: SymbolFlags, name: string) => Symbol;

getTypeConstructor(): new (checker: TypeChecker, flags: TypeFlags) => Type;

getSignatureConstructor(): new (checker: TypeChecker) => Signature;

writeLine();

}

// 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)) {

// If optional property emit ? but in the case of parameterProperty declaration with "?" indicating optional parameter for the constructor

// we don't want to emit property declaration with "?"

if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature ||

write("?");

}

if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) && node.parent.kind === SyntaxKind.TypeLiteral) {

}

}

if (bindingElement.kind === SyntaxKind.OmittedExpression) {

// If bindingElement is an omittedExpression (i.e. containing elision),

// we will emit blank space (although this may differ from users' original code,

case SyntaxKind.ModuleDeclaration:

return emitModuleDeclaration(<ModuleDeclaration>node);

case SyntaxKind.ModuleBlock:

case SyntaxKind.CaseBlock:

return emitCaseBlock(<CaseBlock>node);

case SyntaxKind.ImportEqualsDeclaration:

}

}

if (getEmitFlags(node) & EmitFlags.SingleLine) {

emitList(node, node.statements, ListFormat.SingleLineBlockStatements);

}

}

function emitModuleBlock(node: ModuleBlock) {

write("{ }");

}

else {

function isSingleLineEmptyBlock(block: Block) {

return !block.multiLine

&& rangeEndIsOnSameLineAsRangeStart(block, block, currentSourceFile);

}