@tslite/services 0.0.0-stage → 1.13.0

package/dist/completions.js

@@ -0,0 +1,1720 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/completions.ts: o namespace virou módulo ES, com os imports explícitos.
+import { CharacterCodes, ContextFlags, Debug, InternalSymbolName, LanguageVariant, NodeFlags, ScriptTarget, SignatureHelp, SymbolDisplay, SymbolDisplayPartKind, SymbolFlags, SyntaxKind, TypeFlags, addToSeen, arrayToSet, cast, createMap, createTextRangeFromSpan, createTextSpanFromBounds, createTextSpanFromNode, createUnderscoreEscapedMap, displayPart, filterMutate, find, findAncestor, findChildOfKind, findPrecedingToken, first, firstDefined, getCombinedLocalAndExportSymbolFlags, getContextualTypeFromParent, getEscapedTextOfIdentifierOrLiteral, getLineAndCharacterOfPosition, getNameForExportedSymbol, getNameOfDeclaration, getReplacementSpanForContextToken, getRootDeclaration, getSwitchedType, getSymbolId, getTokenAtPosition, getTouchingPropertyName, hasIndexSignature, hasInitializer, hasType, isAssertionExpression, isBinaryExpression, isBindingElement, isCallExpression, isCaseClause, isComputedPropertyName, isContextualKeyword, isDeclarationName, isEntityName, isEqualityOperatorKind, isExportAssignment, isExportSpecifier, isExpression, isExternalModuleSymbol, isFunctionLikeDeclaration, isFunctionLikeKind, isIdentifier, isIdentifierANonContextualKeyword, isIdentifierText, isInComment, isInString, isJsxAttribute, isJsxClosingElement, isJsxExpression, isJsxSpreadAttribute, isKeyword, isKnownSymbol, isLiteralImportTypeNode, isModuleDeclaration, isNamedExports, isNamedImportsOrExports, isObjectBindingPattern, isObjectLiteralExpression, isObjectTypeDeclaration, isPartOfTypeNode, isPossiblyTypeArgumentPosition, isPropertyAccessExpression, isPropertyNameLiteral, isSingleOrDoubleQuote, isSourceFile, isSpreadAssignment, isStatement, isString, isStringLiteralLike, isStringLiteralOrTemplate, isStringTextContainingNode, isTypeElement, isTypeKeyword, isTypeOfExpression, isVariableLike, last, lastOrUndefined, mapDefined, memoize, nodeIsMissing, or, positionBelongsToNode, positionIsASICandidate, pseudoBigIntToString, quote, rangeContainsPositionExclusive, skipAlias, some, startsWith, stringToToken, stripQuotes, textPart, timestamp, tokenToString, tryCast, tryGetImportFromModuleSpecifier, typeHasCallOrConstructSignatures, } from "./_namespaces/ts.js";
+import { StringCompletions, } from "./_namespaces/ts.Completions.js";
+// O alvo da configuração fixa (CK-24): o do nome que se oferece e o da conversão do nome de um módulo.
+const languageVersion = ScriptTarget.ES2020;
+let autoImportProvider;
+/** Registra o auto-import do completion: quem o chama é a edição, ao carregar (CK-67). */
+export function registerAutoImportProvider(provider) {
+    autoImportProvider = provider;
+}
+export var SortText;
+(function (SortText) {
+    SortText["LocationPriority"] = "0";
+    SortText["OptionalMember"] = "1";
+    SortText["MemberDeclaredBySpreadAssignment"] = "2";
+    SortText["SuggestedClassMembers"] = "3";
+    SortText["GlobalsOrKeywords"] = "4";
+    SortText["AutoImportSuggestions"] = "5";
+    SortText["JavascriptIdentifiers"] = "6";
+})(SortText || (SortText = {}));
+var SymbolOriginInfoKind;
+(function (SymbolOriginInfoKind) {
+    SymbolOriginInfoKind[SymbolOriginInfoKind["SymbolMember"] = 2] = "SymbolMember";
+    SymbolOriginInfoKind[SymbolOriginInfoKind["Export"] = 4] = "Export";
+    SymbolOriginInfoKind[SymbolOriginInfoKind["Promise"] = 8] = "Promise";
+    SymbolOriginInfoKind[SymbolOriginInfoKind["Nullable"] = 16] = "Nullable";
+    SymbolOriginInfoKind[SymbolOriginInfoKind["SymbolMemberNoExport"] = 2] = "SymbolMemberNoExport";
+    SymbolOriginInfoKind[SymbolOriginInfoKind["SymbolMemberExport"] = 6] = "SymbolMemberExport";
+})(SymbolOriginInfoKind || (SymbolOriginInfoKind = {}));
+function originIsSymbolMember(origin) {
+    return !!(origin.kind & 2 /* SymbolOriginInfoKind.SymbolMember */);
+}
+function originIsExport(origin) {
+    return !!(origin && origin.kind & 4 /* SymbolOriginInfoKind.Export */);
+}
+function originIsPromise(origin) {
+    return !!(origin.kind & 8 /* SymbolOriginInfoKind.Promise */);
+}
+function originIsNullableMember(origin) {
+    return !!(origin.kind & 16 /* SymbolOriginInfoKind.Nullable */);
+}
+var KeywordCompletionFilters;
+(function (KeywordCompletionFilters) {
+    KeywordCompletionFilters[KeywordCompletionFilters["None"] = 0] = "None";
+    KeywordCompletionFilters[KeywordCompletionFilters["All"] = 1] = "All";
+    KeywordCompletionFilters[KeywordCompletionFilters["InterfaceElementKeywords"] = 2] = "InterfaceElementKeywords";
+    KeywordCompletionFilters[KeywordCompletionFilters["FunctionLikeBodyKeywords"] = 3] = "FunctionLikeBodyKeywords";
+    KeywordCompletionFilters[KeywordCompletionFilters["TypeAssertionKeywords"] = 4] = "TypeAssertionKeywords";
+    KeywordCompletionFilters[KeywordCompletionFilters["TypeKeywords"] = 5] = "TypeKeywords";
+    KeywordCompletionFilters[KeywordCompletionFilters["Last"] = 5] = "Last";
+})(KeywordCompletionFilters || (KeywordCompletionFilters = {}));
+var GlobalsSearch;
+(function (GlobalsSearch) {
+    GlobalsSearch[GlobalsSearch["Continue"] = 0] = "Continue";
+    GlobalsSearch[GlobalsSearch["Success"] = 1] = "Success";
+    GlobalsSearch[GlobalsSearch["Fail"] = 2] = "Fail";
+})(GlobalsSearch || (GlobalsSearch = {}));
+export function getCompletionsAtPosition(host, program, log, sourceFile, position, preferences, triggerCharacter) {
+    const typeChecker = program.getTypeChecker();
+    const contextToken = findPrecedingToken(position, sourceFile);
+    if (triggerCharacter && !isInString(sourceFile, position, contextToken) && !isValidTrigger(sourceFile, triggerCharacter, contextToken, position)) {
+        return undefined;
+    }
+    const stringCompletions = StringCompletions.getStringLiteralCompletions(sourceFile, position, contextToken, typeChecker, host, log, preferences);
+    if (stringCompletions) {
+        return stringCompletions;
+    }
+    const completionData = getCompletionData(program, log, sourceFile, position, preferences, /*detailsEntryId*/ undefined, host);
+    if (!completionData) {
+        return undefined;
+    }
+    return completionInfoFromData(sourceFile, typeChecker, log, completionData, preferences);
+}
+function completionInfoFromData(sourceFile, typeChecker, log, completionData, preferences) {
+    const { symbols, completionKind, isInSnippetScope, isNewIdentifierLocation, location, propertyAccessToConvert, keywordFilters, literals, symbolToOriginInfoMap, isJsxInitializer, symbolToSortTextMap, } = completionData;
+    if (location && location.parent && isJsxClosingElement(location.parent)) {
+        // 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*/
+        // The completion list at "1" will contain "div>" with type any
+        // And at `<div> </ /*1*/ >` (with a closing `>`), the completion list will contain "div".
+        const tagName = location.parent.parent.openingElement.tagName;
+        const hasClosingAngleBracket = !!findChildOfKind(location.parent, SyntaxKind.GreaterThanToken, sourceFile);
+        const entry = {
+            name: tagName.getFullText(sourceFile) + (hasClosingAngleBracket ? "" : ">"),
+            kind: "class" /* ScriptElementKind.classElement */,
+            kindModifiers: undefined,
+            sortText: SortText.LocationPriority,
+        };
+        return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: false, entries: [entry] };
+    }
+    const entries = [];
+    if (!isNewIdentifierLocation && (!symbols || symbols.length === 0) && keywordFilters === 0 /* KeywordCompletionFilters.None */) {
+        return undefined;
+    }
+    getCompletionEntriesFromSymbols(symbols, entries, 
+    /* contextToken */ undefined, location, sourceFile, typeChecker, languageVersion, log, completionKind, preferences, propertyAccessToConvert, completionData.isJsxIdentifierExpected, isJsxInitializer, symbolToOriginInfoMap, symbolToSortTextMap);
+    if (keywordFilters !== 0 /* KeywordCompletionFilters.None */) {
+        const entryNames = arrayToSet(entries, e => e.name);
+        for (const keywordEntry of getTypescriptKeywordCompletions(keywordFilters)) {
+            if (!entryNames.has(keywordEntry.name)) {
+                entries.push(keywordEntry);
+            }
+        }
+    }
+    for (const literal of literals) {
+        entries.push(createCompletionEntryForLiteral(literal, preferences));
+    }
+    return { isGlobalCompletion: isInSnippetScope, isMemberCompletion: isMemberCompletionKind(completionKind), isNewIdentifierLocation, entries };
+}
+function isMemberCompletionKind(kind) {
+    switch (kind) {
+        case 0 /* CompletionKind.ObjectPropertyDeclaration */:
+        case 3 /* CompletionKind.MemberLike */:
+        case 2 /* CompletionKind.PropertyAccess */:
+            return true;
+        default:
+            return false;
+    }
+}
+function completionNameForLiteral(literal, preferences) {
+    return typeof literal === "object" ? pseudoBigIntToString(literal) + "n" :
+        isString(literal) ? quote(literal, preferences) : JSON.stringify(literal);
+}
+function createCompletionEntryForLiteral(literal, preferences) {
+    return { name: completionNameForLiteral(literal, preferences), kind: "string" /* ScriptElementKind.string */, kindModifiers: "" /* ScriptElementKindModifier.none */, sortText: SortText.LocationPriority };
+}
+function createCompletionEntry(symbol, sortText, contextToken, location, sourceFile, typeChecker, name, needsConvertPropertyAccess, origin, propertyAccessToConvert, isJsxInitializer, preferences) {
+    let insertText;
+    let replacementSpan = getReplacementSpanForContextToken(contextToken);
+    const insertQuestionDot = origin && originIsNullableMember(origin);
+    const useBraces = origin && originIsSymbolMember(origin) || needsConvertPropertyAccess;
+    // O `needsConvertPropertyAccess` só vem com um acesso a converter; um global de nome que não é identificador não o
+    // tem.
+    if ((useBraces || insertQuestionDot) && propertyAccessToConvert) {
+        insertText = useBraces ? needsConvertPropertyAccess ? `[${quotePropertyName(name, preferences)}]` : `[${name}]` : name;
+        if (insertQuestionDot || propertyAccessToConvert.questionDotToken) {
+            insertText = `?.${insertText}`;
+        }
+        const dot = findChildOfKind(propertyAccessToConvert, SyntaxKind.DotToken, sourceFile) ||
+            findChildOfKind(propertyAccessToConvert, SyntaxKind.QuestionDotToken, sourceFile);
+        if (!dot) {
+            return undefined;
+        }
+        // If the text after the '.' starts with this name, write over it. Else, add new text.
+        const end = startsWith(name, propertyAccessToConvert.name.text) ? propertyAccessToConvert.name.end : dot.end;
+        replacementSpan = createTextSpanFromBounds(dot.getStart(sourceFile), end);
+    }
+    if (isJsxInitializer) {
+        if (insertText === undefined)
+            insertText = name;
+        insertText = `{${insertText}}`;
+        if (typeof isJsxInitializer !== "boolean") {
+            replacementSpan = createTextSpanFromNode(isJsxInitializer, sourceFile);
+        }
+    }
+    if (origin && originIsPromise(origin) && propertyAccessToConvert) {
+        if (insertText === undefined)
+            insertText = name;
+        const precedingToken = findPrecedingToken(propertyAccessToConvert.pos, sourceFile);
+        let awaitText = "";
+        if (precedingToken && positionIsASICandidate(precedingToken.end, precedingToken.parent, sourceFile)) {
+            awaitText = ";";
+        }
+        awaitText += `(await ${propertyAccessToConvert.expression.getText()})`;
+        insertText = needsConvertPropertyAccess ? `${awaitText}${insertText}` : `${awaitText}${insertQuestionDot ? "?." : "."}${insertText}`;
+        replacementSpan = createTextSpanFromBounds(propertyAccessToConvert.getStart(sourceFile), propertyAccessToConvert.end);
+    }
+    if (insertText !== undefined && !preferences.includeCompletionsWithInsertText) {
+        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,
+        kind: SymbolDisplay.getSymbolKind(typeChecker, symbol, location), // TODO: GH#18217
+        kindModifiers: SymbolDisplay.getSymbolModifiers(symbol),
+        sortText,
+        source: getSourceFromOrigin(origin),
+        hasAction: origin && originIsExport(origin) || undefined,
+        // Na tag, também a marca do item recomendado, que só o enum e a classe davam (CK-02).
+        insertText,
+        replacementSpan,
+    };
+}
+function quotePropertyName(name, preferences) {
+    if (/^\d+$/.test(name)) {
+        return name;
+    }
+    return quote(name, preferences);
+}
+function getSourceFromOrigin(origin) {
+    if (originIsExport(origin)) {
+        return stripQuotes(origin.moduleSymbol.name);
+    }
+}
+export function getCompletionEntriesFromSymbols(symbols, entries, contextToken, location, sourceFile, typeChecker, target, log, kind, preferences, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, symbolToOriginInfoMap, symbolToSortTextMap) {
+    const start = timestamp();
+    // Tracks unique names.
+    // Value is set to false for global variables or completions from external module exports, because we can have multiple of those;
+    // true otherwise. 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();
+    for (const symbol of symbols) {
+        const origin = symbolToOriginInfoMap ? symbolToOriginInfoMap[getSymbolId(symbol)] : undefined;
+        const info = getCompletionEntryDisplayNameForSymbol(symbol, target, origin, kind, !!jsxIdentifierExpected);
+        if (!info) {
+            continue;
+        }
+        const { name, needsConvertPropertyAccess } = info;
+        if (uniques.get(name)) {
+            continue;
+        }
+        const entry = createCompletionEntry(symbol, symbolToSortTextMap && symbolToSortTextMap[getSymbolId(symbol)] || SortText.LocationPriority, contextToken, location, sourceFile, typeChecker, name, needsConvertPropertyAccess, origin, propertyAccessToConvert, isJsxInitializer, preferences);
+        if (!entry) {
+            continue;
+        }
+        /** True for locals; false for globals, module exports from other files, `this.` completions. */
+        const shouldShadowLaterSymbols = !origin && !(symbol.parent === undefined && !some(symbol.declarations, d => d.getSourceFile() === location.getSourceFile()));
+        uniques.set(name, shouldShadowLaterSymbols);
+        entries.push(entry);
+    }
+    log("getCompletionsAtPosition: getCompletionEntriesFromSymbols: " + (timestamp() - start));
+    // Prevent consumers of this map from having to worry about
+    // the boolean value. Externally, it should be seen as the
+    // set of all names.
+    return {
+        has: name => uniques.has(name),
+        add: name => uniques.set(name, true),
+    };
+}
+function getSymbolCompletionFromEntryId(program, log, sourceFile, position, entryId, host, preferences) {
+    const completionData = getCompletionData(program, log, sourceFile, position, { includeCompletionsForModuleExports: true, includeCompletionsWithInsertText: true }, entryId, host);
+    if (!completionData) {
+        return { type: "none" };
+    }
+    const { symbols, literals, location, completionKind, symbolToOriginInfoMap, previousToken, isJsxInitializer, isTypeOnlyLocation } = completionData;
+    const literal = find(literals, l => completionNameForLiteral(l, preferences) === entryId.name);
+    if (literal !== undefined)
+        return { type: "literal", literal };
+    // 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.
+    return firstDefined(symbols, (symbol) => {
+        const origin = symbolToOriginInfoMap[getSymbolId(symbol)];
+        const info = getCompletionEntryDisplayNameForSymbol(symbol, languageVersion, origin, completionKind, completionData.isJsxIdentifierExpected);
+        return info && info.name === entryId.name && getSourceFromOrigin(origin) === entryId.source
+            ? { type: "symbol", symbol, location, symbolToOriginInfoMap, previousToken, isJsxInitializer, isTypeOnlyLocation }
+            : undefined;
+    }) || { type: "none" };
+}
+/**
+ * O detalhe de um item do completion. Na tag, quem chama monta o contexto de formatação, que só a ação do auto-import
+ * usa; aqui, as opções de formatação seguem cruas até o auto-import da edição, que monta o contexto (CK-67).
+ */
+export function getCompletionEntryDetails(program, log, sourceFile, position, entryId, host, formatOptions, preferences, cancellationToken) {
+    const typeChecker = program.getTypeChecker();
+    const { name } = entryId;
+    const contextToken = findPrecedingToken(position, sourceFile);
+    if (isInString(sourceFile, position, contextToken)) {
+        return StringCompletions.getStringLiteralCompletionDetails(name, sourceFile, position, contextToken, typeChecker, host, cancellationToken);
+    }
+    // Todos os símbolos do completion, calculados de novo.
+    const symbolCompletion = getSymbolCompletionFromEntryId(program, log, sourceFile, position, entryId, host, preferences);
+    switch (symbolCompletion.type) {
+        case "symbol": {
+            const { symbol, location, symbolToOriginInfoMap, previousToken } = symbolCompletion;
+            const { codeActions, sourceDisplay } = getCompletionEntryCodeActionsAndSourceDisplay(symbolToOriginInfoMap, symbol, program, typeChecker, host, sourceFile, position, previousToken, formatOptions, preferences);
+            return createCompletionDetailsForSymbol(symbol, typeChecker, sourceFile, location, cancellationToken, codeActions, sourceDisplay); // TODO: GH#18217
+        }
+        case "literal": {
+            const { literal } = symbolCompletion;
+            return createSimpleDetails(completionNameForLiteral(literal, preferences), "string" /* ScriptElementKind.string */, typeof literal === "string" ? SymbolDisplayPartKind.stringLiteral : SymbolDisplayPartKind.numericLiteral);
+        }
+        case "none":
+            // Didn't find a symbol with this name.  See if we can find a keyword instead.
+            return allKeywordsCompletions().some(c => c.name === name) ? createSimpleDetails(name, "keyword" /* ScriptElementKind.keyword */, SymbolDisplayPartKind.keyword) : undefined;
+        default:
+            Debug.assertNever(symbolCompletion);
+    }
+}
+function createSimpleDetails(name, kind, kind2) {
+    return createCompletionDetails(name, "" /* ScriptElementKindModifier.none */, kind, [displayPart(name, kind2)]);
+}
+export function createCompletionDetailsForSymbol(symbol, checker, sourceFile, location, cancellationToken, codeActions, sourceDisplay) {
+    const { displayParts, documentation, symbolKind, tags } = checker.runWithCancellationToken(cancellationToken, checker => SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, sourceFile, location, location, 7 /* SemanticMeaning.All */));
+    return createCompletionDetails(symbol.name, SymbolDisplay.getSymbolModifiers(symbol), symbolKind, displayParts, documentation, tags, codeActions, sourceDisplay);
+}
+export function createCompletionDetails(name, kindModifiers, kind, displayParts, documentation, tags, codeActions, source) {
+    return { name, kindModifiers, kind, displayParts, documentation, tags, codeActions, source };
+}
+function getCompletionEntryCodeActionsAndSourceDisplay(symbolToOriginInfoMap, symbol, program, checker, host, sourceFile, position, previousToken, formatOptions, preferences) {
+    const symbolOriginInfo = symbolToOriginInfoMap[getSymbolId(symbol)];
+    // A origem de um módulo só existe com o auto-import, e o auto-import, com a edição registrada (CK-67).
+    if (!symbolOriginInfo || !originIsExport(symbolOriginInfo) || !autoImportProvider) {
+        return { codeActions: undefined, sourceDisplay: undefined };
+    }
+    const { moduleSymbol } = symbolOriginInfo;
+    const exportedSymbol = checker.getMergedSymbol(skipAlias(symbol.exportSymbol || symbol, checker));
+    const { moduleSpecifier, codeAction } = autoImportProvider.getImportCompletionAction(exportedSymbol, moduleSymbol, sourceFile, getNameForExportedSymbol(symbol, languageVersion), host, program, formatOptions, previousToken && isIdentifier(previousToken) ? previousToken.getStart(sourceFile) : position, preferences);
+    return { sourceDisplay: [textPart(moduleSpecifier)], codeActions: [codeAction] };
+}
+export function getCompletionEntrySymbol(program, log, sourceFile, position, entryId, host, preferences) {
+    const completion = getSymbolCompletionFromEntryId(program, log, sourceFile, position, entryId, host, preferences);
+    return completion.type === "symbol" ? completion.symbol : undefined;
+}
+export var CompletionKind;
+(function (CompletionKind) {
+    CompletionKind[CompletionKind["ObjectPropertyDeclaration"] = 0] = "ObjectPropertyDeclaration";
+    CompletionKind[CompletionKind["Global"] = 1] = "Global";
+    CompletionKind[CompletionKind["PropertyAccess"] = 2] = "PropertyAccess";
+    CompletionKind[CompletionKind["MemberLike"] = 3] = "MemberLike";
+    CompletionKind[CompletionKind["String"] = 4] = "String";
+    CompletionKind[CompletionKind["None"] = 5] = "None";
+})(CompletionKind || (CompletionKind = {}));
+function getContextualType(previousToken, position, sourceFile, checker) {
+    const { parent } = previousToken;
+    switch (previousToken.kind) {
+        case SyntaxKind.Identifier:
+            return getContextualTypeFromParent(previousToken, checker);
+        case SyntaxKind.EqualsToken:
+            switch (parent.kind) {
+                case SyntaxKind.VariableDeclaration:
+                    return checker.getContextualType(parent.initializer); // TODO: GH#18217
+                case SyntaxKind.BinaryExpression:
+                    return checker.getTypeAtLocation(parent.left);
+                case SyntaxKind.JsxAttribute:
+                    return checker.getContextualTypeForJsxAttribute(parent);
+                default:
+                    return undefined;
+            }
+        case SyntaxKind.CaseKeyword:
+            return getSwitchedType(cast(parent, isCaseClause), checker);
+        case SyntaxKind.OpenBraceToken:
+            return isJsxExpression(parent) && parent.parent.kind !== SyntaxKind.JsxElement ? checker.getContextualTypeForJsxAttribute(parent.parent) : undefined;
+        default:
+            const argInfo = SignatureHelp.getArgumentInfoForCompletions(previousToken, position, sourceFile);
+            return argInfo ?
+                // At `,`, treat this as the next argument after the comma.
+                checker.getContextualTypeForArgumentAtIndex(argInfo.invocation, argInfo.argumentIndex + (previousToken.kind === SyntaxKind.CommaToken ? 1 : 0)) :
+                isEqualityOperatorKind(previousToken.kind) && isBinaryExpression(parent) && isEqualityOperatorKind(parent.operatorToken.kind) ?
+                    // o completion em `x ==/**/` é o do lado direito
+                    checker.getTypeAtLocation(parent.left) :
+                    checker.getContextualType(previousToken);
+    }
+}
+function getFirstSymbolInChain(symbol, enclosingDeclaration, checker) {
+    const chain = checker.getAccessibleSymbolChain(symbol, enclosingDeclaration, /*meaning*/ SymbolFlags.All, /*useOnlyExternalAliasing*/ false);
+    if (chain)
+        return first(chain);
+    return symbol.parent && (isModuleSymbol(symbol.parent) ? symbol : getFirstSymbolInChain(symbol.parent, enclosingDeclaration, checker));
+}
+function isModuleSymbol(symbol) {
+    return symbol.declarations.some(d => d.kind === SyntaxKind.SourceFile);
+}
+function getCompletionData(program, log, sourceFile, position, preferences, detailsEntryId, host) {
+    const typeChecker = program.getTypeChecker();
+    let start = timestamp();
+    const currentToken = getTokenAtPosition(sourceFile, position);
+    log("getCompletionData: Get current token: " + (timestamp() - start));
+    start = timestamp();
+    const insideComment = isInComment(sourceFile, position, currentToken);
+    log("getCompletionData: Is inside comment: " + (timestamp() - start));
+    let isInSnippetScope = false;
+    // Dentro de um comentário não há completion. Na tag, o comentário do JSDoc tinha o das tags e o do tipo de uma tag,
+    // e a cópia não tem o JSDoc (CK-03).
+    if (insideComment) {
+        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); // TODO: GH#18217
+    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 && (isIdentifier(contextToken) || isKeyword(contextToken.kind))) {
+        const start = timestamp();
+        contextToken = findPrecedingToken(contextToken.getFullStart(), sourceFile, /*startNode*/ undefined); // TODO: GH#18217
+        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 propertyAccessToConvert;
+    let isRightOfDot = false;
+    let isRightOfQuestionDot = false;
+    let isRightOfOpenTag = false;
+    let isStartingCloseTag = false;
+    let isJsxInitializer = false;
+    let isJsxIdentifierExpected = false;
+    let location = getTouchingPropertyName(sourceFile, position);
+    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 || contextToken.kind === SyntaxKind.QuestionDotToken) {
+            isRightOfDot = contextToken.kind === SyntaxKind.DotToken;
+            isRightOfQuestionDot = contextToken.kind === SyntaxKind.QuestionDotToken;
+            switch (parent.kind) {
+                case SyntaxKind.PropertyAccessExpression:
+                    propertyAccessToConvert = parent;
+                    node = propertyAccessToConvert.expression;
+                    if (node.end === contextToken.pos &&
+                        isCallExpression(node) &&
+                        node.getChildCount(sourceFile) &&
+                        last(node.getChildren(sourceFile)).kind !== SyntaxKind.CloseParenToken) {
+                        // This is likely dot from incorrectly parsed call expression and user is starting to write spread
+                        // eg: Math.min(./**/)
+                        return undefined;
+                    }
+                    break;
+                case SyntaxKind.QualifiedName:
+                    node = parent.left;
+                    break;
+                case SyntaxKind.ModuleDeclaration:
+                    node = parent.name;
+                    break;
+                case SyntaxKind.ImportType:
+                    node = parent;
+                    break;
+                default:
+                    // 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;
+            }
+            // Fix location
+            if (currentToken.parent === location) {
+                switch (currentToken.kind) {
+                    case SyntaxKind.GreaterThanToken:
+                        if (currentToken.parent.kind === SyntaxKind.JsxElement || currentToken.parent.kind === SyntaxKind.JsxOpeningElement) {
+                            location = currentToken;
+                        }
+                        break;
+                    case SyntaxKind.SlashToken:
+                        if (currentToken.parent.kind === SyntaxKind.JsxSelfClosingElement) {
+                            location = currentToken;
+                        }
+                        break;
+                }
+            }
+            switch (parent.kind) {
+                case SyntaxKind.JsxClosingElement:
+                    if (contextToken.kind === SyntaxKind.SlashToken) {
+                        isStartingCloseTag = true;
+                        location = contextToken;
+                    }
+                    break;
+                case SyntaxKind.BinaryExpression:
+                    if (!binaryExpressionMayBeOpenTag(parent)) {
+                        break;
+                    }
+                // falls through
+                case SyntaxKind.JsxSelfClosingElement:
+                case SyntaxKind.JsxElement:
+                case SyntaxKind.JsxOpeningElement:
+                    isJsxIdentifierExpected = true;
+                    if (contextToken.kind === SyntaxKind.LessThanToken) {
+                        isRightOfOpenTag = true;
+                        location = contextToken;
+                    }
+                    break;
+                case SyntaxKind.JsxAttribute:
+                    switch (previousToken.kind) {
+                        case SyntaxKind.EqualsToken:
+                            isJsxInitializer = true;
+                            break;
+                        case SyntaxKind.Identifier:
+                            isJsxIdentifierExpected = true;
+                            // For `<div x=[|f/**/|]`, `parent` will be `x` and `previousToken.parent` will be `f` (which is its own JsxAttribute)
+                            // Note for `<div someBool f>` we don't want to treat this as a jsx inializer, instead it's the attribute name.
+                            if (parent !== previousToken.parent &&
+                                !parent.initializer &&
+                                findChildOfKind(parent, SyntaxKind.EqualsToken, sourceFile)) {
+                                isJsxInitializer = previousToken;
+                            }
+                    }
+                    break;
+            }
+        }
+    }
+    const semanticStart = timestamp();
+    let completionKind = 5 /* CompletionKind.None */;
+    let isNewIdentifierLocation = false;
+    let keywordFilters = 0 /* KeywordCompletionFilters.None */;
+    // This also gets mutated in nested-functions after the return
+    let symbols = [];
+    const symbolToOriginInfoMap = [];
+    const symbolToSortTextMap = [];
+    const isTypeOnly = isTypeOnlyCompletion();
+    if (isRightOfDot || isRightOfQuestionDot) {
+        getTypeScriptMemberSymbols();
+    }
+    else if (isRightOfOpenTag) {
+        const tagSymbols = typeChecker.getJsxIntrinsicTagNamesAt(location);
+        Debug.assertEachIsDefined(tagSymbols, "getJsxIntrinsicTagNames() should all be defined");
+        tryGetGlobalSymbols();
+        symbols = tagSymbols.concat(symbols);
+        completionKind = 3 /* CompletionKind.MemberLike */;
+        keywordFilters = 0 /* KeywordCompletionFilters.None */;
+    }
+    else if (isStartingCloseTag) {
+        const tagName = contextToken.parent.parent.openingElement.tagName;
+        const tagSymbol = typeChecker.getSymbolAtLocation(tagName);
+        if (tagSymbol) {
+            symbols = [tagSymbol];
+        }
+        completionKind = 3 /* CompletionKind.MemberLike */;
+        keywordFilters = 0 /* KeywordCompletionFilters.None */;
+    }
+    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));
+    const contextualType = previousToken && getContextualType(previousToken, position, sourceFile, typeChecker);
+    const literals = mapDefined(contextualType && (contextualType.isUnion() ? contextualType.types : [contextualType]), t => t.isLiteral() ? t.value : undefined);
+    // Na tag, o tipo esperado dava também o item recomendado, que só o enum e a classe davam (CK-02).
+    return {
+        symbols,
+        completionKind,
+        isInSnippetScope,
+        propertyAccessToConvert,
+        isNewIdentifierLocation,
+        location,
+        keywordFilters,
+        literals,
+        symbolToOriginInfoMap,
+        previousToken,
+        isJsxInitializer,
+        symbolToSortTextMap,
+        isTypeOnlyLocation: isTypeOnly,
+        isJsxIdentifierExpected,
+    };
+    function getTypeScriptMemberSymbols() {
+        // Right of dot member completion list
+        completionKind = 2 /* CompletionKind.PropertyAccess */;
+        // Since this is qualified name check it's a type node location
+        const isImportType = isLiteralImportTypeNode(node);
+        const isTypeLocation = (isImportType && !node.isTypeOf)
+            || isPartOfTypeNode(node.parent)
+            || isPossiblyTypeArgumentPosition(contextToken, sourceFile, typeChecker);
+        if (isEntityName(node) || isImportType) {
+            const isNamespaceName = isModuleDeclaration(node.parent);
+            if (isNamespaceName)
+                isNewIdentifierLocation = true;
+            let symbol = typeChecker.getSymbolAtLocation(node);
+            if (symbol) {
+                symbol = skipAlias(symbol, typeChecker);
+                if (symbol.flags & SymbolFlags.Module) {
+                    // os membros do módulo
+                    const exportedSymbols = typeChecker.getExportsOfModule(symbol);
+                    Debug.assertEachIsDefined(exportedSymbols, "getExportsOfModule() should all be defined");
+                    const isValidValueAccess = (symbol) => typeChecker.isValidPropertyAccess(isImportType ? node : (node.parent), symbol.name);
+                    const isValidTypeAccess = (symbol) => symbolCanBeReferencedAtTypeLocation(symbol);
+                    const isValidAccess = isNamespaceName
+                        // At `namespace N.M/**/`, if this is the only declaration of `M`, don't include `M` as a completion.
+                        ? symbol => !!(symbol.flags & SymbolFlags.Namespace) && !symbol.declarations.every(d => d.parent === node.parent)
+                        : isTypeLocation ? isValidTypeAccess : isValidValueAccess;
+                    for (const exportedSymbol of exportedSymbols) {
+                        if (isValidAccess(exportedSymbol)) {
+                            symbols.push(exportedSymbol);
+                        }
+                    }
+                    // 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 &&
+                        symbol.declarations.some(d => d.kind !== SyntaxKind.SourceFile && d.kind !== SyntaxKind.ModuleDeclaration)) {
+                        let type = typeChecker.getTypeOfSymbolAtLocation(symbol, node).getNonOptionalType();
+                        let insertQuestionDot = false;
+                        if (type.isNullableType()) {
+                            const canCorrectToQuestionDot = isRightOfDot &&
+                                !isRightOfQuestionDot &&
+                                preferences.includeAutomaticOptionalChainCompletions !== false;
+                            if (canCorrectToQuestionDot || isRightOfQuestionDot) {
+                                type = type.getNonNullableType();
+                                if (canCorrectToQuestionDot) {
+                                    insertQuestionDot = true;
+                                }
+                            }
+                        }
+                        addTypeProperties(type, !!(node.flags & NodeFlags.AwaitContext), insertQuestionDot);
+                    }
+                    return;
+                }
+            }
+        }
+        if (!isTypeLocation) {
+            let type = typeChecker.getTypeAtLocation(node).getNonOptionalType();
+            let insertQuestionDot = false;
+            if (type.isNullableType()) {
+                const canCorrectToQuestionDot = isRightOfDot &&
+                    !isRightOfQuestionDot &&
+                    preferences.includeAutomaticOptionalChainCompletions !== false;
+                if (canCorrectToQuestionDot || isRightOfQuestionDot) {
+                    type = type.getNonNullableType();
+                    if (canCorrectToQuestionDot) {
+                        insertQuestionDot = true;
+                    }
+                }
+            }
+            addTypeProperties(type, !!(node.flags & NodeFlags.AwaitContext), insertQuestionDot);
+        }
+    }
+    function addTypeProperties(type, insertAwait, insertQuestionDot) {
+        isNewIdentifierLocation = !!type.getStringIndexType();
+        if (isRightOfQuestionDot && some(type.getCallSignatures())) {
+            isNewIdentifierLocation = true;
+        }
+        const propertyAccess = node.kind === SyntaxKind.ImportType ? node : node.parent;
+        for (const symbol of type.getApparentProperties()) {
+            if (typeChecker.isValidPropertyAccessForCompletions(propertyAccess, type, symbol)) {
+                addPropertySymbol(symbol, /*insertAwait*/ false, insertQuestionDot);
+            }
+        }
+        if (insertAwait && preferences.includeCompletionsWithInsertText) {
+            const promiseType = typeChecker.getPromisedTypeOfPromise(type);
+            if (promiseType) {
+                for (const symbol of promiseType.getApparentProperties()) {
+                    if (typeChecker.isValidPropertyAccessForCompletions(propertyAccess, promiseType, symbol)) {
+                        addPropertySymbol(symbol, /* insertAwait */ true, insertQuestionDot);
+                    }
+                }
+            }
+        }
+    }
+    function addPropertySymbol(symbol, insertAwait, insertQuestionDot) {
+        // For a computed property with an accessible name like `Symbol.iterator`,
+        // we'll add a completion for the *name* `Symbol` instead of for the property.
+        // If this is e.g. [Symbol.iterator], add a completion for `Symbol`.
+        const computedPropertyName = firstDefined(symbol.declarations, decl => tryCast(getNameOfDeclaration(decl), isComputedPropertyName));
+        if (computedPropertyName) {
+            const leftMostName = getLeftMostName(computedPropertyName.expression); // The completion is for `Symbol`, not `iterator`.
+            const nameSymbol = leftMostName && typeChecker.getSymbolAtLocation(leftMostName);
+            // If this is nested like for `namespace N { export const sym = Symbol(); }`, we'll add the completion for `N`.
+            const firstAccessibleSymbol = nameSymbol && getFirstSymbolInChain(nameSymbol, contextToken, typeChecker);
+            if (firstAccessibleSymbol && !symbolToOriginInfoMap[getSymbolId(firstAccessibleSymbol)]) {
+                symbols.push(firstAccessibleSymbol);
+                const moduleSymbol = firstAccessibleSymbol.parent;
+                symbolToOriginInfoMap[getSymbolId(firstAccessibleSymbol)] =
+                    !moduleSymbol || !isExternalModuleSymbol(moduleSymbol)
+                        ? { kind: getNullableSymbolOriginInfoKind(2 /* SymbolOriginInfoKind.SymbolMemberNoExport */) }
+                        : { kind: getNullableSymbolOriginInfoKind(6 /* SymbolOriginInfoKind.SymbolMemberExport */), moduleSymbol, isDefaultExport: false };
+            }
+            else if (preferences.includeCompletionsWithInsertText) {
+                addSymbolOriginInfo(symbol);
+                symbols.push(symbol);
+            }
+        }
+        else {
+            addSymbolOriginInfo(symbol);
+            symbols.push(symbol);
+        }
+        function addSymbolOriginInfo(symbol) {
+            if (preferences.includeCompletionsWithInsertText) {
+                if (insertAwait && !symbolToOriginInfoMap[getSymbolId(symbol)]) {
+                    symbolToOriginInfoMap[getSymbolId(symbol)] = { kind: getNullableSymbolOriginInfoKind(8 /* SymbolOriginInfoKind.Promise */) };
+                }
+                else if (insertQuestionDot) {
+                    symbolToOriginInfoMap[getSymbolId(symbol)] = { kind: 16 /* SymbolOriginInfoKind.Nullable */ };
+                }
+            }
+        }
+        function getNullableSymbolOriginInfoKind(kind) {
+            return insertQuestionDot ? kind | 16 /* SymbolOriginInfoKind.Nullable */ : kind;
+        }
+    }
+    /** Given 'a.b.c', returns 'a'. */
+    function getLeftMostName(e) {
+        return isIdentifier(e) ? e : isPropertyAccessExpression(e) ? getLeftMostName(e.expression) : undefined;
+    }
+    function tryGetGlobalSymbols() {
+        const result = tryGetObjectLikeCompletionSymbols()
+            || tryGetImportOrExportClauseCompletionSymbols()
+            || tryGetLocalNamedExportCompletionSymbols()
+            || tryGetClassLikeCompletionSymbols()
+            || tryGetJsxCompletionSymbols()
+            || (getGlobalCompletions(), 1 /* GlobalsSearch.Success */);
+        return result === 1 /* GlobalsSearch.Success */;
+    }
+    function tryGetJsxCompletionSymbols() {
+        const jsxContainer = tryGetContainingJsxElement(contextToken);
+        // Cursor is inside a JSX self-closing element or opening element
+        const attrsType = jsxContainer && typeChecker.getContextualType(jsxContainer.attributes);
+        if (!attrsType)
+            return 0 /* GlobalsSearch.Continue */;
+        const completionsType = jsxContainer && typeChecker.getContextualType(jsxContainer.attributes, ContextFlags.Completions);
+        symbols = filterJsxAttributes(getPropertiesForObjectExpression(attrsType, completionsType, jsxContainer.attributes, typeChecker), jsxContainer.attributes.properties);
+        setSortTextToOptionalMember();
+        completionKind = 3 /* CompletionKind.MemberLike */;
+        isNewIdentifierLocation = false;
+        return 1 /* GlobalsSearch.Success */;
+    }
+    function getGlobalCompletions() {
+        keywordFilters = tryGetFunctionLikeBodyCompletionContainer(contextToken) ? 3 /* KeywordCompletionFilters.FunctionLikeBodyKeywords */ : 1 /* KeywordCompletionFilters.All */;
+        // Get all entities in the current scope.
+        completionKind = 1 /* CompletionKind.Global */;
+        isNewIdentifierLocation = isNewIdentifierDefinitionLocation(contextToken);
+        if (previousToken !== contextToken) {
+            Debug.assert(!!previousToken, "Expected 'contextToken' to be defined when different from 'previousToken'.");
+        }
+        // We need to find the node that will give us an appropriate scope to begin
+        // aggregating completion candidates. This is achieved in 'getScopeNode'
+        // by finding the first node that encompasses a position, accounting for whether a node
+        // is "complete" to decide whether a position belongs to the node.
+        //
+        // However, at the end of an identifier, we are interested in the scope of the identifier
+        // itself, but fall outside of the identifier. For instance:
+        //
+        //      xyz => x$
+        //
+        // the cursor is outside of both the 'x' and the arrow function 'xyz => x',
+        // so 'xyz' is not returned in our results.
+        //
+        // We define 'adjustedPosition' so that we may appropriately account for
+        // being at the end of an identifier. The intention is that if requesting completion
+        // at the end of an identifier, it should be effectively equivalent to requesting completion
+        // anywhere inside/at the beginning of the identifier. So in the previous case, the
+        // 'adjustedPosition' will work as if requesting completion in the following:
+        //
+        //      xyz => $x
+        //
+        // If previousToken !== contextToken, then
+        //   - 'contextToken' was adjusted to the token prior to 'previousToken'
+        //      because we were at the end of an identifier.
+        //   - 'previousToken' is defined.
+        const adjustedPosition = previousToken !== contextToken ?
+            previousToken.getStart() :
+            position;
+        const scopeNode = getScopeNode(contextToken, adjustedPosition, sourceFile) || sourceFile;
+        isInSnippetScope = isSnippetScope(scopeNode);
+        const symbolMeanings = (isTypeOnly ? SymbolFlags.None : SymbolFlags.Value) | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias;
+        symbols = typeChecker.getSymbolsInScope(scopeNode, symbolMeanings);
+        Debug.assertEachIsDefined(symbols, "getSymbolsInScope() should all be defined");
+        for (const symbol of symbols) {
+            if (!some(symbol.declarations, d => d.getSourceFile() === sourceFile)) {
+                symbolToSortTextMap[getSymbolId(symbol)] = SortText.GlobalsOrKeywords;
+            }
+        }
+        if (shouldOfferImportCompletions()) {
+            const lowerCaseTokenText = previousToken && isIdentifier(previousToken) ? previousToken.text.toLowerCase() : "";
+            const autoImportSuggestions = getSymbolsFromOtherSourceFileExports(languageVersion, host);
+            autoImportSuggestions.forEach(({ symbol, symbolName, skipFilter, origin }) => {
+                if (detailsEntryId) {
+                    if (detailsEntryId.source && stripQuotes(origin.moduleSymbol.name) !== detailsEntryId.source) {
+                        return;
+                    }
+                }
+                else if (!skipFilter && !stringContainsCharactersInOrder(symbolName.toLowerCase(), lowerCaseTokenText)) {
+                    return;
+                }
+                const symbolId = getSymbolId(symbol);
+                symbols.push(symbol);
+                symbolToOriginInfoMap[symbolId] = origin;
+                symbolToSortTextMap[symbolId] = SortText.AutoImportSuggestions;
+            });
+        }
+        filterGlobalCompletion(symbols);
+    }
+    function shouldOfferImportCompletions() {
+        if (!preferences.includeCompletionsForModuleExports)
+            return false;
+        // O auto-import monta a edição do import, e só existe com a edição registrada (CK-67).
+        if (!autoImportProvider)
+            return false;
+        // Na tag, a conferência seguia pelo módulo do arquivo e pelas opções. O alvo da configuração fixa já indica os
+        // módulos ES (o `compilerOptionsIndicateEs6Modules` dele é verdadeiro), e a conferência sempre aceita (CK-24).
+        return true;
+    }
+    function isSnippetScope(scopeNode) {
+        switch (scopeNode.kind) {
+            case SyntaxKind.SourceFile:
+            case SyntaxKind.TemplateExpression:
+            case SyntaxKind.JsxExpression:
+            case SyntaxKind.Block:
+                return true;
+            default:
+                return isStatement(scopeNode);
+        }
+    }
+    function filterGlobalCompletion(symbols) {
+        const isTypeOnly = isTypeOnlyCompletion();
+        if (isTypeOnly) {
+            keywordFilters = isTypeAssertion()
+                ? 4 /* KeywordCompletionFilters.TypeAssertionKeywords */
+                : 5 /* KeywordCompletionFilters.TypeKeywords */;
+        }
+        filterMutate(symbols, symbol => {
+            if (!isSourceFile(location)) {
+                // export default /**/ aceita todo significado
+                if (isExportAssignment(location.parent)) {
+                    return true;
+                }
+                symbol = skipAlias(symbol, typeChecker);
+                if (isTypeOnly) {
+                    // It's a type, but you can reach it by namespace.type as well
+                    return symbolCanBeReferencedAtTypeLocation(symbol);
+                }
+            }
+            // expressions are value space (which includes the value namespaces)
+            return !!(getCombinedLocalAndExportSymbolFlags(symbol) & SymbolFlags.Value);
+        });
+    }
+    function isTypeAssertion() {
+        return isAssertionExpression(contextToken.parent);
+    }
+    function isTypeOnlyCompletion() {
+        return !isContextTokenValueLocation(contextToken) &&
+            (isPossiblyTypeArgumentPosition(contextToken, sourceFile, typeChecker)
+                || isPartOfTypeNode(location)
+                || isContextTokenTypeLocation(contextToken));
+    }
+    function isContextTokenValueLocation(contextToken) {
+        return contextToken &&
+            contextToken.kind === SyntaxKind.TypeOfKeyword &&
+            (contextToken.parent.kind === SyntaxKind.TypeQuery || isTypeOfExpression(contextToken.parent));
+    }
+    function isContextTokenTypeLocation(contextToken) {
+        if (contextToken) {
+            const parentKind = contextToken.parent.kind;
+            switch (contextToken.kind) {
+                case SyntaxKind.ColonToken:
+                    return parentKind === SyntaxKind.PropertySignature ||
+                        parentKind === SyntaxKind.Parameter ||
+                        parentKind === SyntaxKind.VariableDeclaration ||
+                        isFunctionLikeKind(parentKind);
+                case SyntaxKind.EqualsToken:
+                    return parentKind === SyntaxKind.TypeAliasDeclaration;
+                case SyntaxKind.AsKeyword:
+                    return parentKind === SyntaxKind.AsExpression;
+                case SyntaxKind.LessThanToken:
+                    return parentKind === SyntaxKind.TypeReference;
+                case SyntaxKind.ExtendsKeyword:
+                    return parentKind === SyntaxKind.TypeParameter;
+            }
+        }
+        return false;
+    }
+    /** True if symbol is a type or a module containing at least one type. */
+    function symbolCanBeReferencedAtTypeLocation(symbol, seenModules = createMap()) {
+        const sym = skipAlias(symbol.exportSymbol || symbol, typeChecker);
+        return !!(sym.flags & SymbolFlags.Type) ||
+            !!(sym.flags & SymbolFlags.Module) &&
+                addToSeen(seenModules, getSymbolId(sym)) &&
+                typeChecker.getExportsOfModule(sym).some(e => symbolCanBeReferencedAtTypeLocation(e, seenModules));
+    }
+    /**
+     * Gathers symbols that can be imported from other files, de-duplicating along the way. Symbols can be "duplicates"
+     * if re-exported from another module, e.g. `export { foo } from "./a"`. That syntax creates a fresh symbol, but
+     * it’s just an alias to the first, and both have the same name, so we generally want to filter those aliases out,
+     * if and only if the the first can be imported (it may be excluded due to package.json filtering in
+     * `codefix.forEachExternalModuleToImportFrom`).
+     *
+     * Example. Imagine a chain of node_modules re-exporting one original symbol:
+     *
+     * ```js
+     *  node_modules/x/index.js         node_modules/y/index.js           node_modules/z/index.js
+     * +-----------------------+      +--------------------------+      +--------------------------+
+     * |                       |      |                          |      |                          |
+     * | export const foo = 0; | <--- | export { foo } from 'x'; | <--- | export { foo } from 'y'; |
+     * |                       |      |                          |      |                          |
+     * +-----------------------+      +--------------------------+      +--------------------------+
+     * ```
+     *
+     * Also imagine three buckets, which we’ll reference soon:
+     *
+     * ```md
+     * |                  |      |                      |      |                   |
+     * |   **Bucket A**   |      |    **Bucket B**      |      |    **Bucket C**   |
+     * |    Symbols to    |      | Aliases to symbols   |      | Symbols to return |
+     * |    definitely    |      | in Buckets A or C    |      | if nothing better |
+     * |      return      |      | (don’t return these) |      |    comes along    |
+     * |__________________|      |______________________|      |___________________|
+     * ```
+     *
+     * We _probably_ want to show `foo` from 'x', but not from 'y' or 'z'. However, if 'x' is not in a package.json, it
+     * will not appear in a `forEachExternalModuleToImportFrom` iteration. Furthermore, the order of iterations is not
+     * guaranteed, as it is host-dependent. Therefore, when presented with the symbol `foo` from module 'y' alone, we
+     * may not be sure whether or not it should go in the list. So, we’ll take the following steps:
+     *
+     * 1. Resolve alias `foo` from 'y' to the export declaration in 'x', get the symbol there, and see if that symbol is
+     *    already in Bucket A (symbols we already know will be returned). If it is, put `foo` from 'y' in Bucket B
+     *    (symbols that are aliases to symbols in Bucket A). If it’s not, put it in Bucket C.
+     * 2. Next, imagine we see `foo` from module 'z'. Again, we resolve the alias to the nearest export, which is in 'y'.
+     *    At this point, if that nearest export from 'y' is in _any_ of the three buckets, we know the symbol in 'z'
+     *    should never be returned in the final list, so put it in Bucket B.
+     * 3. Next, imagine we see `foo` from module 'x', the original. Syntactically, it doesn’t look like a re-export, so
+     *    we can just check Bucket C to see if we put any aliases to the original in there. If they exist, throw them out.
+     *    Put this symbol in Bucket A.
+     * 4. After we’ve iterated through every symbol of every module, any symbol left in Bucket C means that step 3 didn’t
+     *    occur for that symbol---that is, the original symbol is not in Bucket A, so we should include the alias. Move
+     *    everything from Bucket C to Bucket A.
+     */
+    function getSymbolsFromOtherSourceFileExports(target, host) {
+        const startTime = timestamp();
+        log(`getSymbolsFromOtherSourceFileExports: Recomputing list${detailsEntryId ? " for details entry" : ""}`);
+        const seenResolvedModules = createMap();
+        const seenExports = createMap();
+        /** Bucket B */
+        const aliasesToAlreadyIncludedSymbols = createMap();
+        /** Bucket C */
+        const aliasesToReturnIfOriginalsAreMissing = createMap();
+        /** Bucket A */
+        const results = [];
+        /** Ids present in `results` for faster lookup */
+        const resultSymbolIds = createMap();
+        autoImportProvider.forEachExternalModuleToImportFrom(program, host, sourceFile, moduleSymbol => {
+            // Perf -- ignore other modules if this is a request for details
+            if (detailsEntryId && detailsEntryId.source && stripQuotes(moduleSymbol.name) !== detailsEntryId.source) {
+                return;
+            }
+            // Na tag, o alvo do módulo podia ser o valor do `export =`, que vários módulos podiam exportar, e entrava como item
+            // próprio; sem o `export =`, o alvo é o próprio módulo (CK-03).
+            if (!addToSeen(seenResolvedModules, getSymbolId(moduleSymbol))) {
+                return;
+            }
+            for (const symbol of typeChecker.getExportsAndPropertiesOfModule(moduleSymbol)) {
+                const symbolId = getSymbolId(symbol).toString();
+                // `getExportsAndPropertiesOfModule` can include duplicates
+                if (!addToSeen(seenExports, symbolId)) {
+                    continue;
+                }
+                // If this is `export { _break as break };` (a keyword) -- skip this and prefer the keyword completion.
+                if (some(symbol.declarations, d => isExportSpecifier(d) && !!d.propertyName && isIdentifierANonContextualKeyword(d.name))) {
+                    continue;
+                }
+                // If `symbol.parent !== moduleSymbol`, this is an `export * from "foo"` re-export. Those don't create new symbols.
+                const isExportStarFromReExport = typeChecker.getMergedSymbol(symbol.parent) !== moduleSymbol;
+                // If `!!d.parent.parent.moduleSpecifier`, this is `export { foo } from "foo"` re-export, which creates a new symbol (thus isn't caught by the first check).
+                if (isExportStarFromReExport || some(symbol.declarations, d => isExportSpecifier(d) && !d.propertyName && !!d.parent.parent.moduleSpecifier)) {
+                    // Walk the export chain back one module (step 1 or 2 in diagrammed example).
+                    // Or, in the case of `export * from "foo"`, `symbol` already points to the original export, so just use that.
+                    const nearestExportSymbol = isExportStarFromReExport ? symbol : getNearestExportSymbol(symbol);
+                    if (!nearestExportSymbol)
+                        continue;
+                    const nearestExportSymbolId = getSymbolId(nearestExportSymbol).toString();
+                    const symbolHasBeenSeen = resultSymbolIds.has(nearestExportSymbolId) || aliasesToAlreadyIncludedSymbols.has(nearestExportSymbolId);
+                    if (!symbolHasBeenSeen) {
+                        aliasesToReturnIfOriginalsAreMissing.set(nearestExportSymbolId, { alias: symbol, moduleSymbol });
+                        aliasesToAlreadyIncludedSymbols.set(symbolId, true);
+                    }
+                    else {
+                        // Perf - we know this symbol is an alias to one that’s already covered in `symbols`, so store it here
+                        // in case another symbol re-exports this one; that way we can short-circuit as soon as we see this symbol id.
+                        addToSeen(aliasesToAlreadyIncludedSymbols, symbolId);
+                    }
+                }
+                else {
+                    // This is not a re-export, so see if we have any aliases pending and remove them (step 3 in diagrammed example)
+                    aliasesToReturnIfOriginalsAreMissing.delete(symbolId);
+                    pushSymbol(symbol, moduleSymbol);
+                }
+            }
+        });
+        // By this point, any potential duplicates that were actually duplicates have been
+        // removed, so the rest need to be added. (Step 4 in diagrammed example)
+        aliasesToReturnIfOriginalsAreMissing.forEach(({ alias, moduleSymbol }) => pushSymbol(alias, moduleSymbol));
+        log(`getSymbolsFromOtherSourceFileExports: ${timestamp() - startTime}`);
+        return results;
+        function pushSymbol(symbol, moduleSymbol, skipFilter = false) {
+            // Na tag, o `default` de uma declaração exportada dava o símbolo local dela; o modificador saiu com a `function` e a
+            // classe (CK-02), e o `export default` que fica é de expressão, sem símbolo local.
+            const isDefaultExport = symbol.escapedName === InternalSymbolName.Default;
+            if (typeChecker.isUndefinedSymbol(symbol)) {
+                return;
+            }
+            addToSeen(resultSymbolIds, getSymbolId(symbol));
+            const origin = { kind: 4 /* SymbolOriginInfoKind.Export */, moduleSymbol, isDefaultExport };
+            results.push({
+                symbol,
+                symbolName: getNameForExportedSymbol(symbol, target),
+                origin,
+                skipFilter,
+            });
+        }
+    }
+    function getNearestExportSymbol(fromSymbol) {
+        return findAlias(typeChecker, fromSymbol, alias => {
+            return some(alias.declarations, d => isExportSpecifier(d) || !!d.localSymbol);
+        });
+    }
+    /**
+     * True if you could remove some characters in `a` to get `b`.
+     * E.g., true for "abcdef" and "bdf".
+     * But not true for "abcdef" and "dbf".
+     */
+    function stringContainsCharactersInOrder(str, characters) {
+        if (characters.length === 0) {
+            return true;
+        }
+        let characterIndex = 0;
+        for (let strIndex = 0; strIndex < str.length; strIndex++) {
+            if (str.charCodeAt(strIndex) === characters.charCodeAt(characterIndex)) {
+                characterIndex++;
+                if (characterIndex === characters.length) {
+                    return true;
+                }
+            }
+        }
+        // Did not find all characters
+        return false;
+    }
+    /**
+     * Finds the first node that "embraces" the position, so that one may
+     * accurately aggregate locals from the closest containing scope.
+     */
+    function getScopeNode(initialToken, position, sourceFile) {
+        let scope = initialToken;
+        while (scope && !positionBelongsToNode(scope, position, sourceFile)) {
+            scope = scope.parent;
+        }
+        return scope;
+    }
+    function isCompletionListBlocker(contextToken) {
+        const start = timestamp();
+        const result = isInStringOrRegularExpressionOrTemplateLiteral(contextToken) ||
+            isSolelyIdentifierDefinitionLocation(contextToken) ||
+            isDotOfNumericLiteral(contextToken) ||
+            isInJsxText(contextToken);
+        log("getCompletionsAtPosition: isCompletionListBlocker: " + (timestamp() - start));
+        return result;
+    }
+    function isInJsxText(contextToken) {
+        if (contextToken.kind === SyntaxKind.JsxText) {
+            return true;
+        }
+        if (contextToken.kind === SyntaxKind.GreaterThanToken && contextToken.parent) {
+            if (contextToken.parent.kind === SyntaxKind.JsxOpeningElement) {
+                // Two possibilities:
+                //   1. <div>/**/
+                //      - contextToken: GreaterThanToken (before cursor)
+                //      - location: JSXElement
+                //      - different parents (JSXOpeningElement, JSXElement)
+                //   2. <Component<string> /**/>
+                //      - contextToken: GreaterThanToken (before cursor)
+                //      - location: GreaterThanToken (after cursor)
+                //      - same parent (JSXOpeningElement)
+                return location.parent.kind !== SyntaxKind.JsxOpeningElement;
+            }
+            if (contextToken.parent.kind === SyntaxKind.JsxClosingElement || contextToken.parent.kind === SyntaxKind.JsxSelfClosingElement) {
+                return !!contextToken.parent.parent && contextToken.parent.parent.kind === SyntaxKind.JsxElement;
+            }
+        }
+        return false;
+    }
+    function isNewIdentifierDefinitionLocation(previousToken) {
+        if (previousToken) {
+            const containingNodeKind = previousToken.parent.kind;
+            // Previous token may have been a keyword that was converted to an identifier.
+            switch (keywordForNode(previousToken)) {
+                case SyntaxKind.CommaToken:
+                    return containingNodeKind === SyntaxKind.CallExpression // func( a, |
+                        || containingNodeKind === SyntaxKind.ArrayLiteralExpression // [a, |
+                        || containingNodeKind === SyntaxKind.BinaryExpression // const x = (a, |
+                        || containingNodeKind === SyntaxKind.FunctionType; // var x: (s: string, list|
+                case SyntaxKind.OpenParenToken:
+                    return containingNodeKind === SyntaxKind.CallExpression // func( |
+                        || containingNodeKind === SyntaxKind.ParenthesizedExpression // const x = (a|
+                        || containingNodeKind === SyntaxKind.ParenthesizedType; // function F(pred: (a| /* this can become an arrow function, where 'a' is the argument */
+                case SyntaxKind.OpenBracketToken:
+                    return containingNodeKind === SyntaxKind.ArrayLiteralExpression // [ |
+                        || containingNodeKind === SyntaxKind.IndexSignature // [ | : string ]
+                        || containingNodeKind === SyntaxKind.ComputedPropertyName; // [ |    /* this can become an index signature */
+                // Na tag, também o `module`, que saiu do scanner com o `module X` e o `declare module "x"` (CK-02, CK-56).
+                case SyntaxKind.NamespaceKeyword: // namespace |
+                    return true;
+                case SyntaxKind.DotToken:
+                    return containingNodeKind === SyntaxKind.ModuleDeclaration; // module A.|
+                case SyntaxKind.EqualsToken:
+                    return containingNodeKind === SyntaxKind.VariableDeclaration // const x = a|
+                        || containingNodeKind === SyntaxKind.BinaryExpression; // x = a|
+                case SyntaxKind.TemplateHead:
+                    return containingNodeKind === SyntaxKind.TemplateExpression; // `aa ${|
+                case SyntaxKind.TemplateMiddle:
+                    return containingNodeKind === SyntaxKind.TemplateSpan; // `aa ${10} dd ${|
+            }
+        }
+        return false;
+    }
+    function isInStringOrRegularExpressionOrTemplateLiteral(contextToken) {
+        // A posição está num literal se está dentro do texto dele, ou no fim de um que não fechou. Na tag, também no fim
+        // de uma regex, pelas flags; a Linguagem não tem o literal de regex (CK-02).
+        return isStringTextContainingNode(contextToken) && (rangeContainsPositionExclusive(createTextRangeFromSpan(createTextSpanFromNode(contextToken)), position) ||
+            position === contextToken.end && !!contextToken.isUnterminated);
+    }
+    /**
+     * Aggregates relevant symbols for completion in object literals and object binding patterns.
+     * Relevant symbols are stored in the captured 'symbols' variable.
+     *
+     * @returns true if 'symbols' was successfully populated; false otherwise.
+     */
+    function tryGetObjectLikeCompletionSymbols() {
+        const objectLikeContainer = tryGetObjectLikeCompletionContainer(contextToken);
+        if (!objectLikeContainer)
+            return 0 /* GlobalsSearch.Continue */;
+        // We're looking up possible property names from contextual/inferred/declared type.
+        completionKind = 0 /* CompletionKind.ObjectPropertyDeclaration */;
+        let typeMembers;
+        let existingMembers;
+        if (objectLikeContainer.kind === SyntaxKind.ObjectLiteralExpression) {
+            const instantiatedType = typeChecker.getContextualType(objectLikeContainer);
+            const completionsType = instantiatedType && typeChecker.getContextualType(objectLikeContainer, ContextFlags.Completions);
+            if (!instantiatedType || !completionsType)
+                return 2 /* GlobalsSearch.Fail */;
+            isNewIdentifierLocation = hasIndexSignature(instantiatedType || completionsType);
+            typeMembers = getPropertiesForObjectExpression(instantiatedType, completionsType, objectLikeContainer, typeChecker);
+            existingMembers = objectLikeContainer.properties;
+        }
+        else {
+            Debug.assert(objectLikeContainer.kind === SyntaxKind.ObjectBindingPattern);
+            // We are *only* completing on properties from the type being destructured.
+            isNewIdentifierLocation = false;
+            const rootDeclaration = getRootDeclaration(objectLikeContainer.parent);
+            if (!isVariableLike(rootDeclaration))
+                return Debug.fail("Root declaration is not variable-like.");
+            // We don't want to complete using the type acquired by the shape
+            // of the binding pattern; we are only interested in types acquired
+            // through type declaration or inference.
+            // Also proceed if rootDeclaration is a parameter and if its containing function expression/arrow function is contextually typed -
+            // type of parameter will flow in from the contextual type of the function
+            let canGetType = hasInitializer(rootDeclaration) || hasType(rootDeclaration) || rootDeclaration.parent.parent.kind === SyntaxKind.ForOfStatement;
+            if (!canGetType && rootDeclaration.kind === SyntaxKind.Parameter) {
+                if (isExpression(rootDeclaration.parent)) {
+                    canGetType = !!typeChecker.getContextualType(rootDeclaration.parent);
+                }
+            }
+            if (canGetType) {
+                const typeForObject = typeChecker.getTypeAtLocation(objectLikeContainer);
+                if (!typeForObject)
+                    return 2 /* GlobalsSearch.Fail */;
+                // Na tag, a propriedade não pública ficava de fora, salvo dentro da classe dela; a Linguagem não tem
+                // classe nem o modificador de acesso (CK-02).
+                typeMembers = typeChecker.getPropertiesOfType(typeForObject);
+                existingMembers = objectLikeContainer.elements;
+            }
+        }
+        if (typeMembers && typeMembers.length > 0) {
+            // Add filtered items to the completion list
+            symbols = filterObjectMembersList(typeMembers, Debug.checkDefined(existingMembers));
+        }
+        setSortTextToOptionalMember();
+        return 1 /* GlobalsSearch.Success */;
+    }
+    /**
+     * Aggregates relevant symbols for completion in import clauses and export clauses
+     * whose declarations have a module specifier; for instance, symbols will be aggregated for
+     *
+     *      import { | } from "moduleName";
+     *      export { a as foo, | } from "moduleName";
+     *
+     * but not for
+     *
+     *      export { | };
+     *
+     * Relevant symbols are stored in the captured 'symbols' variable.
+     */
+    function tryGetImportOrExportClauseCompletionSymbols() {
+        // `import { |` or `import { a as 0, | }`
+        const namedImportsOrExports = contextToken && (contextToken.kind === SyntaxKind.OpenBraceToken || contextToken.kind === SyntaxKind.CommaToken)
+            ? tryCast(contextToken.parent, isNamedImportsOrExports) : undefined;
+        if (!namedImportsOrExports)
+            return 0 /* GlobalsSearch.Continue */;
+        // try to show exported member for imported/re-exported module
+        const { moduleSpecifier } = namedImportsOrExports.kind === SyntaxKind.NamedImports ? namedImportsOrExports.parent.parent : namedImportsOrExports.parent;
+        if (!moduleSpecifier)
+            return namedImportsOrExports.kind === SyntaxKind.NamedImports ? 2 /* GlobalsSearch.Fail */ : 0 /* GlobalsSearch.Continue */;
+        const moduleSpecifierSymbol = typeChecker.getSymbolAtLocation(moduleSpecifier); // TODO: GH#18217
+        if (!moduleSpecifierSymbol)
+            return 2 /* GlobalsSearch.Fail */;
+        completionKind = 3 /* CompletionKind.MemberLike */;
+        isNewIdentifierLocation = false;
+        const exports = typeChecker.getExportsAndPropertiesOfModule(moduleSpecifierSymbol);
+        const existing = arrayToSet(namedImportsOrExports.elements, n => isCurrentlyEditingNode(n) ? undefined : (n.propertyName || n.name).escapedText);
+        symbols = exports.filter(e => e.escapedName !== InternalSymbolName.Default && !existing.get(e.escapedName));
+        return 1 /* GlobalsSearch.Success */;
+    }
+    /**
+     * Adds local declarations for completions in named exports:
+     *
+     *   export { | };
+     *
+     * Does not check for the absence of a module specifier (`export {} from "./other"`)
+     * because `tryGetImportOrExportClauseCompletionSymbols` runs first and handles that,
+     * preventing this function from running.
+     */
+    function tryGetLocalNamedExportCompletionSymbols() {
+        const namedExports = contextToken && (contextToken.kind === SyntaxKind.OpenBraceToken || contextToken.kind === SyntaxKind.CommaToken)
+            ? tryCast(contextToken.parent, isNamedExports)
+            : undefined;
+        if (!namedExports) {
+            return 0 /* GlobalsSearch.Continue */;
+        }
+        const localsContainer = findAncestor(namedExports, or(isSourceFile, isModuleDeclaration));
+        completionKind = 5 /* CompletionKind.None */;
+        isNewIdentifierLocation = false;
+        localsContainer.locals?.forEach((symbol, name) => {
+            symbols.push(symbol);
+            if (localsContainer.symbol?.exports?.has(name)) {
+                symbolToSortTextMap[getSymbolId(symbol)] = SortText.OptionalMember;
+            }
+        });
+        return 1 /* GlobalsSearch.Success */;
+    }
+    /**
+     * O completion no corpo de um tipo de objeto: só as palavras-chave de um membro. Na tag, o de uma classe oferecia
+     * também os membros do tipo base; a Linguagem não tem classe (CK-02), e o tipo de objeto é o literal.
+     */
+    function tryGetClassLikeCompletionSymbols() {
+        const decl = tryGetObjectTypeDeclarationCompletionContainer(sourceFile, contextToken, location, position);
+        if (!decl)
+            return 0 /* GlobalsSearch.Continue */;
+        completionKind = 3 /* CompletionKind.MemberLike */;
+        // um membro novo
+        isNewIdentifierLocation = true;
+        keywordFilters = 2 /* KeywordCompletionFilters.InterfaceElementKeywords */;
+        return 1 /* GlobalsSearch.Success */;
+    }
+    /**
+     * Returns the immediate owning object literal or binding pattern of a context token,
+     * on the condition that one exists and that the context implies completion should be given.
+     */
+    function tryGetObjectLikeCompletionContainer(contextToken) {
+        if (contextToken) {
+            const { parent } = contextToken;
+            switch (contextToken.kind) {
+                case SyntaxKind.OpenBraceToken: // const x = { |
+                case SyntaxKind.CommaToken: // const x = { a: 0, |
+                    if (isObjectLiteralExpression(parent) || isObjectBindingPattern(parent)) {
+                        return parent;
+                    }
+                    break;
+            }
+        }
+        return undefined;
+    }
+    function tryGetFunctionLikeBodyCompletionContainer(contextToken) {
+        if (contextToken) {
+            let prev;
+            const container = findAncestor(contextToken.parent, (node) => {
+                if (isFunctionLikeDeclaration(node) && prev === node.body) {
+                    return true;
+                }
+                prev = node;
+                return false;
+            });
+            return container && container;
+        }
+    }
+    function tryGetContainingJsxElement(contextToken) {
+        if (contextToken) {
+            const parent = contextToken.parent;
+            switch (contextToken.kind) {
+                case SyntaxKind.GreaterThanToken: // End of a type argument list
+                case SyntaxKind.LessThanSlashToken:
+                case SyntaxKind.SlashToken:
+                case SyntaxKind.Identifier:
+                case SyntaxKind.PropertyAccessExpression:
+                case SyntaxKind.JsxAttributes:
+                case SyntaxKind.JsxAttribute:
+                case SyntaxKind.JsxSpreadAttribute:
+                    if (parent && (parent.kind === SyntaxKind.JsxSelfClosingElement || parent.kind === SyntaxKind.JsxOpeningElement)) {
+                        if (contextToken.kind === SyntaxKind.GreaterThanToken) {
+                            const precedingToken = findPrecedingToken(contextToken.pos, sourceFile, /*startNode*/ undefined);
+                            if (!parent.typeArguments || (precedingToken && precedingToken.kind === SyntaxKind.SlashToken))
+                                break;
+                        }
+                        return parent;
+                    }
+                    else if (parent.kind === SyntaxKind.JsxAttribute) {
+                        // Currently we parse JsxOpeningLikeElement as:
+                        //      JsxOpeningLikeElement
+                        //          attributes: JsxAttributes
+                        //             properties: NodeArray<JsxAttributeLike>
+                        return parent.parent.parent;
+                    }
+                    break;
+                // The context token is the closing } or " of an attribute, which means
+                // its parent is a JsxExpression, whose parent is a JsxAttribute,
+                // whose parent is a JsxOpeningLikeElement
+                case SyntaxKind.StringLiteral:
+                    if (parent && ((parent.kind === SyntaxKind.JsxAttribute) || (parent.kind === SyntaxKind.JsxSpreadAttribute))) {
+                        // Currently we parse JsxOpeningLikeElement as:
+                        //      JsxOpeningLikeElement
+                        //          attributes: JsxAttributes
+                        //             properties: NodeArray<JsxAttributeLike>
+                        return parent.parent.parent;
+                    }
+                    break;
+                case SyntaxKind.CloseBraceToken:
+                    if (parent &&
+                        parent.kind === SyntaxKind.JsxExpression &&
+                        parent.parent && parent.parent.kind === SyntaxKind.JsxAttribute) {
+                        // Currently we parse JsxOpeningLikeElement as:
+                        //      JsxOpeningLikeElement
+                        //          attributes: JsxAttributes
+                        //             properties: NodeArray<JsxAttributeLike>
+                        //                  each JsxAttribute can have initializer as JsxExpression
+                        return parent.parent.parent.parent;
+                    }
+                    if (parent && parent.kind === SyntaxKind.JsxSpreadAttribute) {
+                        // Currently we parse JsxOpeningLikeElement as:
+                        //      JsxOpeningLikeElement
+                        //          attributes: JsxAttributes
+                        //             properties: NodeArray<JsxAttributeLike>
+                        return parent.parent.parent;
+                    }
+                    break;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * @returns true if we are certain that the currently edited location must define a new location; false otherwise.
+     */
+    function isSolelyIdentifierDefinitionLocation(contextToken) {
+        const parent = contextToken.parent;
+        const containingNodeKind = parent.kind;
+        switch (contextToken.kind) {
+            case SyntaxKind.CommaToken:
+                return containingNodeKind === SyntaxKind.VariableDeclaration ||
+                    isVariableDeclarationListButNotTypeArgument(contextToken) ||
+                    containingNodeKind === SyntaxKind.VariableStatement ||
+                    isFunctionLikeKind(containingNodeKind) ||
+                    containingNodeKind === SyntaxKind.ArrayBindingPattern || // var [x, y|
+                    containingNodeKind === SyntaxKind.TypeAliasDeclaration; // type Map, K, |
+            case SyntaxKind.DotToken:
+                return containingNodeKind === SyntaxKind.ArrayBindingPattern; // var [.|
+            case SyntaxKind.ColonToken:
+                return containingNodeKind === SyntaxKind.BindingElement; // var {x :html|
+            case SyntaxKind.OpenBracketToken:
+                return containingNodeKind === SyntaxKind.ArrayBindingPattern; // var [x|
+            case SyntaxKind.OpenParenToken:
+                return containingNodeKind === SyntaxKind.CatchClause ||
+                    isFunctionLikeKind(containingNodeKind);
+            case SyntaxKind.LessThanToken:
+                return containingNodeKind === SyntaxKind.TypeAliasDeclaration || // type List< |
+                    isFunctionLikeKind(containingNodeKind);
+            case SyntaxKind.DotDotDotToken:
+                return containingNodeKind === SyntaxKind.Parameter ||
+                    (!!parent.parent && parent.parent.kind === SyntaxKind.ArrayBindingPattern); // var [...z|
+            case SyntaxKind.AsKeyword:
+                return containingNodeKind === SyntaxKind.ImportSpecifier ||
+                    containingNodeKind === SyntaxKind.ExportSpecifier ||
+                    containingNodeKind === SyntaxKind.NamespaceImport;
+            case SyntaxKind.ImportKeyword:
+            case SyntaxKind.LetKeyword:
+            case SyntaxKind.ConstKeyword:
+            case SyntaxKind.TypeKeyword: // type htm|
+                return true;
+        }
+        // Depois de uma palavra-chave de membro, num tipo de objeto, há completion.
+        if (isClassMemberCompletionKeyword(keywordForNode(contextToken)) && isFromObjectTypeDeclaration(contextToken)) {
+            return false;
+        }
+        // A palavra-chave que o parser leu como identificador.
+        switch (keywordForNode(contextToken)) {
+            case SyntaxKind.ConstKeyword:
+            case SyntaxKind.DeclareKeyword:
+            case SyntaxKind.LetKeyword:
+                return true;
+        }
+        return isDeclarationName(contextToken)
+            && !isJsxAttribute(contextToken.parent);
+    }
+    function isDotOfNumericLiteral(contextToken) {
+        if (contextToken.kind === SyntaxKind.NumericLiteral) {
+            const text = contextToken.getFullText();
+            return text.charAt(text.length - 1) === ".";
+        }
+        return false;
+    }
+    function isVariableDeclarationListButNotTypeArgument(node) {
+        return node.parent.kind === SyntaxKind.VariableDeclarationList
+            && !isPossiblyTypeArgumentPosition(node, sourceFile, typeChecker);
+    }
+    /**
+     * Filters out completion suggestions for named imports or exports.
+     *
+     * @returns Symbols to be suggested in an object binding pattern or object literal expression, barring those whose declarations
+     *          do not occur at the current position and have not otherwise been typed.
+     */
+    function filterObjectMembersList(contextualMemberSymbols, existingMembers) {
+        if (existingMembers.length === 0) {
+            return contextualMemberSymbols;
+        }
+        const membersDeclaredBySpreadAssignment = createMap();
+        const existingMemberNames = createUnderscoreEscapedMap();
+        for (const m of existingMembers) {
+            // Ignore omitted expressions for missing members
+            if (m.kind !== SyntaxKind.PropertyAssignment &&
+                m.kind !== SyntaxKind.ShorthandPropertyAssignment &&
+                m.kind !== SyntaxKind.BindingElement &&
+                m.kind !== SyntaxKind.SpreadAssignment) {
+                continue;
+            }
+            // If this is the current item we are editing right now, do not filter it out
+            if (isCurrentlyEditingNode(m)) {
+                continue;
+            }
+            let existingName;
+            if (isSpreadAssignment(m)) {
+                setMembersDeclaredBySpreadAssignment(m, membersDeclaredBySpreadAssignment);
+            }
+            else if (isBindingElement(m) && m.propertyName) {
+                // include only identifiers in completion list
+                if (m.propertyName.kind === SyntaxKind.Identifier) {
+                    existingName = m.propertyName.escapedText;
+                }
+            }
+            else {
+                // TODO: Account for computed property name
+                // NOTE: if one only performs this step when m.name is an identifier,
+                // things like '__proto__' are not filtered out.
+                const name = getNameOfDeclaration(m);
+                existingName = name && isPropertyNameLiteral(name) ? getEscapedTextOfIdentifierOrLiteral(name) : undefined;
+            }
+            existingMemberNames.set(existingName, true); // TODO: GH#18217
+        }
+        const filteredSymbols = contextualMemberSymbols.filter(m => !existingMemberNames.get(m.escapedName));
+        setSortTextToMemberDeclaredBySpreadAssignment(membersDeclaredBySpreadAssignment, filteredSymbols);
+        return filteredSymbols;
+    }
+    function setMembersDeclaredBySpreadAssignment(declaration, membersDeclaredBySpreadAssignment) {
+        const expression = declaration.expression;
+        const symbol = typeChecker.getSymbolAtLocation(expression);
+        const type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, expression);
+        const properties = type && type.properties;
+        if (properties) {
+            properties.forEach(property => {
+                membersDeclaredBySpreadAssignment.set(property.name, true);
+            });
+        }
+    }
+    // Set SortText to OptionalMember if it is an optional member
+    function setSortTextToOptionalMember() {
+        symbols.forEach(m => {
+            if (m.flags & SymbolFlags.Optional) {
+                symbolToSortTextMap[getSymbolId(m)] = symbolToSortTextMap[getSymbolId(m)] || SortText.OptionalMember;
+            }
+        });
+    }
+    // Set SortText to MemberDeclaredBySpreadAssignment if it is fulfilled by spread assignment
+    function setSortTextToMemberDeclaredBySpreadAssignment(membersDeclaredBySpreadAssignment, contextualMemberSymbols) {
+        if (membersDeclaredBySpreadAssignment.size === 0) {
+            return;
+        }
+        for (const contextualMemberSymbol of contextualMemberSymbols) {
+            if (membersDeclaredBySpreadAssignment.has(contextualMemberSymbol.name)) {
+                symbolToSortTextMap[getSymbolId(contextualMemberSymbol)] = SortText.MemberDeclaredBySpreadAssignment;
+            }
+        }
+    }
+    /**
+     * Filters out completion suggestions from 'symbols' according to existing JSX attributes.
+     *
+     * @returns Symbols to be suggested in a JSX element, barring those whose attributes
+     *          do not occur at the current position and have not otherwise been typed.
+     */
+    function filterJsxAttributes(symbols, attributes) {
+        const seenNames = createUnderscoreEscapedMap();
+        const membersDeclaredBySpreadAssignment = createMap();
+        for (const attr of attributes) {
+            // If this is the current item we are editing right now, do not filter it out
+            if (isCurrentlyEditingNode(attr)) {
+                continue;
+            }
+            if (attr.kind === SyntaxKind.JsxAttribute) {
+                seenNames.set(attr.name.escapedText, true);
+            }
+            else if (isJsxSpreadAttribute(attr)) {
+                setMembersDeclaredBySpreadAssignment(attr, membersDeclaredBySpreadAssignment);
+            }
+        }
+        const filteredSymbols = symbols.filter(a => !seenNames.get(a.escapedName));
+        setSortTextToMemberDeclaredBySpreadAssignment(membersDeclaredBySpreadAssignment, filteredSymbols);
+        return filteredSymbols;
+    }
+    function isCurrentlyEditingNode(node) {
+        return node.getStart(sourceFile) <= position && position <= node.getEnd();
+    }
+}
+function getCompletionEntryDisplayNameForSymbol(symbol, target, origin, kind, jsxIdentifierExpected) {
+    const name = originIsExport(origin) ? getNameForExportedSymbol(symbol, target) : symbol.name;
+    if (name === undefined
+        // 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)
+        || symbol.flags & SymbolFlags.Module && isSingleOrDoubleQuote(name.charCodeAt(0))
+        // If the symbol is the internal name of an ES symbol, it is not a valid entry. Internal names for ES symbols start with "__@"
+        || isKnownSymbol(symbol)) {
+        return undefined;
+    }
+    const validNameResult = { name, needsConvertPropertyAccess: false };
+    if (isIdentifierText(name, target, jsxIdentifierExpected ? LanguageVariant.JSX : LanguageVariant.Standard)) {
+        return validNameResult;
+    }
+    switch (kind) {
+        case 3 /* CompletionKind.MemberLike */:
+            return undefined;
+        case 0 /* CompletionKind.ObjectPropertyDeclaration */:
+            // TODO: GH#18169
+            return { name: JSON.stringify(name), needsConvertPropertyAccess: false };
+        case 2 /* CompletionKind.PropertyAccess */:
+        case 1 /* CompletionKind.Global */: // For a 'this.' completion it will be in a global context, but may have a non-identifier name.
+            // Don't add a completion for a name starting with a space. See https://github.com/Microsoft/TypeScript/pull/20547
+            return name.charCodeAt(0) === CharacterCodes.space ? undefined : { name, needsConvertPropertyAccess: true };
+        case 5 /* CompletionKind.None */:
+        case 4 /* CompletionKind.String */:
+            return validNameResult;
+        default:
+            Debug.assertNever(kind);
+    }
+}
+// A cache of completion entries for keywords, these do not change between sessions
+const _keywordCompletions = [];
+const allKeywordsCompletions = memoize(() => {
+    const res = [];
+    for (let i = SyntaxKind.FirstKeyword; i <= SyntaxKind.LastKeyword; i++) {
+        // A palavra que a Linguagem não usa não é palavra-chave no scanner, e não se oferece (CK-56).
+        const name = tokenToString(i);
+        if (name === undefined)
+            continue;
+        res.push({
+            name,
+            kind: "keyword" /* ScriptElementKind.keyword */,
+            kindModifiers: "" /* ScriptElementKindModifier.none */,
+            sortText: SortText.GlobalsOrKeywords
+        });
+    }
+    return res;
+});
+function getTypescriptKeywordCompletions(keywordFilter) {
+    return _keywordCompletions[keywordFilter] || (_keywordCompletions[keywordFilter] = allKeywordsCompletions().filter(entry => {
+        const kind = stringToToken(entry.name);
+        switch (keywordFilter) {
+            case 0 /* KeywordCompletionFilters.None */:
+                return false;
+            case 1 /* KeywordCompletionFilters.All */:
+                // Na tag, também o `module` (CK-02, CK-56).
+                return isFunctionLikeBodyKeyword(kind)
+                    || kind === SyntaxKind.DeclareKeyword
+                    || kind === SyntaxKind.TypeKeyword
+                    || kind === SyntaxKind.NamespaceKeyword
+                    || kind === SyntaxKind.AsKeyword
+                    || isTypeKeyword(kind) && kind !== SyntaxKind.UndefinedKeyword;
+            case 3 /* KeywordCompletionFilters.FunctionLikeBodyKeywords */:
+                return isFunctionLikeBodyKeyword(kind);
+            case 2 /* KeywordCompletionFilters.InterfaceElementKeywords */:
+                return isInterfaceOrTypeLiteralCompletionKeyword(kind);
+            case 4 /* KeywordCompletionFilters.TypeAssertionKeywords */:
+                return isTypeKeyword(kind) || kind === SyntaxKind.ConstKeyword;
+            case 5 /* KeywordCompletionFilters.TypeKeywords */:
+                return isTypeKeyword(kind);
+            default:
+                return Debug.assertNever(keywordFilter);
+        }
+    }));
+}
+function isInterfaceOrTypeLiteralCompletionKeyword(kind) {
+    return kind === SyntaxKind.ReadonlyKeyword;
+}
+/**
+ * A palavra que começa um membro. Na tag, também o `abstract`, o `constructor`, o `get` e o `set`, e os modificadores de
+ * membro de classe (o de acesso e o `static`), que a Linguagem não tem (CK-02); deles fica o `readonly`.
+ */
+function isClassMemberCompletionKeyword(kind) {
+    switch (kind) {
+        case SyntaxKind.AsyncKeyword:
+        case SyntaxKind.DeclareKeyword:
+        case SyntaxKind.ReadonlyKeyword:
+            return true;
+        default:
+            return false;
+    }
+}
+function isFunctionLikeBodyKeyword(kind) {
+    return kind === SyntaxKind.AsyncKeyword
+        || kind === SyntaxKind.AwaitKeyword
+        || !isContextualKeyword(kind) && !isClassMemberCompletionKeyword(kind);
+}
+function keywordForNode(node) {
+    return isIdentifier(node) ? node.originalKeywordKind || SyntaxKind.Unknown : node.kind;
+}
+function getPropertiesForObjectExpression(contextualType, completionsType, obj, checker) {
+    const hasCompletionsType = completionsType && completionsType !== contextualType;
+    const type = hasCompletionsType && !(completionsType.flags & TypeFlags.AnyOrUnknown)
+        ? checker.getUnionType([contextualType, completionsType])
+        : contextualType;
+    const properties = type.isUnion()
+        ? checker.getAllPossiblePropertiesOfTypes(type.types.filter(memberType => 
+        // If we're providing completions for an object literal, skip primitive, array-like, or callable types since those shouldn't be implemented by object literals.
+        !(memberType.flags & TypeFlags.Primitive ||
+            checker.isArrayLikeType(memberType) ||
+            typeHasCallOrConstructSignatures(memberType, checker) ||
+            checker.isTypeInvalidDueToUnionDiscriminant(memberType, obj))))
+        : type.getApparentProperties();
+    return hasCompletionsType ? properties.filter(hasDeclarationOtherThanSelf) : properties;
+    // Filter out members whose only declaration is the object literal itself to avoid
+    // self-fulfilling completions like:
+    //
+    // function f<T>(x: T) {}
+    // f({ abc/**/: "" }) // `abc` is a member of `T` but only because it declares itself
+    function hasDeclarationOtherThanSelf(member) {
+        return some(member.declarations, decl => decl.parent !== obj);
+    }
+}
+/**
+ * Returns the immediate owning class declaration of a context token,
+ * on the condition that one exists and that the context implies completion should be given.
+ */
+function tryGetObjectTypeDeclarationCompletionContainer(sourceFile, contextToken, location, position) {
+    // class c { method() { } | method2() { } }
+    switch (location.kind) {
+        case SyntaxKind.SyntaxList:
+            return tryCast(location.parent, isObjectTypeDeclaration);
+        case SyntaxKind.EndOfFileToken:
+            const cls = tryCast(lastOrUndefined(cast(location.parent, isSourceFile).statements), isObjectTypeDeclaration);
+            if (cls && !findChildOfKind(cls, SyntaxKind.CloseBraceToken, sourceFile)) {
+                return cls;
+            }
+            break;
+        case SyntaxKind.Identifier: {
+            // type t = { a: () => 1\n compon| }
+            if (isFromObjectTypeDeclaration(location)) {
+                return findAncestor(location, isObjectTypeDeclaration);
+            }
+        }
+    }
+    if (!contextToken)
+        return undefined;
+    switch (contextToken.kind) {
+        case SyntaxKind.EqualsToken: // class c { public prop = | /* global completions */ }
+            return undefined;
+        case SyntaxKind.SemicolonToken: // class c {getValue(): number; | }
+        case SyntaxKind.CloseBraceToken: // class c { method() { } | }
+            // class c { method() { } b| }
+            return isFromObjectTypeDeclaration(location) && location.parent.name === location
+                ? location.parent.parent
+                : tryCast(location, isObjectTypeDeclaration);
+        case SyntaxKind.OpenBraceToken: // class c { |
+        case SyntaxKind.CommaToken: // class c {getValue(): number, | }
+            return tryCast(contextToken.parent, isObjectTypeDeclaration);
+        default:
+            if (!isFromObjectTypeDeclaration(contextToken)) {
+                // class c extends React.Component { a: () => 1\n| }
+                if (getLineAndCharacterOfPosition(sourceFile, contextToken.getEnd()).line !== getLineAndCharacterOfPosition(sourceFile, position).line && isObjectTypeDeclaration(location)) {
+                    return location;
+                }
+                return undefined;
+            }
+            // Na tag, o corpo de uma classe aceitava também as palavras de membro de classe e o `*` do gerador (CK-02).
+            const isValidKeyword = isInterfaceOrTypeLiteralCompletionKeyword;
+            return (isValidKeyword(contextToken.kind) || isIdentifier(contextToken) && isValidKeyword(stringToToken(contextToken.text)))
+                ? contextToken.parent.parent : undefined;
+    }
+}
+/** Se o nó é parte de um membro de um tipo de objeto. Na tag, também de um membro de classe (CK-02). */
+function isFromObjectTypeDeclaration(node) {
+    return node.parent && isTypeElement(node.parent) && isObjectTypeDeclaration(node.parent.parent);
+}
+function isValidTrigger(sourceFile, triggerCharacter, contextToken, position) {
+    switch (triggerCharacter) {
+        case ".":
+        case "@":
+            return true;
+        case '"':
+        case "'":
+        case "`":
+            // Only automatically bring up completions if this is an opening quote.
+            return !!contextToken && isStringLiteralOrTemplate(contextToken) && position === contextToken.getStart(sourceFile) + 1;
+        case "#":
+            // O `#` abria o nome privado de uma classe, que a Linguagem não tem (CK-02).
+            return false;
+        case "<":
+            // Opening JSX tag
+            return !!contextToken && contextToken.kind === SyntaxKind.LessThanToken && (!isBinaryExpression(contextToken.parent) || binaryExpressionMayBeOpenTag(contextToken.parent));
+        case "/":
+            return !!contextToken && (isStringLiteralLike(contextToken)
+                ? !!tryGetImportFromModuleSpecifier(contextToken)
+                : contextToken.kind === SyntaxKind.SlashToken && isJsxClosingElement(contextToken.parent));
+        default:
+            return Debug.assertNever(triggerCharacter);
+    }
+}
+function binaryExpressionMayBeOpenTag({ left }) {
+    return nodeIsMissing(left);
+}
+function findAlias(typeChecker, symbol, predicate) {
+    let currentAlias = symbol;
+    while (currentAlias.flags & SymbolFlags.Alias && (currentAlias = typeChecker.getImmediateAliasedSymbol(currentAlias))) {
+        if (predicate(currentAlias)) {
+            return currentAlias;
+        }
+    }
+}