None,

ClassElementKeywords, // Keywords at class keyword

ConstructorParameterKeywords, // Keywords at constructor parameter

host: LanguageServiceHost,

typeChecker: TypeChecker,

log: Log,

compilerOptions: CompilerOptions,

sourceFile: SourceFile,

position: number,

allSourceFiles: ReadonlyArray<SourceFile>,

): CompletionInfo | undefined {

if (isInReferenceComment(sourceFile, position)) {

return PathCompletions.getTripleSlashReferenceCompletion(sourceFile, position, compilerOptions, host);

}

if (isInString(sourceFile, position)) {

return getStringLiteralCompletionEntries(sourceFile, position, typeChecker, compilerOptions, host, log);

}

const completionData = getCompletionData(typeChecker, log, sourceFile, position, allSourceFiles);

if (!completionData) {

return undefined;

}

const { symbols, isGlobalCompletion, isMemberCompletion, allowStringLiteral, isNewIdentifierLocation, location, request, keywordFilters, symbolToOriginInfoMap } = completionData;

if (sourceFile.languageVariant === LanguageVariant.JSX &&

location && location.parent && location.parent.kind === SyntaxKind.JsxClosingElement) {

// In the TypeScript JSX element, if such element is not defined. When users query for completion at closing tag,

// instead of simply giving unknown value, the completion will return the tag-name of an associated opening-element.

// For example:

// var x = <div> </ /*1*/> completion list at "1" will contain "div" with type any

const tagName = (<JsxElement>location.parent.parent).openingElement.tagName;

return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: false,

entries: [{

name: (<JsxTagNameExpression>tagName).getFullText(),

kind: ScriptElementKind.classElement,

kindModifiers: undefined,

sortText: "0",

}]};

}

if (request) {

const entries = request.kind === "JsDocTagName"

// If the current position is a jsDoc tag name, only tag names should be provided for completion

? JsDoc.getJSDocTagNameCompletions()

: request.kind === "JsDocTag"

// If the current position is a jsDoc tag, only tags should be provided for completion

? JsDoc.getJSDocTagCompletions()

: JsDoc.getJSDocParameterNameCompletions(request.tag);

return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries };

}

const entries: CompletionEntry[] = [];

if (isSourceFileJavaScript(sourceFile)) {

const uniqueNames = getCompletionEntriesFromSymbols(symbols, entries, location, /*performCharacterChecks*/ true, typeChecker, compilerOptions.target, log, allowStringLiteral, symbolToOriginInfoMap);

getJavaScriptCompletionEntries(sourceFile, location.pos, uniqueNames, compilerOptions.target, entries);

}

else {

if ((!symbols || symbols.length === 0) && keywordFilters === KeywordCompletionFilters.None) {

return undefined;

}

getCompletionEntriesFromSymbols(symbols, entries, location, /*performCharacterChecks*/ true, typeChecker, compilerOptions.target, log, allowStringLiteral, symbolToOriginInfoMap);

}

// TODO add filter for keyword based on type/value/namespace and also location

// Add all keywords if

// - this is not a member completion list (all the keywords)

// - other filters are enabled in required scenario so add those keywords

if (keywordFilters !== KeywordCompletionFilters.None || !isMemberCompletion) {

addRange(entries, getKeywordCompletions(keywordFilters));

}

return { isGlobalCompletion, isMemberCompletion, isNewIdentifierLocation, entries };

sourceFile: SourceFile,

position: number,

uniqueNames: Map<{}>,

target: ScriptTarget,

