@tslite/services 0.0.0-stage → 1.12.0

package/dist/signatureHelp.d.ts

@@ -0,0 +1,8 @@
+import type { CallLikeExpression, CancellationToken, CheckResult, Node, SignatureHelpItems, SignatureHelpTriggerReason, SourceFile } from "./_namespaces/ts.js";
+export declare function getSignatureHelpItems(program: CheckResult, sourceFile: SourceFile, position: number, triggerReason: SignatureHelpTriggerReason | undefined, cancellationToken: CancellationToken): SignatureHelpItems | undefined;
+export interface ArgumentInfoForCompletions {
+    readonly invocation: CallLikeExpression;
+    readonly argumentIndex: number;
+    readonly argumentCount: number;
+}
+export declare function getArgumentInfoForCompletions(node: Node, position: number, sourceFile: SourceFile): ArgumentInfoForCompletions | undefined;

package/dist/signatureHelp.js

@@ -0,0 +1,414 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/signatureHelp.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, EmitHint, InternalSymbolName, ListFormat, NodeBuilderFlags, SyntaxKind, contains, countWhere, createNodeArray, createPrinter, createTextSpan, createTextSpanFromBounds, emptyArray, findContainingList, findPrecedingToken, findTokenOnLeftOfPosition, first, firstDefined, getInvokedExpression, getPossibleGenericSignatures, getPossibleTypeArgumentsInfo, isBlock, isCallExpression, isFunctionTypeNode, isIdentifier, isInComment, isInString, isJsxOpeningLikeElement, isSourceFile, last, mapToDisplayParts, punctuationPart, rangeContainsRange, skipTrivia, spacePart, symbolToDisplayParts, } from "./_namespaces/ts.js";
+var InvocationKind;
+(function (InvocationKind) {
+    InvocationKind[InvocationKind["Call"] = 0] = "Call";
+    InvocationKind[InvocationKind["TypeArgs"] = 1] = "TypeArgs";
+    InvocationKind[InvocationKind["Contextual"] = 2] = "Contextual";
+})(InvocationKind || (InvocationKind = {}));
+export function getSignatureHelpItems(program, sourceFile, position, triggerReason, cancellationToken) {
+    const typeChecker = program.getTypeChecker();
+    // Decide whether to show signature help
+    const startingToken = findTokenOnLeftOfPosition(sourceFile, position);
+    if (!startingToken) {
+        // We are at the beginning of the file
+        return undefined;
+    }
+    // Only need to be careful if the user typed a character and signature help wasn't showing.
+    const onlyUseSyntacticOwners = !!triggerReason && triggerReason.kind === "characterTyped";
+    // Bail out quickly in the middle of a string or comment, don't provide signature help unless the user explicitly requested it.
+    if (onlyUseSyntacticOwners && (isInString(sourceFile, position, startingToken) || isInComment(sourceFile, position))) {
+        return undefined;
+    }
+    const isManuallyInvoked = !!triggerReason && triggerReason.kind === "invoked";
+    const argumentInfo = getContainingArgumentInfo(startingToken, position, sourceFile, typeChecker, isManuallyInvoked);
+    if (!argumentInfo)
+        return undefined;
+    cancellationToken.throwIfCancellationRequested();
+    // Extra syntactic and semantic filtering of signature help
+    const candidateInfo = getCandidateOrTypeInfo(argumentInfo, typeChecker, sourceFile, startingToken, onlyUseSyntacticOwners);
+    cancellationToken.throwIfCancellationRequested();
+    // Na tag, num arquivo JavaScript sem resposta do checker, a assinatura de uma declaração de mesmo nome em qualquer
+    // arquivo (o `createJSSignatureHelpItems`, CK-03).
+    if (!candidateInfo) {
+        return undefined;
+    }
+    return typeChecker.runWithCancellationToken(cancellationToken, typeChecker => candidateInfo.kind === 0 /* CandidateOrTypeKind.Candidate */
+        ? createSignatureHelpItems(candidateInfo.candidates, candidateInfo.resolvedSignature, argumentInfo, sourceFile, typeChecker)
+        : createTypeHelpItems(candidateInfo.symbol, argumentInfo, sourceFile, typeChecker));
+}
+var CandidateOrTypeKind;
+(function (CandidateOrTypeKind) {
+    CandidateOrTypeKind[CandidateOrTypeKind["Candidate"] = 0] = "Candidate";
+    CandidateOrTypeKind[CandidateOrTypeKind["Type"] = 1] = "Type";
+})(CandidateOrTypeKind || (CandidateOrTypeKind = {}));
+function getCandidateOrTypeInfo({ invocation, argumentCount }, checker, sourceFile, startingToken, onlyUseSyntacticOwners) {
+    switch (invocation.kind) {
+        case 0 /* InvocationKind.Call */: {
+            if (onlyUseSyntacticOwners && !isSyntacticOwner(startingToken, invocation.node, sourceFile)) {
+                return undefined;
+            }
+            const candidates = [];
+            const resolvedSignature = checker.getResolvedSignatureForSignatureHelp(invocation.node, candidates, argumentCount);
+            return candidates.length === 0 ? undefined : { kind: 0 /* CandidateOrTypeKind.Candidate */, candidates, resolvedSignature };
+        }
+        case 1 /* InvocationKind.TypeArgs */: {
+            const { called } = invocation;
+            if (onlyUseSyntacticOwners && !containsPrecedingToken(startingToken, sourceFile, isIdentifier(called) ? called.parent : called)) {
+                return undefined;
+            }
+            const candidates = getPossibleGenericSignatures(called, argumentCount, checker);
+            if (candidates.length !== 0)
+                return { kind: 0 /* CandidateOrTypeKind.Candidate */, candidates, resolvedSignature: first(candidates) };
+            const symbol = checker.getSymbolAtLocation(called);
+            return symbol && { kind: 1 /* CandidateOrTypeKind.Type */, symbol };
+        }
+        case 2 /* InvocationKind.Contextual */:
+            return { kind: 0 /* CandidateOrTypeKind.Candidate */, candidates: [invocation.signature], resolvedSignature: invocation.signature };
+        default:
+            return Debug.assertNever(invocation);
+    }
+}
+/** Na tag, também o `new` (CK-02). */
+function isSyntacticOwner(startingToken, node, sourceFile) {
+    if (!isCallExpression(node))
+        return false;
+    const invocationChildren = node.getChildren(sourceFile);
+    switch (startingToken.kind) {
+        case SyntaxKind.OpenParenToken:
+            return contains(invocationChildren, startingToken);
+        case SyntaxKind.CommaToken: {
+            const containingList = findContainingList(startingToken);
+            return !!containingList && contains(invocationChildren, containingList);
+        }
+        case SyntaxKind.LessThanToken:
+            return containsPrecedingToken(startingToken, sourceFile, node.expression);
+        default:
+            return false;
+    }
+}
+function containsPrecedingToken(startingToken, sourceFile, container) {
+    const pos = startingToken.getFullStart();
+    // There’s a possibility that `startingToken.parent` contains only `startingToken` and
+    // missing nodes, none of which are valid to be returned by `findPrecedingToken`. In that
+    // case, the preceding token we want is actually higher up the tree—almost definitely the
+    // next parent, but theoretically the situation with missing nodes might be happening on
+    // multiple nested levels.
+    let currentParent = startingToken.parent;
+    while (currentParent) {
+        // Na tag, sem o token de um JSDoc (o `excludeJsdoc`, CK-03).
+        const precedingToken = findPrecedingToken(pos, sourceFile, currentParent);
+        if (precedingToken) {
+            return rangeContainsRange(container, precedingToken);
+        }
+        currentParent = currentParent.parent;
+    }
+    return Debug.fail("Could not find preceding token");
+}
+export function getArgumentInfoForCompletions(node, position, sourceFile) {
+    const info = getImmediatelyContainingArgumentInfo(node, position, sourceFile);
+    return !info || info.isTypeParameterList || info.invocation.kind !== 0 /* InvocationKind.Call */ ? undefined
+        : { invocation: info.invocation.node, argumentCount: info.argumentCount, argumentIndex: info.argumentIndex };
+}
+function getArgumentOrParameterListInfo(node, sourceFile) {
+    const info = getArgumentOrParameterListAndIndex(node, sourceFile);
+    if (!info)
+        return undefined;
+    const { list, argumentIndex } = info;
+    const argumentCount = getArgumentCount(list);
+    if (argumentIndex !== 0) {
+        Debug.assertLessThan(argumentIndex, argumentCount);
+    }
+    const argumentsSpan = getApplicableSpanForArguments(list, sourceFile);
+    return { list, argumentIndex, argumentCount, argumentsSpan };
+}
+function getArgumentOrParameterListAndIndex(node, sourceFile) {
+    if (node.kind === SyntaxKind.LessThanToken || node.kind === SyntaxKind.OpenParenToken) {
+        // Find the list that starts right *after* the < or ( token.
+        // If the user has just opened a list, consider this item 0.
+        return { list: getChildListThatStartsWithOpenerToken(node.parent, node, sourceFile), argumentIndex: 0 };
+    }
+    else {
+        // findListItemInfo can return undefined if we are not in parent's argument list
+        // or type argument list. This includes cases where the cursor is:
+        //   - To the right of the closing parenthesis, non-substitution template, or template tail.
+        //   - Between the type arguments and the arguments (greater than token)
+        //   - On the target of the call (parent.func)
+        //   - On the 'new' keyword in a 'new' expression
+        const list = findContainingList(node);
+        return list && { list, argumentIndex: getArgumentIndex(list, node) };
+    }
+}
+/**
+ * A lista de argumentos e o argumento corrente, quando o nó está nos argumentos de uma chamada. A posição só servia, na
+ * tag, ao template marcado (CK-02).
+ */
+function getImmediatelyContainingArgumentInfo(node, _position, sourceFile) {
+    const { parent } = node;
+    // Na tag, também o `new` (CK-02).
+    if (isCallExpression(parent)) {
+        const invocation = parent;
+        // There are 3 cases to handle:
+        //   1. The token introduces a list, and should begin a signature help session
+        //   2. The token is either not associated with a list, or ends a list, so the session should end
+        //   3. The token is buried inside a list, and should give signature help
+        //
+        // The following are examples of each:
+        //
+        //    Case 1:
+        //          foo<#T, U>(#a, b)    -> The token introduces a list, and should begin a signature help session
+        //    Case 2:
+        //          fo#o<T, U>#(a, b)#   -> The token is either not associated with a list, or ends a list, so the session should end
+        //    Case 3:
+        //          foo<T#, U#>(a#, #b#) -> The token is buried inside a list, and should give signature help
+        // Find out if 'node' is an argument, a type argument, or neither
+        const info = getArgumentOrParameterListInfo(node, sourceFile);
+        if (!info)
+            return undefined;
+        const { list, argumentIndex, argumentCount, argumentsSpan } = info;
+        const isTypeParameterList = !!parent.typeArguments && parent.typeArguments.pos === list.pos;
+        return { isTypeParameterList, invocation: { kind: 0 /* InvocationKind.Call */, node: invocation }, argumentsSpan, argumentIndex, argumentCount };
+    }
+    // Na tag, os três ramos seguintes eram o do tagged template, que a Linguagem não tem (CK-02).
+    else if (isJsxOpeningLikeElement(parent)) {
+        // Provide a signature help for JSX opening element or JSX self-closing element.
+        // This is not guarantee that JSX tag-name is resolved into stateless function component. (that is done in "getSignatureHelpItems")
+        // i.e
+        //      export function MainButton(props: ButtonProps, context: any): JSX.Element { ... }
+        //      <MainButton /*signatureHelp*/
+        const attributeSpanStart = parent.attributes.pos;
+        const attributeSpanEnd = skipTrivia(sourceFile.text, parent.attributes.end, /*stopAfterLineBreak*/ false);
+        return {
+            isTypeParameterList: false,
+            invocation: { kind: 0 /* InvocationKind.Call */, node: parent },
+            argumentsSpan: createTextSpan(attributeSpanStart, attributeSpanEnd - attributeSpanStart),
+            argumentIndex: 0,
+            argumentCount: 1
+        };
+    }
+    else {
+        const typeArgInfo = getPossibleTypeArgumentsInfo(node, sourceFile);
+        if (typeArgInfo) {
+            const { called, nTypeArguments } = typeArgInfo;
+            const invocation = { kind: 1 /* InvocationKind.TypeArgs */, called };
+            const argumentsSpan = createTextSpanFromBounds(called.getStart(sourceFile), node.end);
+            return { isTypeParameterList: true, invocation, argumentsSpan, argumentIndex: nTypeArguments, argumentCount: nTypeArguments + 1 };
+        }
+        return undefined;
+    }
+}
+function getImmediatelyContainingArgumentOrContextualParameterInfo(node, position, sourceFile, checker) {
+    return tryGetParameterInfo(node, position, sourceFile, checker) || getImmediatelyContainingArgumentInfo(node, position, sourceFile);
+}
+function tryGetParameterInfo(startingToken, _position, sourceFile, checker) {
+    const info = getContextualSignatureLocationInfo(startingToken, sourceFile, checker);
+    if (!info)
+        return undefined;
+    const { contextualType, argumentIndex, argumentCount, argumentsSpan } = info;
+    const signatures = contextualType.getCallSignatures();
+    if (signatures.length !== 1)
+        return undefined;
+    const invocation = { kind: 2 /* InvocationKind.Contextual */, signature: first(signatures), node: startingToken, symbol: chooseBetterSymbol(contextualType.symbol) };
+    return { isTypeParameterList: false, invocation, argumentsSpan, argumentIndex, argumentCount };
+}
+/**
+ * Os parâmetros de uma arrow que se escreve onde o tipo dela já é esperado. Na tag, também os do método de um object literal
+ * e os de uma function expression (CK-02), e a expressão de vírgula que a arrow ainda sem o `=>` era (`(a, b`): o parser da
+ * cópia não a produz, porque o operador vírgula saiu (CK-02).
+ */
+function getContextualSignatureLocationInfo(startingToken, sourceFile, checker) {
+    if (startingToken.kind !== SyntaxKind.OpenParenToken && startingToken.kind !== SyntaxKind.CommaToken)
+        return undefined;
+    const { parent } = startingToken;
+    switch (parent.kind) {
+        case SyntaxKind.ParenthesizedExpression:
+        case SyntaxKind.ArrowFunction:
+            const info = getArgumentOrParameterListInfo(startingToken, sourceFile);
+            if (!info)
+                return undefined;
+            const { argumentIndex, argumentCount, argumentsSpan } = info;
+            const contextualType = checker.getContextualType(parent);
+            return contextualType && { contextualType, argumentIndex, argumentCount, argumentsSpan };
+        default:
+            return undefined;
+    }
+}
+// The type of a function type node has a symbol at that node, but it's better to use the symbol for a parameter or type alias.
+function chooseBetterSymbol(s) {
+    return s.name === InternalSymbolName.Type
+        ? firstDefined(s.declarations, d => isFunctionTypeNode(d) ? d.parent.symbol : undefined) || s
+        : s;
+}
+function getArgumentIndex(argumentsList, node) {
+    // The list we got back can include commas.  In the presence of errors it may
+    // also just have nodes without commas.  For example "Foo(a b c)" will have 3
+    // args without commas. We want to find what index we're at.  So we count
+    // forward until we hit ourselves, only incrementing the index if it isn't a
+    // comma.
+    //
+    // Note: the subtlety around trailing commas (in getArgumentCount) does not apply
+    // here.  That's because we're only walking forward until we hit the node we're
+    // on.  In that case, even if we're after the trailing comma, we'll still see
+    // that trailing comma in the list, and we'll have generated the appropriate
+    // arg index.
+    let argumentIndex = 0;
+    for (const child of argumentsList.getChildren()) {
+        if (child === node) {
+            break;
+        }
+        if (child.kind !== SyntaxKind.CommaToken) {
+            argumentIndex++;
+        }
+    }
+    return argumentIndex;
+}
+function getArgumentCount(argumentsList) {
+    // The argument count for a list is normally the number of non-comma children it has.
+    // For example, if you have "Foo(a,b)" then there will be three children of the arg
+    // list 'a' '<comma>' 'b'.  So, in this case the arg count will be 2.  However, there
+    // is a small subtlety.  If you have "Foo(a,)", then the child list will just have
+    // 'a' '<comma>'.  So, in the case where the last child is a comma, we increase the
+    // arg count by one to compensate.
+    //
+    // Note: this subtlety only applies to the last comma.  If you had "Foo(a,," then
+    // we'll have: 'a' '<comma>' '<missing>'
+    // That will give us 2 non-commas.  We then add one for the last comma, giving us an
+    // arg count of 3.
+    const listChildren = argumentsList.getChildren();
+    let argumentCount = countWhere(listChildren, arg => arg.kind !== SyntaxKind.CommaToken);
+    if (listChildren.length > 0 && last(listChildren).kind === SyntaxKind.CommaToken) {
+        argumentCount++;
+    }
+    return argumentCount;
+}
+function getApplicableSpanForArguments(argumentsList, sourceFile) {
+    // We use full start and skip trivia on the end because we want to include trivia on
+    // both sides. For example,
+    //
+    //    foo(   /*comment */     a, b, c      /*comment*/     )
+    //        |                                               |
+    //
+    // The applicable span is from the first bar to the second bar (inclusive,
+    // but not including parentheses)
+    const applicableSpanStart = argumentsList.getFullStart();
+    const applicableSpanEnd = skipTrivia(sourceFile.text, argumentsList.getEnd(), /*stopAfterLineBreak*/ false);
+    return createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart);
+}
+function getContainingArgumentInfo(node, position, sourceFile, checker, isManuallyInvoked) {
+    for (let n = node; !isSourceFile(n) && (isManuallyInvoked || !isBlock(n)); n = n.parent) {
+        // If the node is not a subspan of its parent, this is a big problem.
+        // There have been crashes that might be caused by this violation.
+        Debug.assert(rangeContainsRange(n.parent, n), "Not a subspan", () => `Child: ${Debug.formatSyntaxKind(n.kind)}, parent: ${Debug.formatSyntaxKind(n.parent.kind)}`);
+        const argumentInfo = getImmediatelyContainingArgumentOrContextualParameterInfo(n, position, sourceFile, checker);
+        if (argumentInfo) {
+            return argumentInfo;
+        }
+    }
+    return undefined;
+}
+function getChildListThatStartsWithOpenerToken(parent, openerToken, sourceFile) {
+    const children = parent.getChildren(sourceFile);
+    const indexOfOpenerToken = children.indexOf(openerToken);
+    Debug.assert(indexOfOpenerToken >= 0 && children.length > indexOfOpenerToken + 1);
+    return children[indexOfOpenerToken + 1];
+}
+function getExpressionFromInvocation(invocation) {
+    return invocation.kind === 0 /* InvocationKind.Call */ ? getInvokedExpression(invocation.node) : invocation.called;
+}
+function getEnclosingDeclarationFromInvocation(invocation) {
+    return invocation.kind === 0 /* InvocationKind.Call */ ? invocation.node : invocation.kind === 1 /* InvocationKind.TypeArgs */ ? invocation.called : invocation.node;
+}
+const signatureHelpNodeBuilderFlags = NodeBuilderFlags.OmitParameterModifiers | NodeBuilderFlags.IgnoreErrors | NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope;
+function createSignatureHelpItems(candidates, resolvedSignature, { isTypeParameterList, argumentCount, argumentsSpan: applicableSpan, invocation, argumentIndex }, sourceFile, typeChecker) {
+    const enclosingDeclaration = getEnclosingDeclarationFromInvocation(invocation);
+    const callTargetSymbol = invocation.kind === 2 /* InvocationKind.Contextual */ ? invocation.symbol : typeChecker.getSymbolAtLocation(getExpressionFromInvocation(invocation));
+    const callTargetDisplayParts = callTargetSymbol ? symbolToDisplayParts(typeChecker, callTargetSymbol, /*enclosingDeclaration*/ undefined, /*meaning*/ undefined) : emptyArray;
+    const items = candidates.map(candidateSignature => getSignatureHelpItem(candidateSignature, callTargetDisplayParts, isTypeParameterList, typeChecker, enclosingDeclaration, sourceFile));
+    if (argumentIndex !== 0) {
+        Debug.assertLessThan(argumentIndex, argumentCount);
+    }
+    const selectedItemIndex = candidates.indexOf(resolvedSignature);
+    Debug.assert(selectedItemIndex !== -1); // If candidates is non-empty it should always include bestSignature. We check for an empty candidates before calling this function.
+    return { items, applicableSpan, selectedItemIndex, argumentIndex, argumentCount };
+}
+function createTypeHelpItems(symbol, { argumentCount, argumentsSpan: applicableSpan, invocation, argumentIndex }, sourceFile, checker) {
+    const typeParameters = checker.getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
+    if (!typeParameters)
+        return undefined;
+    const items = [getTypeHelpItem(symbol, typeParameters, checker, getEnclosingDeclarationFromInvocation(invocation), sourceFile)];
+    return { items, applicableSpan, selectedItemIndex: 0, argumentIndex, argumentCount };
+}
+function getTypeHelpItem(symbol, typeParameters, checker, enclosingDeclaration, sourceFile) {
+    const typeSymbolDisplay = symbolToDisplayParts(checker, symbol);
+    const printer = createPrinter({ removeComments: true });
+    const parameters = typeParameters.map(t => createSignatureHelpParameterForTypeParameter(t, checker, enclosingDeclaration, sourceFile, printer));
+    // Na tag, a documentação e as tags do JSDoc do símbolo. Sem o JSDoc (CK-03), as duas saem vazias, como as de um símbolo
+    // sem comentário na tag.
+    const documentation = [];
+    const tags = [];
+    const prefixDisplayParts = [...typeSymbolDisplay, punctuationPart(SyntaxKind.LessThanToken)];
+    return { isVariadic: false, prefixDisplayParts, suffixDisplayParts: [punctuationPart(SyntaxKind.GreaterThanToken)], separatorDisplayParts, parameters, documentation, tags };
+}
+const separatorDisplayParts = [punctuationPart(SyntaxKind.CommaToken), spacePart()];
+function getSignatureHelpItem(candidateSignature, callTargetDisplayParts, isTypeParameterList, checker, enclosingDeclaration, sourceFile) {
+    const { isVariadic, parameters, prefix, suffix } = (isTypeParameterList ? itemInfoForTypeParameters : itemInfoForParameters)(candidateSignature, checker, enclosingDeclaration, sourceFile);
+    const prefixDisplayParts = [...callTargetDisplayParts, ...prefix];
+    const suffixDisplayParts = [...suffix, ...returnTypeToDisplayParts(candidateSignature, enclosingDeclaration, checker)];
+    // Na tag, a documentação e as tags do JSDoc da assinatura; sem o JSDoc (CK-03), vazias.
+    const documentation = [];
+    const tags = [];
+    return { isVariadic, prefixDisplayParts, suffixDisplayParts, separatorDisplayParts, parameters, documentation, tags };
+}
+function returnTypeToDisplayParts(candidateSignature, enclosingDeclaration, checker) {
+    return mapToDisplayParts(writer => {
+        writer.writePunctuation(":");
+        writer.writeSpace(" ");
+        const predicate = checker.getTypePredicateOfSignature(candidateSignature);
+        if (predicate) {
+            checker.writeTypePredicate(predicate, enclosingDeclaration, /*flags*/ undefined, writer);
+        }
+        else {
+            checker.writeType(checker.getReturnTypeOfSignature(candidateSignature), enclosingDeclaration, /*flags*/ undefined, writer);
+        }
+    });
+}
+function itemInfoForTypeParameters(candidateSignature, checker, enclosingDeclaration, sourceFile) {
+    const typeParameters = (candidateSignature.target || candidateSignature).typeParameters;
+    const printer = createPrinter({ removeComments: true });
+    const parameters = (typeParameters || emptyArray).map(t => createSignatureHelpParameterForTypeParameter(t, checker, enclosingDeclaration, sourceFile, printer));
+    const parameterParts = mapToDisplayParts(writer => {
+        // Na tag, também o parâmetro `this`, antes dos outros (CK-02).
+        const params = createNodeArray(checker.getExpandedParameters(candidateSignature).map(param => checker.symbolToParameterDeclaration(param, enclosingDeclaration, signatureHelpNodeBuilderFlags)));
+        printer.writeList(ListFormat.CallExpressionArguments, params, sourceFile, writer);
+    });
+    return { isVariadic: false, parameters, prefix: [punctuationPart(SyntaxKind.LessThanToken)], suffix: [punctuationPart(SyntaxKind.GreaterThanToken), ...parameterParts] };
+}
+function itemInfoForParameters(candidateSignature, checker, enclosingDeclaration, sourceFile) {
+    const isVariadic = checker.hasEffectiveRestParameter(candidateSignature);
+    const printer = createPrinter({ removeComments: true });
+    const typeParameterParts = mapToDisplayParts(writer => {
+        if (candidateSignature.typeParameters && candidateSignature.typeParameters.length) {
+            const args = createNodeArray(candidateSignature.typeParameters.map(p => checker.typeParameterToDeclaration(p, enclosingDeclaration, signatureHelpNodeBuilderFlags)));
+            printer.writeList(ListFormat.TypeParameters, args, sourceFile, writer);
+        }
+    });
+    const parameters = checker.getExpandedParameters(candidateSignature).map(p => createSignatureHelpParameterForParameter(p, checker, enclosingDeclaration, sourceFile, printer));
+    return { isVariadic, parameters, prefix: [...typeParameterParts, punctuationPart(SyntaxKind.OpenParenToken)], suffix: [punctuationPart(SyntaxKind.CloseParenToken)] };
+}
+function createSignatureHelpParameterForParameter(parameter, checker, enclosingDeclaration, sourceFile, printer) {
+    const displayParts = mapToDisplayParts(writer => {
+        const param = checker.symbolToParameterDeclaration(parameter, enclosingDeclaration, signatureHelpNodeBuilderFlags);
+        printer.writeNode(EmitHint.Unspecified, param, sourceFile, writer);
+    });
+    const isOptional = checker.isOptionalParameter(parameter.valueDeclaration);
+    // Na tag, a documentação do JSDoc do parâmetro; sem o JSDoc (CK-03), vazia.
+    return { name: parameter.name, documentation: [], displayParts, isOptional };
+}
+function createSignatureHelpParameterForTypeParameter(typeParameter, checker, enclosingDeclaration, sourceFile, printer) {
+    const displayParts = mapToDisplayParts(writer => {
+        const param = checker.typeParameterToDeclaration(typeParameter, enclosingDeclaration, signatureHelpNodeBuilderFlags);
+        printer.writeNode(EmitHint.Unspecified, param, sourceFile, writer);
+    });
+    // Na tag, a documentação do JSDoc do parâmetro de tipo; sem o JSDoc (CK-03), vazia.
+    return { name: typeParameter.symbol.name, documentation: [], displayParts, isOptional: false };
+}

package/dist/smartSelection.d.ts

@@ -0,0 +1,2 @@
+import type { SelectionRange, SourceFile } from "./_namespaces/ts.js";
+export declare function getSmartSelectionRange(pos: number, sourceFile: SourceFile): SelectionRange;