@tslite/services 0.0.0-stage → 1.13.0

package/dist/smartSelection.js

@@ -0,0 +1,243 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/smartSelection.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, SyntaxKind, compact, contains, createNode, createTextSpanFromBounds, findIndex, getTouchingPropertyName, isBindingElement, isBlock, isImportDeclaration, isMappedTypeNode, isParameter, isPropertySignature, isSourceFile, isStringLiteral, isSyntaxList, isTemplateHead, isTemplateLiteral, isTemplateMiddleOrTemplateTail, isTemplateSpan, isTemplateTail, isVariableDeclaration, isVariableDeclarationList, isVariableStatement, last, positionsAreOnSameLine, textSpanIntersectsWithPosition, textSpansEqual, } from "./_namespaces/ts.js";
+export function getSmartSelectionRange(pos, sourceFile) {
+    let selectionRange = {
+        textSpan: createTextSpanFromBounds(sourceFile.getFullStart(), sourceFile.getEnd())
+    };
+    let parentNode = sourceFile;
+    outer: while (true) {
+        const children = getSelectionChildren(parentNode);
+        if (!children.length)
+            break;
+        for (let i = 0; i < children.length; i++) {
+            const prevNode = children[i - 1];
+            const node = children[i];
+            const nextNode = children[i + 1];
+            if (node.getStart(sourceFile) > pos) {
+                break outer;
+            }
+            if (positionShouldSnapToNode(sourceFile, pos, node)) {
+                // 1. Blocks are effectively redundant with SyntaxLists.
+                // 2. TemplateSpans, along with the SyntaxLists containing them, are a somewhat unintuitive grouping
+                //    of things that should be considered independently.
+                // 3. A VariableStatement’s children are just a VaraiableDeclarationList and a semicolon.
+                // 4. A lone VariableDeclaration in a VaraibleDeclaration feels redundant with the VariableStatement.
+                //
+                // Dive in without pushing a selection range.
+                if (isBlock(node)
+                    || isTemplateSpan(node) || isTemplateHead(node) || isTemplateTail(node)
+                    || prevNode && isTemplateHead(prevNode)
+                    || isVariableDeclarationList(node) && isVariableStatement(parentNode)
+                    || isSyntaxList(node) && isVariableDeclarationList(parentNode)
+                    || isVariableDeclaration(node) && isSyntaxList(parentNode) && children.length === 1) {
+                    parentNode = node;
+                    break;
+                }
+                // Synthesize a stop for '${ ... }' since '${' and '}' actually belong to siblings.
+                if (isTemplateSpan(parentNode) && nextNode && isTemplateMiddleOrTemplateTail(nextNode)) {
+                    const start = node.getFullStart() - "${".length;
+                    const end = nextNode.getStart() + "}".length;
+                    pushSelectionRange(start, end);
+                }
+                // Blocks with braces, brackets, parens, or JSX tags on separate lines should be
+                // selected from open to close, including whitespace but not including the braces/etc. themselves.
+                const isBetweenMultiLineBookends = isSyntaxList(node)
+                    && isListOpener(prevNode)
+                    && isListCloser(nextNode)
+                    && !positionsAreOnSameLine(prevNode.getStart(), nextNode.getStart(), sourceFile);
+                const start = isBetweenMultiLineBookends ? prevNode.getEnd() : node.getStart();
+                const end = isBetweenMultiLineBookends ? nextNode.getStart() : node.getEnd();
+                // Na tag, também o trecho do nó com o comentário JSDoc dele (CK-03).
+                pushSelectionRange(start, end);
+                // String literals should have a stop both inside and outside their quotes.
+                if (isStringLiteral(node) || isTemplateLiteral(node)) {
+                    pushSelectionRange(start + 1, end - 1);
+                }
+                parentNode = node;
+                break;
+            }
+            // If we made it to the end of the for loop, we’re done.
+            // In practice, I’ve only seen this happen at the very end
+            // of a SourceFile.
+            if (i === children.length - 1) {
+                break outer;
+            }
+        }
+    }
+    return selectionRange;
+    function pushSelectionRange(start, end) {
+        // Skip empty ranges
+        if (start !== end) {
+            const textSpan = createTextSpanFromBounds(start, end);
+            if (!selectionRange || (
+            // Skip ranges that are identical to the parent
+            !textSpansEqual(textSpan, selectionRange.textSpan) &&
+                // Skip ranges that don’t contain the original position
+                textSpanIntersectsWithPosition(textSpan, pos))) {
+                selectionRange = { textSpan, ...selectionRange && { parent: selectionRange } };
+            }
+        }
+    }
+}
+/**
+ * Like `ts.positionBelongsToNode`, except positions immediately after nodes
+ * count too, unless that position belongs to the next node. In effect, makes
+ * selections able to snap to preceding tokens when the cursor is on the tail
+ * end of them with only whitespace ahead.
+ * @param sourceFile The source file containing the nodes.
+ * @param pos The position to check.
+ * @param node The candidate node to snap to.
+ */
+function positionShouldSnapToNode(sourceFile, pos, node) {
+    // Can’t use 'ts.positionBelongsToNode()' here because it cleverly accounts
+    // for missing nodes, which can’t really be considered when deciding what
+    // to select.
+    Debug.assert(node.pos <= pos);
+    if (pos < node.end) {
+        return true;
+    }
+    const nodeEnd = node.getEnd();
+    if (nodeEnd === pos) {
+        return getTouchingPropertyName(sourceFile, pos).pos < node.end;
+    }
+    return false;
+}
+// Na tag, também o `import =` (CK-03).
+const isImport = isImportDeclaration;
+/**
+ * Gets the children of a node to be considered for selection ranging,
+ * transforming them into an artificial tree according to their intuitive
+ * grouping where no grouping actually exists in the parse tree. For example,
+ * top-level imports are grouped into their own SyntaxList so they can be
+ * selected all together, even though in the AST they’re just siblings of each
+ * other as well as of other top-level statements and declarations.
+ */
+function getSelectionChildren(node) {
+    // Group top-level imports
+    if (isSourceFile(node)) {
+        return groupChildren(node.getChildAt(0).getChildren(), isImport);
+    }
+    // Mapped types _look_ like ObjectTypes with a single member,
+    // but in fact don’t contain a SyntaxList or a node containing
+    // the “key/value” pair like ObjectTypes do, but it seems intuitive
+    // that the selection would snap to those points. The philosophy
+    // of choosing a selection range is not so much about what the
+    // syntax currently _is_ as what the syntax might easily become
+    // if the user is making a selection; e.g., we synthesize a selection
+    // around the “key/value” pair not because there’s a node there, but
+    // because it allows the mapped type to become an object type with a
+    // few keystrokes.
+    if (isMappedTypeNode(node)) {
+        const [openBraceToken, ...children] = node.getChildren();
+        const closeBraceToken = Debug.checkDefined(children.pop());
+        Debug.assertEqual(openBraceToken.kind, SyntaxKind.OpenBraceToken);
+        Debug.assertEqual(closeBraceToken.kind, SyntaxKind.CloseBraceToken);
+        // Group `-/+readonly` and `-/+?`
+        const groupedWithPlusMinusTokens = groupChildren(children, child => child === node.readonlyToken || child.kind === SyntaxKind.ReadonlyKeyword ||
+            child === node.questionToken || child.kind === SyntaxKind.QuestionToken);
+        // Group type parameter with surrounding brackets
+        const groupedWithBrackets = groupChildren(groupedWithPlusMinusTokens, ({ kind }) => kind === SyntaxKind.OpenBracketToken ||
+            kind === SyntaxKind.TypeParameter ||
+            kind === SyntaxKind.CloseBracketToken);
+        return [
+            openBraceToken,
+            // Pivot on `:`
+            createSyntaxList(splitChildren(groupedWithBrackets, ({ kind }) => kind === SyntaxKind.ColonToken)),
+            closeBraceToken,
+        ];
+    }
+    // Group modifiers and property name, then pivot on `:`.
+    if (isPropertySignature(node)) {
+        const children = groupChildren(node.getChildren(), child => child === node.name || contains(node.modifiers, child));
+        return splitChildren(children, ({ kind }) => kind === SyntaxKind.ColonToken);
+    }
+    // Group the parameter name with its `...`, then that group with its `?`, then pivot on `=`.
+    if (isParameter(node)) {
+        const groupedDotDotDotAndName = groupChildren(node.getChildren(), child => child === node.dotDotDotToken || child === node.name);
+        const groupedWithQuestionToken = groupChildren(groupedDotDotDotAndName, child => child === groupedDotDotDotAndName[0] || child === node.questionToken);
+        return splitChildren(groupedWithQuestionToken, ({ kind }) => kind === SyntaxKind.EqualsToken);
+    }
+    // Pivot on '='
+    if (isBindingElement(node)) {
+        return splitChildren(node.getChildren(), ({ kind }) => kind === SyntaxKind.EqualsToken);
+    }
+    return node.getChildren();
+}
+/**
+ * Groups sibling nodes together into their own SyntaxList if they
+ * a) are adjacent, AND b) match a predicate function.
+ */
+function groupChildren(children, groupOn) {
+    const result = [];
+    let group;
+    for (const child of children) {
+        if (groupOn(child)) {
+            group = group || [];
+            group.push(child);
+        }
+        else {
+            if (group) {
+                result.push(createSyntaxList(group));
+                group = undefined;
+            }
+            result.push(child);
+        }
+    }
+    if (group) {
+        result.push(createSyntaxList(group));
+    }
+    return result;
+}
+/**
+ * Splits sibling nodes into up to four partitions:
+ * 1) everything left of the first node matched by `pivotOn`,
+ * 2) the first node matched by `pivotOn`,
+ * 3) everything right of the first node matched by `pivotOn`,
+ * 4) a trailing semicolon, if `separateTrailingSemicolon` is enabled.
+ * The left and right groups, if not empty, will each be grouped into their own containing SyntaxList.
+ * @param children The sibling nodes to split.
+ * @param pivotOn The predicate function to match the node to be the pivot. The first node that matches
+ * the predicate will be used; any others that may match will be included into the right-hand group.
+ * @param separateTrailingSemicolon If the last token is a semicolon, it will be returned as a separate
+ * child rather than be included in the right-hand group.
+ */
+function splitChildren(children, pivotOn, separateTrailingSemicolon = true) {
+    if (children.length < 2) {
+        return children;
+    }
+    const splitTokenIndex = findIndex(children, pivotOn);
+    if (splitTokenIndex === -1) {
+        return children;
+    }
+    const leftChildren = children.slice(0, splitTokenIndex);
+    const splitToken = children[splitTokenIndex];
+    const lastToken = last(children);
+    const separateLastToken = separateTrailingSemicolon && lastToken.kind === SyntaxKind.SemicolonToken;
+    const rightChildren = children.slice(splitTokenIndex + 1, separateLastToken ? children.length - 1 : undefined);
+    const result = compact([
+        leftChildren.length ? createSyntaxList(leftChildren) : undefined,
+        splitToken,
+        rightChildren.length ? createSyntaxList(rightChildren) : undefined,
+    ]);
+    return separateLastToken ? result.concat(lastToken) : result;
+}
+function createSyntaxList(children) {
+    Debug.assertGreaterThanOrEqual(children.length, 1);
+    const syntaxList = createNode(SyntaxKind.SyntaxList, children[0].pos, last(children).end);
+    syntaxList._children = children;
+    return syntaxList;
+}
+function isListOpener(token) {
+    const kind = token && token.kind;
+    return kind === SyntaxKind.OpenBraceToken
+        || kind === SyntaxKind.OpenBracketToken
+        || kind === SyntaxKind.OpenParenToken
+        || kind === SyntaxKind.JsxOpeningElement;
+}
+function isListCloser(token) {
+    const kind = token && token.kind;
+    return kind === SyntaxKind.CloseBraceToken
+        || kind === SyntaxKind.CloseBracketToken
+        || kind === SyntaxKind.CloseParenToken
+        || kind === SyntaxKind.JsxClosingElement;
+}