entries: Push<CompletionEntry>): void {

getNameTable(sourceFile).forEach((pos, name) => {

// Skip identifiers produced only from the current location

if (pos === position) {

return;

}

const realName = unescapeLeadingUnderscores(name);

if (uniqueNames.has(realName)) {

return;

}

uniqueNames.set(realName, true);

const displayName = getCompletionEntryDisplayName(realName, target, /*performCharacterChecks*/ true, /*allowStringLiteral*/ false);

if (displayName) {

entries.push({

name: displayName,

kind: ScriptElementKind.warning,

kindModifiers: "",

sortText: "1"

});

}

});

symbol: Symbol,

location: Node,

performCharacterChecks: boolean,

typeChecker: TypeChecker,

target: ScriptTarget,

allowStringLiteral: boolean,

origin: SymbolOriginInfo,

): CompletionEntry | undefined {

// Try to get a valid display name for this symbol, if we could not find one, then ignore it.

// We would like to only show things that can be added after a dot, so for instance numeric properties can

// not be accessed with a dot (a.1 <- invalid)

const displayName = getCompletionEntryDisplayNameForSymbol(symbol, target, performCharacterChecks, allowStringLiteral);

if (!displayName) {

return undefined;

}

// TODO(drosen): Right now we just permit *all* semantic meanings when calling

// 'getSymbolKind' which is permissible given that it is backwards compatible; but

// really we should consider passing the meaning for the node so that we don't report

// that a suggestion for a value is an interface. We COULD also just do what

// 'getSymbolModifiers' does, which is to use the first declaration.

// Use a 'sortText' of 0' so that all symbol completion entries come before any other

// entries (like JavaScript identifier entries).

return {

name: displayName,

kind: SymbolDisplay.getSymbolKind(typeChecker, symbol, location),

kindModifiers: SymbolDisplay.getSymbolModifiers(symbol),

sortText: "0",

source: getSourceFromOrigin(origin),

hasAction: origin === undefined ? undefined : true,

};

symbols: ReadonlyArray<Symbol>,

entries: Push<CompletionEntry>,

location: Node,

performCharacterChecks: boolean,

typeChecker: TypeChecker,

target: ScriptTarget,

log: Log,

allowStringLiteral: boolean,

symbolToOriginInfoMap?: SymbolOriginInfoMap,

): Map<true> {

const start = timestamp();

// Tracks unique names.

// We don't set this for global variables or completions from external module exports, because we can have multiple of those.

// Based on the order we add things we will always see locals first, then globals, then module exports.

// So adding a completion for a local will prevent us from adding completions for external module exports sharing the same name.

const uniques = createMap<true>();

if (symbols) {

for (const symbol of symbols) {

const origin = symbolToOriginInfoMap ? symbolToOriginInfoMap[getSymbolId(symbol)] : undefined;

const entry = createCompletionEntry(symbol, location, performCharacterChecks, typeChecker, target, allowStringLiteral, origin);

if (!entry) {

continue;

}

const { name } = entry;

if (uniques.has(name)) {

continue;

}

// Latter case tests whether this is a global variable.

if (!origin && !(symbol.parent === undefined && !some(symbol.declarations, d => d.getSourceFile() === location.getSourceFile()))) {

uniques.set(name, true);

}

entries.push(entry);

}

}

log("getCompletionsAtPosition: getCompletionEntriesFromSymbols: " + (timestamp() - start));

return uniques;

const node = findPrecedingToken(position, sourceFile);

if (!node || node.kind !== SyntaxKind.StringLiteral) {

return undefined;

}

if (node.parent.kind === SyntaxKind.PropertyAssignment &&

node.parent.parent.kind === SyntaxKind.ObjectLiteralExpression &&

(<PropertyAssignment>node.parent).name === node) {

// Get quoted name of properties of the object literal expression

// i.e. interface ConfigFiles {

// 'jspm:dev': string

// }

// let files: ConfigFiles = {

// '/*completion position*/'

// }

//

// function foo(c: ConfigFiles) {}

// foo({

// '/*completion position*/'

// });

return getStringLiteralCompletionEntriesFromPropertyAssignment(<ObjectLiteralElement>node.parent, typeChecker, compilerOptions.target, log);

}

else if (isElementAccessExpression(node.parent) && node.parent.argumentExpression === node) {

// Get all names of properties on the expression

// i.e. interface A {

// 'prop1': string

// }

// let a: A;

// a['/*completion position*/']

return getStringLiteralCompletionEntriesFromElementAccess(node.parent, typeChecker, compilerOptions.target, log);

}

else if (node.parent.kind === SyntaxKind.ImportDeclaration || node.parent.kind === SyntaxKind.ExportDeclaration

|| isRequireCall(node.parent, /*checkArgumentIsStringLiteral*/ false) || isImportCall(node.parent)

|| isExpressionOfExternalModuleImportEqualsDeclaration(node)) {

// Get all known external module names or complete a path to a module

// i.e. import * as ns from "/*completion position*/";

// var y = import("/*completion position*/");

// import x = require("/*completion position*/");

// var y = require("/*completion position*/");

// export * from "/*completion position*/";

return PathCompletions.getStringLiteralCompletionEntriesFromModuleNames(<StringLiteral>node, compilerOptions, host, typeChecker);

}

else if (isEqualityExpression(node.parent)) {

// Get completions from the type of the other operand

// i.e. switch (a) {

// case '/*completion position*/'

// }

return getStringLiteralCompletionEntriesFromType(typeChecker.getTypeAtLocation(node.parent.left === node ? node.parent.right : node.parent.left), typeChecker);

}

else if (isCaseOrDefaultClause(node.parent)) {

// Get completions from the type of the switch expression

// i.e. x === '/*completion position'

return getStringLiteralCompletionEntriesFromType(typeChecker.getTypeAtLocation((<SwitchStatement>node.parent.parent.parent).expression), typeChecker);

}

else {

const argumentInfo = SignatureHelp.getImmediatelyContainingArgumentInfo(node, position, sourceFile);

if (argumentInfo) {

// Get string literal completions from specialized signatures of the target

// i.e. declare function f(a: 'A');

// f("/*completion position*/")

return getStringLiteralCompletionEntriesFromCallExpression(argumentInfo, typeChecker);

}

// Get completion for string literal from string literal type

// i.e. var x: "hi" | "hello" = "/*completion position*/"

return getStringLiteralCompletionEntriesFromType(typeChecker.getContextualType(<StringLiteral>node), typeChecker);

}

const type = typeChecker.getContextualType((<ObjectLiteralExpression>element.parent));

const entries: CompletionEntry[] = [];

if (type) {

getCompletionEntriesFromSymbols(type.getApparentProperties(), entries, element, /*performCharacterChecks*/ false, typeChecker, target, log, /*allowStringLiteral*/ true);

if (entries.length) {

return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: true, entries };

}

}

