function isInsideFunction(node: Node, threshold: Node): boolean {

var current = node;

while (current && current !== threshold) {

return true;

}

current = current.parent;

// if block scoped variable is defined in the function\module\source file scope (because of variable hoisting)

var namesShareScope =

container &&

(container.kind === SyntaxKind.ModuleBlock && container.kind === SyntaxKind.ModuleDeclaration) ||

container.kind === SyntaxKind.SourceFile);

if (!checkGrammarStatementInAmbientContext(node)) {

var current = node.parent;

while (current) {

break;

}

if (current.kind === SyntaxKind.LabeledStatement && (<LabeledStatement>current).label.text === node.label.text) {

function checkGrammarBreakOrContinueStatement(node: BreakOrContinueStatement): boolean {

var current: Node = node;

while (current) {

return grammarErrorOnNode(node, Diagnostics.Jump_target_cannot_cross_function_boundary);

}

// Find containing block which is either Block, ModuleBlock, SourceFile

var links = getNodeLinks(node);

return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts)

}

function getEnclosingBlockScopeContainer(node: Node): Node {

var current = node;

while (current) {

return current;

}

switch (current.kind) {

case SyntaxKind.Block:

// function block is not considered block-scope container

// see comment in binder.ts: bind(...), case for SyntaxKind.Block

return current;

}

}

}

}

if (node) {

switch (node.kind) {

case SyntaxKind.Constructor:

}

export function isFunctionBlock(node: Node) {

}

export function isObjectLiteralMethod(node: Node) {

export function getContainingFunction(node: Node): FunctionLikeDeclaration {

while (true) {

node = node.parent;

return <FunctionLikeDeclaration>node;

}

}

}

export function nodeStartsNewLexicalEnvironment(n: Node): boolean {

}

export function nodeIsSynthesized(node: Node): boolean {

}

// return type of function go to previous token

return spanInPreviousNode(node);

}

function spanInColonToken(node: Node): TextSpan {

// Is this : specifying return annotation of the function declaration

return spanInPreviousNode(node);

}

function isNameOfFunctionDeclaration(node: Node): boolean {

return node.kind === SyntaxKind.Identifier &&

}

/** Returns true if node is a name of an object literal property, e.g. "a" in x = { "a": 1 } */

}

}

// Do not cross function boundaries.

forEachChild(node, aggregate);

}

};

statementAccumulator.push(<BreakOrContinueStatement>node);

}

// Do not cross function boundaries.

forEachChild(node, aggregate);

}

};

break;

default:

// Don't cross function boundaries.

return undefined;

}

break;

return (<CallExpression>node).typeArguments;

}

return (<FunctionLikeDeclaration>node).typeParameters;

}