package/dist/stringCompletions.d.ts

@@ -0,0 +1,4 @@
+import type { CancellationToken, CompletionEntryDetails, CompletionInfo, LanguageServiceHost, Node, SourceFile, TypeChecker, UserPreferences } from "./_namespaces/ts.js";
+import type { Log } from "./_namespaces/ts.Completions.js";
+export declare function getStringLiteralCompletions(sourceFile: SourceFile, position: number, contextToken: Node | undefined, checker: TypeChecker, _host: LanguageServiceHost, log: Log, preferences: UserPreferences): CompletionInfo | undefined;
+export declare function getStringLiteralCompletionDetails(name: string, sourceFile: SourceFile, position: number, contextToken: Node | undefined, checker: TypeChecker, _host: LanguageServiceHost, cancellationToken: CancellationToken): CompletionEntryDetails | undefined;

package/dist/stringCompletions.js

@@ -0,0 +1,220 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/stringCompletions.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, Extension, ScriptTarget, SignatureHelp, SyntaxKind, TypeFlags, addToSeen, contains, createMap, createTextSpan, directorySeparator, emptyArray, find, flatMap, getContextualTypeFromParent, getReplacementSpanForContextToken, hasIndexSignature, isIdentifierText, isImportCall, isInString, isLiteralTypeNode, isObjectLiteralExpression, isRequireCall, isStringLiteral, isStringLiteralLike, isTypeReferenceNode, mapDefined, signatureHasRestParameter, skipConstraint, textPart, } from "./_namespaces/ts.js";
+import { SortText, createCompletionDetails, createCompletionDetailsForSymbol, getCompletionEntriesFromSymbols, } from "./_namespaces/ts.Completions.js";
+/* @internal */
+export function getStringLiteralCompletions(sourceFile, position, contextToken, checker, _host, log, preferences) {
+    // Na tag, o caminho de uma referência `/// <reference path>` tinha completion; a Linguagem não tem a referência (CK-03).
+    if (isInString(sourceFile, position, contextToken)) {
+        if (!contextToken || !isStringLiteralLike(contextToken))
+            return undefined;
+        const entries = getStringLiteralCompletionEntries(sourceFile, contextToken, position, checker);
+        return convertStringLiteralCompletions(entries, contextToken, sourceFile, checker, log, preferences);
+    }
+}
+function convertStringLiteralCompletions(completion, contextToken, sourceFile, checker, log, preferences) {
+    if (completion === undefined) {
+        return undefined;
+    }
+    switch (completion.kind) {
+        case 0 /* StringLiteralCompletionKind.Paths */:
+            return convertPathCompletions(completion.paths);
+        case 1 /* StringLiteralCompletionKind.Properties */: {
+            const entries = [];
+            getCompletionEntriesFromSymbols(completion.symbols, entries, contextToken, sourceFile, sourceFile, checker, ScriptTarget.ESNext, log, 4 /* CompletionKind.String */, preferences); // Target will not be used, so arbitrary
+            return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: completion.hasIndexSignature, entries };
+        }
+        case 2 /* StringLiteralCompletionKind.Types */: {
+            const entries = completion.types.map(type => ({
+                name: type.value,
+                kindModifiers: "" /* ScriptElementKindModifier.none */,
+                kind: "string" /* ScriptElementKind.string */,
+                sortText: "0",
+                replacementSpan: getReplacementSpanForContextToken(contextToken)
+            }));
+            return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: completion.isNewIdentifier, entries };
+        }
+        default:
+            return Debug.assertNever(completion);
+    }
+}
+export function getStringLiteralCompletionDetails(name, sourceFile, position, contextToken, checker, _host, cancellationToken) {
+    if (!contextToken || !isStringLiteralLike(contextToken))
+        return undefined;
+    const completions = getStringLiteralCompletionEntries(sourceFile, contextToken, position, checker);
+    return completions && stringLiteralCompletionDetails(name, contextToken, completions, sourceFile, checker, cancellationToken);
+}
+function stringLiteralCompletionDetails(name, location, completion, sourceFile, checker, cancellationToken) {
+    switch (completion.kind) {
+        case 0 /* StringLiteralCompletionKind.Paths */: {
+            const match = find(completion.paths, p => p.name === name);
+            return match && createCompletionDetails(name, kindModifiersFromExtension(match.extension), match.kind, [textPart(name)]);
+        }
+        case 1 /* StringLiteralCompletionKind.Properties */: {
+            const match = find(completion.symbols, s => s.name === name);
+            return match && createCompletionDetailsForSymbol(match, checker, sourceFile, location, cancellationToken);
+        }
+        case 2 /* StringLiteralCompletionKind.Types */:
+            return find(completion.types, t => t.value === name) ? createCompletionDetails(name, "" /* ScriptElementKindModifier.none */, "type" /* ScriptElementKind.typeElement */, [textPart(name)]) : undefined;
+        default:
+            return Debug.assertNever(completion);
+    }
+}
+function convertPathCompletions(pathCompletions) {
+    const isGlobalCompletion = false; // We don't want the editor to offer any other completions, such as snippets, inside a comment.
+    const isNewIdentifierLocation = true; // The user may type in a path that doesn't yet exist, creating a "new identifier" with respect to the collection of identifiers the server is aware of.
+    const entries = pathCompletions.map(({ name, kind, span, extension }) => ({ name, kind, kindModifiers: kindModifiersFromExtension(extension), sortText: SortText.LocationPriority, replacementSpan: span }));
+    return { isGlobalCompletion, isMemberCompletion: false, isNewIdentifierLocation, entries };
+}
+function kindModifiersFromExtension(extension) {
+    switch (extension) {
+        case Extension.Dts: return ".d.ts" /* ScriptElementKindModifier.dtsModifier */;
+        case Extension.Js: return ".js" /* ScriptElementKindModifier.jsModifier */;
+        case Extension.Json: return ".json" /* ScriptElementKindModifier.jsonModifier */;
+        case Extension.Jsx: return ".jsx" /* ScriptElementKindModifier.jsxModifier */;
+        case Extension.Ts: return ".ts" /* ScriptElementKindModifier.tsModifier */;
+        case Extension.Tsx: return ".tsx" /* ScriptElementKindModifier.tsxModifier */;
+        case Extension.TsBuildInfo: return Debug.fail(`Extension ${Extension.TsBuildInfo} is unsupported.`);
+        case undefined: return "" /* ScriptElementKindModifier.none */;
+        default:
+            return Debug.assertNever(extension);
+    }
+}
+var StringLiteralCompletionKind;
+(function (StringLiteralCompletionKind) {
+    StringLiteralCompletionKind[StringLiteralCompletionKind["Paths"] = 0] = "Paths";
+    StringLiteralCompletionKind[StringLiteralCompletionKind["Properties"] = 1] = "Properties";
+    StringLiteralCompletionKind[StringLiteralCompletionKind["Types"] = 2] = "Types";
+})(StringLiteralCompletionKind || (StringLiteralCompletionKind = {}));
+function getStringLiteralCompletionEntries(sourceFile, node, position, typeChecker) {
+    const { parent } = node;
+    switch (parent.kind) {
+        case SyntaxKind.LiteralType:
+            switch (parent.parent.kind) {
+                case SyntaxKind.TypeReference:
+                    return { kind: 2 /* StringLiteralCompletionKind.Types */, types: getStringLiteralTypes(typeChecker.getTypeArgumentConstraint(parent)), isNewIdentifier: false };
+                case SyntaxKind.IndexedAccessType:
+                    // Get all apparent property names
+                    // i.e. interface Foo {
+                    //          foo: string;
+                    //          bar: string;
+                    //      }
+                    //      let x: Foo["/*completion position*/"]
+                    return stringLiteralCompletionsFromProperties(typeChecker.getTypeFromTypeNode(parent.parent.objectType));
+                case SyntaxKind.ImportType:
+                    return { kind: 0 /* StringLiteralCompletionKind.Paths */, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node) };
+                case SyntaxKind.UnionType: {
+                    if (!isTypeReferenceNode(parent.parent.parent))
+                        return undefined;
+                    const alreadyUsedTypes = getAlreadyUsedTypesInStringLiteralUnion(parent.parent, parent);
+                    const types = getStringLiteralTypes(typeChecker.getTypeArgumentConstraint(parent.parent)).filter(t => !contains(alreadyUsedTypes, t.value));
+                    return { kind: 2 /* StringLiteralCompletionKind.Types */, types, isNewIdentifier: false };
+                }
+                default:
+                    return undefined;
+            }
+        case SyntaxKind.PropertyAssignment:
+            if (isObjectLiteralExpression(parent.parent) && parent.name === node) {
+                // Get quoted name of properties of the object literal expression
+                // i.e. interface ConfigFiles {
+                //          'jspm:dev': string
+                //      }
+                //      let files: ConfigFiles = {
+                //          '/*completion position*/'
+                //      }
+                //
+                //      function foo(c: ConfigFiles) {}
+                //      foo({
+                //          '/*completion position*/'
+                //      });
+                return stringLiteralCompletionsFromProperties(typeChecker.getContextualType(parent.parent));
+            }
+            return fromContextualType();
+        case SyntaxKind.ElementAccessExpression: {
+            const { expression, argumentExpression } = parent;
+            if (node === argumentExpression) {
+                // Get all names of properties on the expression
+                // i.e. interface A {
+                //      'prop1': string
+                // }
+                // let a: A;
+                // a['/*completion position*/']
+                return stringLiteralCompletionsFromProperties(typeChecker.getTypeAtLocation(expression));
+            }
+            return undefined;
+        }
+        case SyntaxKind.CallExpression:
+            if (!isRequireCall(parent, /*checkArgumentIsStringLiteralLike*/ false) && !isImportCall(parent)) {
+                const argumentInfo = SignatureHelp.getArgumentInfoForCompletions(node, position, sourceFile);
+                // Get string literal completions from specialized signatures of the target
+                // i.e. declare function f(a: 'A');
+                // f("/*completion position*/")
+                return argumentInfo ? getStringLiteralCompletionsFromSignature(argumentInfo, typeChecker) : fromContextualType();
+            }
+        // falls through (is `require("")` or `import("")`)
+        case SyntaxKind.ImportDeclaration:
+        case SyntaxKind.ExportDeclaration:
+            // O caminho de um módulo: import * as ns from "/*completion position*/";
+            //      var y = require("/*completion position*/");
+            //      export * from "/*completion position*/";
+            return { kind: 0 /* StringLiteralCompletionKind.Paths */, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node) };
+        default:
+            return fromContextualType();
+    }
+    function fromContextualType() {
+        // Get completion for string literal from string literal type
+        // i.e. var x: "hi" | "hello" = "/*completion position*/"
+        return { kind: 2 /* StringLiteralCompletionKind.Types */, types: getStringLiteralTypes(getContextualTypeFromParent(node, typeChecker)), isNewIdentifier: false };
+    }
+}
+function getAlreadyUsedTypesInStringLiteralUnion(union, current) {
+    return mapDefined(union.types, type => type !== current && isLiteralTypeNode(type) && isStringLiteral(type.literal) ? type.literal.text : undefined);
+}
+function getStringLiteralCompletionsFromSignature(argumentInfo, checker) {
+    let isNewIdentifier = false;
+    const uniques = createMap();
+    const candidates = [];
+    checker.getResolvedSignature(argumentInfo.invocation, candidates, argumentInfo.argumentCount);
+    const types = flatMap(candidates, candidate => {
+        if (!signatureHasRestParameter(candidate) && argumentInfo.argumentCount > candidate.parameters.length)
+            return;
+        const type = checker.getParameterType(candidate, argumentInfo.argumentIndex);
+        isNewIdentifier = isNewIdentifier || !!(type.flags & TypeFlags.String);
+        return getStringLiteralTypes(type, uniques);
+    });
+    return { kind: 2 /* StringLiteralCompletionKind.Types */, types, isNewIdentifier };
+}
+function stringLiteralCompletionsFromProperties(type) {
+    return type && {
+        kind: 1 /* StringLiteralCompletionKind.Properties */,
+        // Na tag, sem o `#private` (CK-02).
+        symbols: type.getApparentProperties(),
+        hasIndexSignature: hasIndexSignature(type)
+    };
+}
+function getStringLiteralTypes(type, uniques = createMap()) {
+    if (!type)
+        return emptyArray;
+    type = skipConstraint(type);
+    // Na tag, o literal de string de um membro de enum ficava de fora (CK-02).
+    return type.isUnion() ? flatMap(type.types, t => getStringLiteralTypes(t, uniques)) :
+        type.isStringLiteral() && addToSeen(uniques, type.value) ? [type] : emptyArray;
+}
+function addReplacementSpans(text, textStart, names) {
+    const span = getDirectoryFragmentTextSpan(text, textStart);
+    return names.map(({ name, kind, extension }) => ({ name, kind, extension, span }));
+}
+/**
+ * O completion do caminho de um módulo. Na tag, ele lia o disco do host: os diretórios relativos, o `baseUrl` e o
+ * `paths`, os módulos ambientes, os pacotes de tipos e o `node_modules`. O host da Linguagem não lê disco (CK-47), e a
+ * resolução de um import é dele (CK-46): a lista sai vazia, como a da tag com um host que não lê diretório.
+ */
+function getStringLiteralCompletionsFromModuleNames(sourceFile, node) {
+    return addReplacementSpans(node.text, node.getStart(sourceFile) + 1, emptyArray);
+}
+function getDirectoryFragmentTextSpan(text, textStart) {
+    const index = Math.max(text.lastIndexOf(directorySeparator), text.lastIndexOf("\\"));
+    const offset = index !== -1 ? index + 1 : 0;
+    // If the range is an identifier, span is unnecessary.
+    const length = text.length - offset;
+    return length === 0 || isIdentifierText(text.substr(offset, length), ScriptTarget.ESNext) ? undefined : createTextSpan(textStart + offset, length);
+}

