function isNarrowableReference(expr: Expression): boolean {

return expr.kind === SyntaxKind.Identifier ||

expr.kind === SyntaxKind.ThisKeyword ||

expr.kind === SyntaxKind.PropertyAccessExpression && isNarrowableReference((<PropertyAccessExpression>expr).expression);

}

// Here the current node is "foo", which is a container, but the scope of "MyType" should

// not be inside "foo". Therefore we always bind @typedef before bind the parent node,

// and skip binding this tag later when binding all the other jsdoc tags.

// First we bind declaration nodes to a symbol if possible. We'll both create a symbol

// and then potentially add the symbol to an appropriate symbol table. Possible

return symbol;

}

function getExcludedSymbolFlags(flags: SymbolFlags): SymbolFlags {

let result: SymbolFlags = 0;

if (flags & SymbolFlags.BlockScopedVariable) result |= SymbolFlags.BlockScopedVariableExcludes;

}

// declaration is after usage

// can be legal if usage is deferred (i.e. inside function or in initializer of instance property)

return true;

}

const sourceFiles = host.getSourceFiles();

// 1. inside a function

// 2. inside an instance property initializer, a reference to a non-instance property

const container = getEnclosingBlockScopeContainer(declaration);

function isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration: VariableDeclaration, usage: Node): boolean {

const container = getEnclosingBlockScopeContainer(declaration);

return false;

}

let current = usage;

while (current) {

if (current === container) {

(<PropertyDeclaration>current.parent).initializer === current;

if (initializerOfInstanceProperty) {

}

current = current.parent;

}

}

else if (name.kind === SyntaxKind.ParenthesizedExpression) {

// i.e class C extends foo()./*do language service operation here*/B {}

return isEntityNameExpression(name.expression) ?

resolveEntityName(name.expression as EntityNameOrEntityNameExpression, meaning, ignoreErrors, dontResolveAlias, location) :

}

function resolveExternalModuleNameWorker(location: Node, moduleReferenceExpression: Expression, moduleNotFoundError: DiagnosticMessage, isForAugmentation = false): Symbol {

return;

}

function buildParameterDisplay(p: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, symbolStack?: Symbol[]) {

const parameterNode = <ParameterDeclaration>p.valueDeclaration;

writePunctuation(writer, SyntaxKind.DotDotDotToken);

}

buildBindingPatternDisplay(<BindingPattern>parameterNode.name, writer, enclosingDeclaration, flags, symbolStack);

}

else {

appendSymbolNameOnly(p, writer);

}

writePunctuation(writer, SyntaxKind.QuestionToken);

}

writePunctuation(writer, SyntaxKind.ColonToken);

writeSpace(writer);

let type = getTypeOfSymbol(p);

type = includeFalsyTypes(type, TypeFlags.Undefined);

}

buildTypeDisplay(type, writer, enclosingDeclaration, flags, symbolStack);

}

}

function getSignaturesOfSymbol(symbol: Symbol): Signature[] {

if (!symbol) return emptyArray;

const result: Signature[] = [];

getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(<Identifier>source)) === getSymbolOfNode(target);

case SyntaxKind.ThisKeyword:

return target.kind === SyntaxKind.ThisKeyword;

case SyntaxKind.PropertyAccessExpression:

return target.kind === SyntaxKind.PropertyAccessExpression &&

(<PropertyAccessExpression>source).name.text === (<PropertyAccessExpression>target).name.text &&

switch (expr.kind) {

case SyntaxKind.Identifier:

case SyntaxKind.ThisKeyword:

case SyntaxKind.PropertyAccessExpression:

return narrowTypeByTruthiness(type, expr, assumeTrue);

case SyntaxKind.CallExpression:

}

}

return getTypeOfSymbol(symbol);

}

}

}

const candidates = candidatesOutArray || [];

// reorderCandidates fills up the candidates array directly

reorderCandidates(signatures, candidates);

function nextTokenIsClassOrFunctionOrAsync(): boolean {

nextToken();

return token() === SyntaxKind.ClassKeyword || token() === SyntaxKind.FunctionKeyword ||

(token() === SyntaxKind.AsyncKeyword && lookAhead(nextTokenIsFunctionKeywordOnSameLine));

}

return tokenIsIdentifierOrKeyword(token()) && !scanner.hasPrecedingLineBreak();

}

function nextTokenIsFunctionKeywordOnSameLine() {

nextToken();

return token() === SyntaxKind.FunctionKeyword && !scanner.hasPrecedingLineBreak();

function parseTagComments(indent: number) {

const comments: string[] = [];

let margin: number | undefined;

function pushComment(text: string) {

if (!margin) {

/* @internal */

export interface TransientSymbol extends Symbol, SymbolLinks {

checkFlags: CheckFlags;

}

export type SymbolTable = Map<Symbol>;

ContextChecked = 0x00000400, // Contextual types have been assigned

AsyncMethodWithSuper = 0x00000800, // An async method that reads a value from a member of 'super'.

AsyncMethodWithSuperBinding = 0x00001000, // An async method that assigns a value to a member of 'super'.

EnumValuesComputed = 0x00004000, // Values for enum members have been computed, and any errors have been reported for them.

LexicalModuleMergesWithClass = 0x00008000, // Instantiated lexical module declaration is merged with a previous class declaration.

LoopWithCapturedBlockScopedBinding = 0x00010000, // Loop that contains block scoped variable captured in closure

maybeTypePredicate?: boolean; // Cached check whether call expression might reference a type predicate

enumMemberValue?: number; // Constant value of enum member

isVisible?: boolean; // Is this node visible

hasReportedStatementInAmbientContext?: boolean; // Cache boolean if we report statements in ambient context

jsxFlags?: JsxFlags; // flags for knowing what kind of element/attributes we're dealing with

resolvedJsxElementAttributesType?: Type; // resolved element attributes type of a JSX openinglike element

/**

}

export function isSingleOrDoubleQuote(charCode: number) {

return node && firstOrUndefined(getJSDocTags(node, kind));

}

let cache: (JSDoc | JSDocTag)[] = node.jsDocCache;

if (!cache) {

getJSDocsWorker(node);