const candidates: Signature[] = [];

const entries: CompletionEntry[] = [];

const uniques = createMap<true>();

typeChecker.getResolvedSignature(argumentInfo.invocation, candidates, argumentInfo.argumentCount);

for (const candidate of candidates) {

addStringLiteralCompletionsFromType(typeChecker.getParameterType(candidate, argumentInfo.argumentIndex), entries, typeChecker, uniques);

}

if (entries.length) {

return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: true, entries };

}

return undefined;

const type = typeChecker.getTypeAtLocation(node.expression);

const entries: CompletionEntry[] = [];

if (type) {

getCompletionEntriesFromSymbols(type.getApparentProperties(), entries, node, /*performCharacterChecks*/ false, typeChecker, target, log, /*allowStringLiteral*/ true);

if (entries.length) {

return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: true, entries };

}

}

return undefined;

if (type) {

const entries: CompletionEntry[] = [];

addStringLiteralCompletionsFromType(type, entries, typeChecker);

if (entries.length) {

return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries };

}

}

return undefined;

if (type && type.flags & TypeFlags.TypeParameter) {

type = typeChecker.getBaseConstraintOfType(type);

}

if (!type) {

return;

}

if (type.flags & TypeFlags.Union) {

for (const t of (<UnionType>type).types) {

addStringLiteralCompletionsFromType(t, result, typeChecker, uniques);

}

}

else if (type.flags & TypeFlags.StringLiteral && !(type.flags & TypeFlags.EnumLiteral)) {

const name = (<StringLiteralType>type).value;

if (!uniques.has(name)) {

uniques.set(name, true);

result.push({

name,

kindModifiers: ScriptElementKindModifier.none,

kind: ScriptElementKind.variableElement,

sortText: "0"

});

}

}

typeChecker: TypeChecker,

log: (message: string) => void,

compilerOptions: CompilerOptions,

sourceFile: SourceFile,

position: number,

{ name, source }: CompletionEntryIdentifier,