package/dist/suggestionDiagnostics.d.ts

@@ -0,0 +1,6 @@
+import type { CallExpression, CancellationToken, CheckResult, DiagnosticWithLocation, Node, ReturnStatement, SourceFile } from "./_namespaces/ts.js";
+export declare function computeSuggestionDiagnostics(sourceFile: SourceFile, program: CheckResult, cancellationToken: CancellationToken): DiagnosticWithLocation[];
+export declare function isReturnStatementWithFixablePromiseHandler(node: Node): node is ReturnStatement & {
+    expression: CallExpression;
+};
+export declare function isFixablePromiseHandler(node: Node): boolean;

package/dist/suggestionDiagnostics.js

@@ -0,0 +1,92 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/suggestionDiagnostics.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Diagnostics, SyntaxKind, addRange, createDiagnosticForNode, createMap, forEachReturnStatement, hasPropertyAccessExpressionWithName, isAsyncFunction, isBlock, isCallExpression, isFunctionLikeDeclaration, isIdentifier, isPropertyAccessExpression, isReturnStatement, isVariableDeclaration, some, } from "./_namespaces/ts.js";
+const visitedNestedConvertibleFunctions = createMap();
+export function computeSuggestionDiagnostics(sourceFile, program, cancellationToken) {
+    program.getSemanticDiagnostics(sourceFile, cancellationToken);
+    const diags = [];
+    const checker = program.getTypeChecker();
+    visitedNestedConvertibleFunctions.clear();
+    check(sourceFile);
+    addRange(diags, sourceFile.bindSuggestionDiagnostics);
+    addRange(diags, program.getSuggestionDiagnostics(sourceFile, cancellationToken));
+    return diags.sort((d1, d2) => d1.start - d2.start);
+    function check(node) {
+        // Na tag, também a sugestão de converter o `const x = require("…")` de topo num import (o TS80005): o `require` é
+        // CommonJS (CK-03), e o nome não se acha na Linguagem (CK-68).
+        if (isFunctionLikeDeclaration(node)) {
+            addConvertToAsyncFunctionDiagnostics(node, checker, diags);
+        }
+        node.forEachChild(check);
+    }
+}
+function addConvertToAsyncFunctionDiagnostics(node, checker, diags) {
+    // A função se confere antes do mapa, para os callbacks aninhados mais fundo também se conferirem.
+    if (isConvertibleFunction(node, checker) && !visitedNestedConvertibleFunctions.has(getKeyFromNode(node))) {
+        diags.push(createDiagnosticForNode(!node.name && isVariableDeclaration(node.parent) && isIdentifier(node.parent.name) ? node.parent.name : node, Diagnostics.This_may_be_converted_to_an_async_function));
+    }
+}
+function isConvertibleFunction(node, checker) {
+    return !isAsyncFunction(node) &&
+        node.body &&
+        isBlock(node.body) &&
+        hasReturnStatementWithPromiseHandler(node.body) &&
+        returnsPromise(node, checker);
+}
+function returnsPromise(node, checker) {
+    const functionType = checker.getTypeAtLocation(node);
+    const callSignatures = checker.getSignaturesOfType(functionType);
+    const returnType = callSignatures.length ? checker.getReturnTypeOfSignature(callSignatures[0]) : undefined;
+    return !!returnType && !!checker.getPromisedTypeOfPromise(returnType);
+}
+function hasReturnStatementWithPromiseHandler(body) {
+    return !!forEachReturnStatement(body, isReturnStatementWithFixablePromiseHandler);
+}
+export function isReturnStatementWithFixablePromiseHandler(node) {
+    return isReturnStatement(node) && !!node.expression && isFixablePromiseHandler(node.expression);
+}
+// Acompanha o `transformExpression` do code fix que converte para async (`convertToAsyncFunction.ts`).
+export function isFixablePromiseHandler(node) {
+    // a chamada de fora existe e é um handler de promise
+    if (!isPromiseHandler(node) || !node.arguments.every(isFixablePromiseArgument)) {
+        return false;
+    }
+    // e cada chamada encadeada é válida
+    let currentNode = node.expression;
+    while (isPromiseHandler(currentNode) || isPropertyAccessExpression(currentNode)) {
+        if (isCallExpression(currentNode) && !currentNode.arguments.every(isFixablePromiseArgument)) {
+            return false;
+        }
+        currentNode = currentNode.expression;
+    }
+    return true;
+}
+function isPromiseHandler(node) {
+    return isCallExpression(node) && (hasPropertyAccessExpressionWithName(node, "then") && hasSupportedNumberOfArguments(node) ||
+        hasPropertyAccessExpressionWithName(node, "catch"));
+}
+function hasSupportedNumberOfArguments(node) {
+    if (node.arguments.length > 2)
+        return false;
+    if (node.arguments.length < 2)
+        return true;
+    return some(node.arguments, arg => {
+        return arg.kind === SyntaxKind.NullKeyword ||
+            isIdentifier(arg) && arg.text === "undefined";
+    });
+}
+// Acompanha o `getTransformationBody` do code fix que converte para async (`convertToAsyncFunction.ts`).
+function isFixablePromiseArgument(arg) {
+    switch (arg.kind) {
+        case SyntaxKind.ArrowFunction:
+            visitedNestedConvertibleFunctions.set(getKeyFromNode(arg), true);
+        // falls through
+        case SyntaxKind.NullKeyword:
+        case SyntaxKind.Identifier: // o `undefined` é um identificador
+            return true;
+        default:
+            return false;
+    }
+}
+function getKeyFromNode(exp) {
+    return `${exp.pos.toString()}:${exp.end.toString()}`;
+}

