return resolveName(location, escapeLeadingUnderscores(name), meaning, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false);

},

getJsxNamespace: () => unescapeLeadingUnderscores(getJsxNamespace()),

};

const tupleTypes: GenericType[] = [];

return nodeLinks[nodeId] || (nodeLinks[nodeId] = { flags: 0 });

}

function isGlobalSourceFile(node: Node) {

return node.kind === SyntaxKind.SourceFile && !isExternalOrCommonJsModule(<SourceFile>node);

}

!hasBaseType(checkClass, getDeclaringClass(p)) : false) ? undefined : checkClass;

}

// Return true if the given type is deeply nested. We consider this to be the case when structural type comparisons

// for 5 or more occurrences or instantiations of the type have been recorded on the given stack. It is possible,

// though highly unlikely, for this test to be true in a situation where a chain of instantiations is not infinitely

// the contextual type of an initializer expression is the type annotation of the containing declaration, if present.

function getContextualTypeForInitializerExpression(node: Expression): Type {

const declaration = <VariableLikeDeclaration>node.parent;

const typeNode = getEffectiveTypeAnnotationNode(declaration);

if (typeNode) {

return getTypeFromTypeNode(typeNode);

case SyntaxKind.AmpersandAmpersandToken:

case SyntaxKind.CommaToken:

return node === right ? getContextualType(binaryExpression) : undefined;

default:

return undefined;

}

return getContextualTypeForReturnExpression(node);

case SyntaxKind.YieldExpression:

return getContextualTypeForYieldOperand(<YieldExpression>parent);

case SyntaxKind.NewExpression:

case SyntaxKind.TypeAssertionExpression:

case SyntaxKind.AsExpression:

return getTypeFromTypeNode((<AssertionExpression>parent).type);

case SyntaxKind.JsxOpeningElement:

case SyntaxKind.JsxSelfClosingElement:

return getAttributesTypeFromJsxOpeningLikeElement(<JsxOpeningLikeElement>parent);

}

return undefined;

}

return getCheckFlags(s) & CheckFlags.Instantiated ? (<TransientSymbol>s).target : s;

}

function getClassOrInterfaceDeclarationsOfSymbol(symbol: Symbol) {

return filter(symbol.declarations, (d: Declaration): d is ClassDeclaration | InterfaceDeclaration =>

d.kind === SyntaxKind.ClassDeclaration || d.kind === SyntaxKind.InterfaceDeclaration);

/* @internal */ getAllPossiblePropertiesOfTypes(type: ReadonlyArray<Type>): Symbol[];

/* @internal */ resolveName(name: string, location: Node, meaning: SymbolFlags): Symbol | undefined;

/* @internal */ getJsxNamespace(): string;

}

export enum NodeBuilderFlags {

return isExternalModule(node) || compilerOptions.isolatedModules || ((getEmitModuleKind(compilerOptions) === ModuleKind.CommonJS) && !!node.commonJsModuleIndicator);

}

export function isBlockScope(node: Node, parentNode: Node) {

switch (node.kind) {

case SyntaxKind.SourceFile:

return false;

}

export function isDeclarationWithTypeParameters(node: Node): node is DeclarationWithTypeParameters;

export function isDeclarationWithTypeParameters(node: DeclarationWithTypeParameters): node is DeclarationWithTypeParameters {

switch (node.kind) {

}

}

export function isAnyImportSyntax(node: Node): node is AnyImportSyntax {

switch (node.kind) {

case SyntaxKind.ImportDeclaration:

}

}

// See GH#16030

export function isAnyDeclarationName(name: Node): boolean {

switch (name.kind) {

return flags;

}

export function getModifierFlagsNoCache(node: Node): ModifierFlags {

let flags = ModifierFlags.None;

}

}

export function typeHasCallOrConstructSignatures(type: Type, checker: TypeChecker) {

return checker.getSignaturesOfType(type, SignatureKind.Call).length !== 0 || checker.getSignaturesOfType(type, SignatureKind.Construct).length !== 0;

}

let replacementSpan: ts.TextSpan;

if (spanIndex !== undefined) {

replacementSpan = this.getTextSpanForRangeAtIndex(spanIndex);

this.raiseError(`verifyReferencesAtPositionListContains failed - could not find the item: ${stringify(missingItem)} in the returned list: (${stringify(references)})`);

}

return this.languageService.getCompletionsAtPosition(this.activeFile.fileName, this.currentCaretPosition, options);

}

const longestNameLength = max(entries, m => m.name.length);

const longestKindLength = max(entries, m => m.kind.length);

entries.sort((m, n) => m.sortText > n.sortText ? 1 : m.sortText < n.sortText ? -1 : m.name > n.name ? 1 : m.name < n.name ? -1 : 0);

Harness.IO.log(membersString);

}

}

assert.equal(item.hasAction, hasAction);

}

private findFile(indexOrName: string | number) {

newContent: string;

}

isNewIdentifierLocation?: boolean;

}

export interface VerifyCompletionListContainsOptions extends ts.GetCompletionsAtPositionOptions {

sourceDisplay: string;

}

export interface NewContentOptions {

isGlobalCompletion: false,

isMemberCompletion: false,

isNewIdentifierLocation: false,

if (entry.replacementSpan !== undefined) {

}

})

};

}

sortText: string;

/**

replacementSpan?: TextSpan;

/**

source?: string;

}

/**

if (simplifiedResult) {

return mapDefined<CompletionEntry, protocol.CompletionEntry>(completions && completions.entries, entry => {

if (completions.isMemberCompletion || startsWith(entry.name.toLowerCase(), prefix.toLowerCase())) {

const convertedSpan = replacementSpan ? this.toLocationTextSpan(replacementSpan, scriptInfo) : undefined;

// Use `hasAction || undefined` to avoid serializing `false`.

}

}).sort((a, b) => compareStringsCaseSensitiveUI(a.name, b.name));

}