allSourceFiles: ReadonlyArray<SourceFile>,

): { type: "symbol", symbol: Symbol, location: Node, symbolToOriginInfoMap: SymbolOriginInfoMap } | { type: "request", request: Request } | { type: "none" } {

const completionData = getCompletionData(typeChecker, log, sourceFile, position, allSourceFiles);

if (!completionData) {

return { type: "none" };

}

const { symbols, location, allowStringLiteral, symbolToOriginInfoMap, request } = completionData;

if (request) {

return { type: "request", request };

}

// Find the symbol with the matching entry name.

// We don't need to perform character checks here because we're only comparing the

// name against 'entryName' (which is known to be good), not building a new

// completion entry.

const symbol = find(symbols, s =>

getCompletionEntryDisplayNameForSymbol(s, compilerOptions.target, /*performCharacterChecks*/ false, allowStringLiteral) === name

&& getSourceFromOrigin(symbolToOriginInfoMap[getSymbolId(s)]) === source);

return symbol ? { type: "symbol", symbol, location, symbolToOriginInfoMap } : { type: "none" };

typeChecker: TypeChecker,

log: (message: string) => void,

compilerOptions: CompilerOptions,

sourceFile: SourceFile,

position: number,

entryId: CompletionEntryIdentifier,

allSourceFiles: ReadonlyArray<SourceFile>,

host: LanguageServiceHost,

rulesProvider: formatting.RulesProvider,

): CompletionEntryDetails {

const { name, source } = entryId;

// Compute all the completion symbols again.

const symbolCompletion = getSymbolCompletionFromEntryId(typeChecker, log, compilerOptions, sourceFile, position, entryId, allSourceFiles);

switch (symbolCompletion.type) {

case "request": {

const { request } = symbolCompletion;

switch (request.kind) {

case "JsDocTagName":

return JsDoc.getJSDocTagNameCompletionDetails(name);

case "JsDocTag":

return JsDoc.getJSDocTagCompletionDetails(name);

case "JsDocParameterName":

return JsDoc.getJSDocParameterNameCompletionDetails(name);

default:

return Debug.assertNever(request);

}

}

case "symbol": {

const { symbol, location, symbolToOriginInfoMap } = symbolCompletion;

const codeActions = getCompletionEntryCodeActions(symbolToOriginInfoMap, symbol, typeChecker, host, compilerOptions, sourceFile, rulesProvider);

const kindModifiers = SymbolDisplay.getSymbolModifiers(symbol);

const { displayParts, documentation, symbolKind, tags } = SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, location, location, SemanticMeaning.All);

return { name, kindModifiers, kind: symbolKind, displayParts, documentation, tags, codeActions, source: source === undefined ? undefined : [textPart(source)] };

}

case "none": {

// Didn't find a symbol with this name. See if we can find a keyword instead.

if (some(getKeywordCompletions(KeywordCompletionFilters.None), c => c.name === name)) {

return {

name,

kind: ScriptElementKind.keyword,

kindModifiers: ScriptElementKindModifier.none,

displayParts: [displayPart(name, SymbolDisplayPartKind.keyword)],

documentation: undefined,

tags: undefined,

codeActions: undefined,

source: undefined,

};

}

return undefined;

}

}

symbolToOriginInfoMap: SymbolOriginInfoMap,

symbol: Symbol,

checker: TypeChecker,

host: LanguageServiceHost,

compilerOptions: CompilerOptions,

sourceFile: SourceFile,