package/dist/symbolDisplay.d.ts

@@ -0,0 +1,16 @@
+import { ScriptElementKind, SemanticMeaning } from "./_namespaces/ts.js";
+import type { JSDocTagInfo, Node, SourceFile, Symbol, SymbolDisplayPart, TypeChecker } from "./_namespaces/ts.js";
+export declare function getSymbolKind(typeChecker: TypeChecker, symbol: Symbol, location: Node): ScriptElementKind;
+export declare function getSymbolModifiers(symbol: Symbol): string;
+interface SymbolDisplayPartsDocumentationAndSymbolKind {
+    displayParts: SymbolDisplayPart[];
+    documentation: SymbolDisplayPart[];
+    symbolKind: ScriptElementKind;
+    tags: JSDocTagInfo[] | undefined;
+}
+/**
+ * O texto do símbolo no ponto (`displayParts`), o tipo de símbolo e a documentação. A documentação e as tags vinham do
+ * JSDoc, que a cópia não tem (CK-03): saem vazias.
+ */
+export declare function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker: TypeChecker, symbol: Symbol, sourceFile: SourceFile, enclosingDeclaration: Node | undefined, location: Node, semanticMeaning?: SemanticMeaning, alias?: Symbol): SymbolDisplayPartsDocumentationAndSymbolKind;
+export {};