}

function getTypeOfSymbolAtLocation(symbol: Symbol, location: Node) {

// If we have an identifier or a property access at the given location, if the location is

// an dotted name expression, and if the location is not an assignment target, obtain the type

// of the expression (which will reflect control flow analysis). If the expression indeed

}

switch (location.kind) {

case SyntaxKind.ModuleDeclaration:

copySymbols(getSymbolOfNode(location).exports, meaning & SymbolFlags.ModuleMember);

break;

* @param meaning meaning of symbol to filter by before adding to symbol table

*/

function copySymbol(symbol: Symbol, meaning: SymbolFlags): void {

const id = symbol.name;

// We will copy all symbol regardless of its reserved name because

// symbolsToArray will check whether the key is a reserved name and

}

return previous[previous.length - 1];

}

namespace ts {

this.verifySymbol(symbol, declarationRanges);

}

private verifyReferencesAre(expectedReferences: Range[]) {

const actualReferences = this.getReferencesAtCaret() || [];

public markerByName(s: string): FourSlash.Marker {

return this.state.getMarkerByName(s);

}

}

export class GoTo {

this.state.verifySymbolAtLocation(startRange, declarationRanges);

}

public referencesOf(start: FourSlash.Range, references: FourSlash.Range[]) {

this.state.verifyReferencesOf(start, references);

}

}

else {

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

}

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

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

if (!displayName) {

return undefined;

}

// 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.

if (symbol) {

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

return undefined;

}

// Compute all the completion symbols again.

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

}

interface CompletionData {

}

type Request = { kind: "JsDocTagName" } | { kind: "JsDocTag" } | { kind: "JsDocParameterName", tag: JSDocParameterTag };

const isJavaScriptFile = isSourceFileJavaScript(sourceFile);

let request: Request | undefined;

// Extract module or enum members

const exportedSymbols = typeChecker.getExportsOfModule(symbol);

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

const isValidAccess = isRhsOfImportDeclaration ?

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

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

if (!isTypeLocation) {

const type = typeChecker.getTypeAtLocation(node);

}

}

symbols.push(symbol);

}

}

}

}

}

(!isContextTokenValueLocation(contextToken) &&

(isPartOfTypeNode(location) || isContextTokenTypeLocation(contextToken)))) {

// Its a type, but you can reach it by namespace.type as well

}

}

// expressions are value space (which includes the value namespaces)

});

}

}

}

// This is an alias, follow what it aliases

if (symbol && symbol.flags & SymbolFlags.Alias) {

symbol = typeChecker.getAliasedSymbol(symbol);

const exportedSymbols = typeChecker.getExportsOfModule(symbol);

// If the exported symbols contains type,

// symbol can be referenced at locations where type is allowed

}

}

/**

// If the symbol is external module, don't show it in the completion list

// (i.e declare module "http" { const x; } | // <= request completion here, "http" should not be there)

return undefined;

}

}

}

/**

function getCompletionEntryDisplayName(name: string, target: ScriptTarget, performCharacterChecks: boolean): string {

// If the user entered name for the symbol was quoted, removing the quotes is not enough, as the name could be an

// invalid identifier name. We need to check if whatever was inside the quotes is actually a valid identifier name.

// e.g "b a" is valid quoted name but when we strip off the quotes, it is invalid.

// We, thus, need to check if whatever was inside the quotes is actually a valid identifier name.

}

return name;

}

function initializeNameTable(sourceFile: SourceFile): void {

}

}

function isObjectLiteralElement(node: Node): node is ObjectLiteralElement {