rulesProvider: formatting.RulesProvider,

): CodeAction[] | undefined {

const symbolOriginInfo = symbolToOriginInfoMap[getSymbolId(symbol)];

if (!symbolOriginInfo) {

return undefined;

}

const { moduleSymbol, isDefaultExport } = symbolOriginInfo;

return codefix.getCodeActionForImport(moduleSymbol, {

host,

checker,

newLineCharacter: host.getNewLine(),

compilerOptions,

sourceFile,

rulesProvider,

symbolName: symbol.name,

getCanonicalFileName: createGetCanonicalFileName(host.useCaseSensitiveFileNames ? host.useCaseSensitiveFileNames() : false),

symbolToken: undefined,

kind: isDefaultExport ? codefix.ImportKind.Default : codefix.ImportKind.Named,

});

typeChecker: TypeChecker,

log: (message: string) => void,

compilerOptions: CompilerOptions,

sourceFile: SourceFile,

position: number,

entryId: CompletionEntryIdentifier,

allSourceFiles: ReadonlyArray<SourceFile>,

): Symbol | undefined {

const completion = getSymbolCompletionFromEntryId(typeChecker, log, compilerOptions, sourceFile, position, entryId, allSourceFiles);

return completion.type === "symbol" ? completion.symbol : undefined;

symbols: ReadonlyArray<Symbol>;

isGlobalCompletion: boolean;

isMemberCompletion: boolean;

allowStringLiteral: boolean;

isNewIdentifierLocation: boolean;

location: Node | undefined;

isRightOfDot: boolean;

request?: Request;

keywordFilters: KeywordCompletionFilters;

symbolToOriginInfoMap: SymbolOriginInfoMap;

typeChecker: TypeChecker,

log: (message: string) => void,

sourceFile: SourceFile,

position: number,

allSourceFiles: ReadonlyArray<SourceFile>,

): CompletionData | undefined {

const isJavaScriptFile = isSourceFileJavaScript(sourceFile);

let request: Request | undefined;

let start = timestamp();

let currentToken = getTokenAtPosition(sourceFile, position, /*includeJsDocComment*/ false); // TODO: GH#15853

// We will check for jsdoc comments with insideComment and getJsDocTagAtPosition. (TODO: that seems rather inefficient to check the same thing so many times.)

log("getCompletionData: Get current token: " + (timestamp() - start));

start = timestamp();

// Completion not allowed inside comments, bail out if this is the case

const insideComment = isInComment(sourceFile, position, currentToken);

log("getCompletionData: Is inside comment: " + (timestamp() - start));

let insideJsDocTagTypeExpression = false;

if (insideComment) {

if (hasDocComment(sourceFile, position)) {

if (sourceFile.text.charCodeAt(position - 1) === CharacterCodes.at) {

// The current position is next to the '@' sign, when no tag name being provided yet.

// Provide a full list of tag names

request = { kind: "JsDocTagName" };

}

else {

// When completion is requested without "@", we will have check to make sure that

// there are no comments prefix the request position. We will only allow "*" and space.

// e.g

// /** |c| /*

//

// /**

// |c|

// */

//

// /**

// * |c|

// */

//

// /**

// * |c|

// */

const lineStart = getLineStartPositionForPosition(position, sourceFile);

if (!(sourceFile.text.substring(lineStart, position).match(/[^\*|\s|(/\*\*)]/))) {

request = { kind: "JsDocTag" };

}

}

}

// Completion should work inside certain JsDoc tags. For example:

// /** @type {number | string} */

// Completion should work in the brackets

const tag = getJsDocTagAtPosition(currentToken, position);

if (tag) {

if (tag.tagName.pos <= position && position <= tag.tagName.end) {

request = { kind: "JsDocTagName" };

}

if (isTagWithTypeExpression(tag) && tag.typeExpression && tag.typeExpression.kind === SyntaxKind.JSDocTypeExpression) {

currentToken = getTokenAtPosition(sourceFile, position, /*includeJsDocComment*/ true);

if (!currentToken ||

(!isDeclarationName(currentToken) &&

(currentToken.parent.kind !== SyntaxKind.JSDocPropertyTag ||

(<JSDocPropertyTag>currentToken.parent).name !== currentToken))) {

// Use as type location if inside tag's type expression

insideJsDocTagTypeExpression = isCurrentlyEditingNode(tag.typeExpression);

}

}

if (isJSDocParameterTag(tag) && (nodeIsMissing(tag.name) || tag.name.pos <= position && position <= tag.name.end)) {

request = { kind: "JsDocParameterName", tag };

}

}

if (request) {

return {

symbols: emptyArray,

isGlobalCompletion: false,

isMemberCompletion: false,

allowStringLiteral: false,

isNewIdentifierLocation: false,

location: undefined,

isRightOfDot: false,

request,

keywordFilters: KeywordCompletionFilters.None,

symbolToOriginInfoMap: undefined,

};

}

if (!insideJsDocTagTypeExpression) {

// Proceed if the current position is in jsDoc tag expression; otherwise it is a normal

// comment or the plain text part of a jsDoc comment, so no completion should be available

log("Returning an empty list because completion was inside a regular comment or plain text part of a JsDoc comment.");

return undefined;

}

}

start = timestamp();

const previousToken = findPrecedingToken(position, sourceFile, /*startNode*/ undefined, insideJsDocTagTypeExpression);

log("getCompletionData: Get previous token 1: " + (timestamp() - start));

// The decision to provide completion depends on the contextToken, which is determined through the previousToken.

// Note: 'previousToken' (and thus 'contextToken') can be undefined if we are the beginning of the file

let contextToken = previousToken;

// Check if the caret is at the end of an identifier; this is a partial identifier that we want to complete: e.g. a.toS|

// Skip this partial identifier and adjust the contextToken to the token that precedes it.

if (contextToken && position <= contextToken.end && isWord(contextToken.kind)) {

const start = timestamp();

contextToken = findPrecedingToken(contextToken.getFullStart(), sourceFile, /*startNode*/ undefined, insideJsDocTagTypeExpression);

log("getCompletionData: Get previous token 2: " + (timestamp() - start));

}

// Find the node where completion is requested on.

// Also determine whether we are trying to complete with members of that node

// or attributes of a JSX tag.

let node = currentToken;

let isRightOfDot = false;

let isRightOfOpenTag = false;

let isStartingCloseTag = false;

let location = getTouchingPropertyName(sourceFile, position, insideJsDocTagTypeExpression); // TODO: GH#15853

if (contextToken) {

// Bail out if this is a known invalid completion location

if (isCompletionListBlocker(contextToken)) {

log("Returning an empty list because completion was requested in an invalid position.");

return undefined;

}

let parent = contextToken.parent;

if (contextToken.kind === SyntaxKind.DotToken) {

if (parent.kind === SyntaxKind.PropertyAccessExpression) {

node = (<PropertyAccessExpression>contextToken.parent).expression;

isRightOfDot = true;

}

else if (parent.kind === SyntaxKind.QualifiedName) {

node = (<QualifiedName>contextToken.parent).left;

isRightOfDot = true;

}

else {

// There is nothing that precedes the dot, so this likely just a stray character

// or leading into a '...' token. Just bail out instead.

return undefined;

}

}

else if (sourceFile.languageVariant === LanguageVariant.JSX) {

// <UI.Test /* completion position */ />

// If the tagname is a property access expression, we will then walk up to the top most of property access expression.

// Then, try to get a JSX container and its associated attributes type.

if (parent && parent.kind === SyntaxKind.PropertyAccessExpression) {

contextToken = parent;

parent = parent.parent;

}

switch (parent.kind) {

case SyntaxKind.JsxClosingElement:

if (contextToken.kind === SyntaxKind.SlashToken) {

isStartingCloseTag = true;

location = contextToken;

}

break;

case SyntaxKind.BinaryExpression:

if (!((parent as BinaryExpression).left.flags & NodeFlags.ThisNodeHasError)) {

// It has a left-hand side, so we're not in an opening JSX tag.

break;

}

// falls through

case SyntaxKind.JsxSelfClosingElement:

case SyntaxKind.JsxElement:

case SyntaxKind.JsxOpeningElement:

if (contextToken.kind === SyntaxKind.LessThanToken) {

isRightOfOpenTag = true;

location = contextToken;

}

break;

}

}

}

const semanticStart = timestamp();

let isGlobalCompletion = false;

let isMemberCompletion: boolean;

let allowStringLiteral = false;

let isNewIdentifierLocation: boolean;

let keywordFilters = KeywordCompletionFilters.None;

let symbols: Symbol[] = [];

const symbolToOriginInfoMap: SymbolOriginInfoMap = [];

if (isRightOfDot) {

getTypeScriptMemberSymbols();

}

else if (isRightOfOpenTag) {

const tagSymbols = typeChecker.getJsxIntrinsicTagNames();

if (tryGetGlobalSymbols()) {

symbols = tagSymbols.concat(symbols.filter(s => !!(s.flags & (SymbolFlags.Value | SymbolFlags.Alias))));

}

else {

symbols = tagSymbols;

}

isMemberCompletion = true;

isNewIdentifierLocation = false;

}

else if (isStartingCloseTag) {

const tagName = (<JsxElement>contextToken.parent.parent).openingElement.tagName;

const tagSymbol = typeChecker.getSymbolAtLocation(tagName);

if (!typeChecker.isUnknownSymbol(tagSymbol)) {

symbols = [tagSymbol];

}

isMemberCompletion = true;

isNewIdentifierLocation = false;

}

else {

// For JavaScript or TypeScript, if we're not after a dot, then just try to get the

// global symbols in scope. These results should be valid for either language as

// the set of symbols that can be referenced from this location.

if (!tryGetGlobalSymbols()) {

return undefined;

}

}

log("getCompletionData: Semantic work: " + (timestamp() - semanticStart));

return { symbols, isGlobalCompletion, isMemberCompletion, allowStringLiteral, isNewIdentifierLocation, location, isRightOfDot: (isRightOfDot || isRightOfOpenTag), request, keywordFilters, symbolToOriginInfoMap };

type JSDocTagWithTypeExpression = JSDocParameterTag | JSDocPropertyTag | JSDocReturnTag | JSDocTypeTag | JSDocTypedefTag;

function isTagWithTypeExpression(tag: JSDocTag): tag is JSDocTagWithTypeExpression {

switch (tag.kind) {

case SyntaxKind.JSDocParameterTag:

case SyntaxKind.JSDocPropertyTag:

case SyntaxKind.JSDocReturnTag:

case SyntaxKind.JSDocTypeTag:

case SyntaxKind.JSDocTypedefTag:

return true;

}

}

function getTypeScriptMemberSymbols(): void {

// Right of dot member completion list

isGlobalCompletion = false;

isMemberCompletion = true;

isNewIdentifierLocation = false;

// Since this is qualified name check its a type node location

const isTypeLocation = insideJsDocTagTypeExpression || isPartOfTypeNode(node.parent);

const isRhsOfImportDeclaration = isInRightSideOfInternalImportEqualsDeclaration(node);

if (isEntityName(node)) {

let symbol = typeChecker.getSymbolAtLocation(node);

if (symbol) {

symbol = skipAlias(symbol, typeChecker);

if (symbol.flags & (SymbolFlags.Module | SymbolFlags.Enum)) {

// Extract module or enum members

const exportedSymbols = typeChecker.getExportsOfModule(symbol);

const isValidValueAccess = (symbol: Symbol) => typeChecker.isValidPropertyAccess(<PropertyAccessExpression>(node.parent), symbol.name);

const isValidTypeAccess = (symbol: Symbol) => symbolCanBeReferencedAtTypeLocation(symbol);

const isValidAccess = isRhsOfImportDeclaration ?

// Any kind is allowed when dotting off namespace in internal import equals declaration

(symbol: Symbol) => isValidTypeAccess(symbol) || isValidValueAccess(symbol) :

isTypeLocation ? isValidTypeAccess : isValidValueAccess;

for (const symbol of exportedSymbols) {

if (isValidAccess(symbol)) {

symbols.push(symbol);

}

}

// If the module is merged with a value, we must get the type of the class and add its propertes (for inherited static methods).

if (!isTypeLocation && symbol.declarations.some(d => d.kind !== SyntaxKind.SourceFile && d.kind !== SyntaxKind.ModuleDeclaration && d.kind !== SyntaxKind.EnumDeclaration)) {

addTypeProperties(typeChecker.getTypeOfSymbolAtLocation(symbol, node));

}

return;

}

}

}

if (!isTypeLocation) {

addTypeProperties(typeChecker.getTypeAtLocation(node));

}

}

function addTypeProperties(type: Type) {

// Filter private properties

for (const symbol of type.getApparentProperties()) {

if (typeChecker.isValidPropertyAccess(<PropertyAccessExpression>(node.parent), symbol.name)) {

symbols.push(symbol);

}

}

if (isJavaScriptFile && type.flags & TypeFlags.Union) {

// In javascript files, for union types, we don't just get the members that

// the individual types have in common, we also include all the members that

// each individual type has. This is because we're going to add all identifiers

// anyways. So we might as well elevate the members that were at least part

// of the individual types to a higher status since we know what they are.

const unionType = <UnionType>type;

for (const elementType of unionType.types) {

addTypeProperties(elementType);

}

}

}

function tryGetGlobalSymbols(): boolean {

let objectLikeContainer: ObjectLiteralExpression | BindingPattern;

let namedImportsOrExports: NamedImportsOrExports;

let classLikeContainer: ClassLikeDeclaration;

let jsxContainer: JsxOpeningLikeElement;

if (objectLikeContainer = tryGetObjectLikeCompletionContainer(contextToken)) {

return tryGetObjectLikeCompletionSymbols(objectLikeContainer);

}

if (namedImportsOrExports = tryGetNamedImportsOrExportsForCompletion(contextToken)) {