diff --git a/internal/fourslash/_scripts/convertFourslash.mts b/internal/fourslash/_scripts/convertFourslash.mts index d4dc96c952..f92a261c28 100644 --- a/internal/fourslash/_scripts/convertFourslash.mts +++ b/internal/fourslash/_scripts/convertFourslash.mts @@ -194,6 +194,14 @@ function parseFourslashStatement(statement: ts.Statement): Cmd[] | undefined { return parseBaselineQuickInfo(callExpression.arguments); case "baselineSignatureHelp": return [parseBaselineSignatureHelp(callExpression.arguments)]; + case "signatureHelp": + return parseSignatureHelp(callExpression.arguments); + case "noSignatureHelp": + return parseNoSignatureHelp(callExpression.arguments); + case "signatureHelpPresentForTriggerReason": + return parseSignatureHelpPresentForTriggerReason(callExpression.arguments); + case "noSignatureHelpForTriggerReason": + return parseNoSignatureHelpForTriggerReason(callExpression.arguments); case "baselineSmartSelection": return [parseBaselineSmartSelection(callExpression.arguments)]; case "baselineGoToDefinition": @@ -1679,6 +1687,334 @@ function parseBaselineSignatureHelp(args: ts.NodeArray): Cmd { }; } +function parseSignatureHelpOptions(obj: ts.ObjectLiteralExpression): VerifySignatureHelpOptions | undefined { + const options: VerifySignatureHelpOptions = {}; + + for (const prop of obj.properties) { + if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) { + console.error(`Unexpected property in signatureHelp options: ${prop.getText()}`); + continue; + } + const name = prop.name.text; + const value = prop.initializer; + + switch (name) { + case "marker": { + if (ts.isStringLiteral(value)) { + options.marker = value.text; + } + else if (ts.isArrayLiteralExpression(value)) { + const markers: string[] = []; + for (const elem of value.elements) { + if (ts.isStringLiteral(elem)) { + markers.push(elem.text); + } + else { + console.error(`Expected string literal in marker array, got ${elem.getText()}`); + return undefined; + } + } + options.marker = markers; + } + else { + console.error(`Expected string or array for marker, got ${value.getText()}`); + return undefined; + } + break; + } + case "text": { + const str = getStringLiteralLike(value); + if (!str) { + console.error(`Expected string for text, got ${value.getText()}`); + return undefined; + } + options.text = str.text; + break; + } + case "docComment": { + const str = getStringLiteralLike(value); + if (!str) { + console.error(`Expected string for docComment, got ${value.getText()}`); + return undefined; + } + options.docComment = str.text; + break; + } + case "parameterCount": { + const num = getNumericLiteral(value); + if (!num) { + console.error(`Expected number for parameterCount, got ${value.getText()}`); + return undefined; + } + options.parameterCount = parseInt(num.text, 10); + break; + } + case "parameterName": { + const str = getStringLiteralLike(value); + if (!str) { + console.error(`Expected string for parameterName, got ${value.getText()}`); + return undefined; + } + options.parameterName = str.text; + break; + } + case "parameterSpan": { + const str = getStringLiteralLike(value); + if (!str) { + console.error(`Expected string for parameterSpan, got ${value.getText()}`); + return undefined; + } + options.parameterSpan = str.text; + break; + } + case "parameterDocComment": { + const str = getStringLiteralLike(value); + if (!str) { + console.error(`Expected string for parameterDocComment, got ${value.getText()}`); + return undefined; + } + options.parameterDocComment = str.text; + break; + } + case "overloadsCount": { + const num = getNumericLiteral(value); + if (!num) { + console.error(`Expected number for overloadsCount, got ${value.getText()}`); + return undefined; + } + options.overloadsCount = parseInt(num.text, 10); + break; + } + case "overrideSelectedItemIndex": { + const num = getNumericLiteral(value); + if (!num) { + console.error(`Expected number for overrideSelectedItemIndex, got ${value.getText()}`); + return undefined; + } + options.overrideSelectedItemIndex = parseInt(num.text, 10); + break; + } + case "triggerReason": { + // triggerReason is an object like { kind: "invoked" } or { kind: "characterTyped", triggerCharacter: "(" } + // For now, just pass it through as a string representation + options.triggerReason = value.getText(); + break; + } + case "argumentCount": + // ignore + break; + case "isVariadic": { + if (value.kind === ts.SyntaxKind.TrueKeyword) { + options.isVariadic = true; + } + else if (value.kind === ts.SyntaxKind.FalseKeyword) { + options.isVariadic = false; + } + else { + console.error(`Expected boolean for isVariadic, got ${value.getText()}`); + return undefined; + } + break; + } + case "tags": + // ignore + break; + default: + console.error(`Unknown signatureHelp option: ${name}`); + return undefined; + } + } + return options; +} + +function parseSignatureHelp(args: ts.NodeArray): Cmd[] | undefined { + const allOptions: VerifySignatureHelpOptions[] = []; + + for (const arg of args) { + if (ts.isObjectLiteralExpression(arg)) { + const opts = parseSignatureHelpOptions(arg); + if (!opts) { + return undefined; + } + allOptions.push(opts); + } + else if (ts.isIdentifier(arg)) { + // Could be a variable reference like `help2` - skip for now + console.error(`signatureHelp with variable reference not supported: ${arg.getText()}`); + return undefined; + } + else { + console.error(`Unexpected argument type in signatureHelp: ${arg.getText()}`); + return undefined; + } + } + + if (allOptions.length === 0) { + console.error("signatureHelp requires at least one options object"); + return undefined; + } + + return [{ + kind: "verifySignatureHelp", + options: allOptions, + }]; +} + +function parseNoSignatureHelp(args: ts.NodeArray): Cmd[] | undefined { + const markers: string[] = []; + + for (const arg of args) { + if (ts.isStringLiteral(arg)) { + markers.push(arg.text); + } + else if (ts.isSpreadElement(arg)) { + // Handle ...test.markerNames() + const expr = arg.expression; + if ( + ts.isCallExpression(expr) && + ts.isPropertyAccessExpression(expr.expression) && + ts.isIdentifier(expr.expression.expression) && + expr.expression.expression.text === "test" && + ts.isIdentifier(expr.expression.name) && + expr.expression.name.text === "markerNames" + ) { + // This means "all markers" - we'll handle this specially in the generator + return [{ + kind: "verifyNoSignatureHelp", + markers: ["...test.markerNames()"], + }]; + } + console.error(`Unsupported spread in noSignatureHelp: ${arg.getText()}`); + return undefined; + } + else { + console.error(`Unexpected argument in noSignatureHelp: ${arg.getText()}`); + return undefined; + } + } + + return [{ + kind: "verifyNoSignatureHelp", + markers, + }]; +} + +interface SignatureHelpTriggerReason { + kind: "invoked" | "characterTyped" | "retrigger"; + triggerCharacter?: string; +} + +function parseTriggerReason(arg: ts.Expression): SignatureHelpTriggerReason | undefined | "undefined" { + // Handle undefined literal + if (ts.isIdentifier(arg) && arg.text === "undefined") { + return "undefined"; + } + + if (!ts.isObjectLiteralExpression(arg)) { + console.error(`Expected object literal for trigger reason, got ${arg.getText()}`); + return undefined; + } + + let kind: "invoked" | "characterTyped" | "retrigger" | undefined; + let triggerCharacter: string | undefined; + + for (const prop of arg.properties) { + if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) { + console.error(`Unexpected property in trigger reason: ${prop.getText()}`); + return undefined; + } + const name = prop.name.text; + if (name === "kind") { + if (!ts.isStringLiteral(prop.initializer)) { + console.error(`Expected string literal for kind, got ${prop.initializer.getText()}`); + return undefined; + } + const k = prop.initializer.text; + if (k === "invoked" || k === "characterTyped" || k === "retrigger") { + kind = k; + } + else { + console.error(`Unknown trigger reason kind: ${k}`); + return undefined; + } + } + else if (name === "triggerCharacter") { + if (!ts.isStringLiteral(prop.initializer)) { + console.error(`Expected string literal for triggerCharacter, got ${prop.initializer.getText()}`); + return undefined; + } + triggerCharacter = prop.initializer.text; + } + } + + if (!kind) { + console.error(`Missing kind in trigger reason`); + return undefined; + } + + return { kind, triggerCharacter }; +} + +function parseSignatureHelpPresentForTriggerReason(args: ts.NodeArray): Cmd[] | undefined { + if (args.length === 0) { + console.error("signatureHelpPresentForTriggerReason requires at least one argument"); + return undefined; + } + + const triggerReason = parseTriggerReason(args[0]); + if (triggerReason === undefined) { + return undefined; + } + + const markers: string[] = []; + for (let i = 1; i < args.length; i++) { + const arg = args[i]; + if (ts.isStringLiteral(arg)) { + markers.push(arg.text); + } + else { + console.error(`Unexpected argument in signatureHelpPresentForTriggerReason: ${arg.getText()}`); + return undefined; + } + } + + return [{ + kind: "verifySignatureHelpPresent", + triggerReason: triggerReason === "undefined" ? undefined : triggerReason, + markers, + }]; +} + +function parseNoSignatureHelpForTriggerReason(args: ts.NodeArray): Cmd[] | undefined { + if (args.length === 0) { + console.error("noSignatureHelpForTriggerReason requires at least one argument"); + return undefined; + } + + const triggerReason = parseTriggerReason(args[0]); + if (triggerReason === undefined) { + return undefined; + } + + const markers: string[] = []; + for (let i = 1; i < args.length; i++) { + const arg = args[i]; + if (ts.isStringLiteral(arg)) { + markers.push(arg.text); + } + else { + console.error(`Unexpected argument in noSignatureHelpForTriggerReason: ${arg.getText()}`); + return undefined; + } + } + + return [{ + kind: "verifyNoSignatureHelpForTriggerReason", + triggerReason: triggerReason === "undefined" ? undefined : triggerReason, + markers, + }]; +} + function parseBaselineSmartSelection(args: ts.NodeArray): Cmd { if (args.length !== 0) { // All calls are currently empty! @@ -2126,6 +2462,42 @@ interface VerifyNavToCmd { args: string[]; } +interface VerifySignatureHelpOptions { + marker?: string | string[]; + text?: string; + docComment?: string; + parameterCount?: number; + parameterName?: string; + parameterSpan?: string; + parameterDocComment?: string; + overloadsCount?: number; + overrideSelectedItemIndex?: number; + triggerReason?: string; + isVariadic?: boolean; +} + +interface VerifySignatureHelpCmd { + kind: "verifySignatureHelp"; + options: VerifySignatureHelpOptions[]; +} + +interface VerifyNoSignatureHelpCmd { + kind: "verifyNoSignatureHelp"; + markers: string[]; +} + +interface VerifySignatureHelpPresentCmd { + kind: "verifySignatureHelpPresent"; + triggerReason?: SignatureHelpTriggerReason; + markers: string[]; +} + +interface VerifyNoSignatureHelpForTriggerReasonCmd { + kind: "verifyNoSignatureHelpForTriggerReason"; + triggerReason?: SignatureHelpTriggerReason; + markers: string[]; +} + type Cmd = | VerifyCompletionsCmd | VerifyApplyCodeActionFromCompletionCmd @@ -2135,6 +2507,10 @@ type Cmd = | VerifyBaselineQuickInfoCmd | VerifyBaselineSignatureHelpCmd | VerifyBaselineSmartSelection + | VerifySignatureHelpCmd + | VerifyNoSignatureHelpCmd + | VerifySignatureHelpPresentCmd + | VerifyNoSignatureHelpForTriggerReasonCmd | GoToCmd | EditCmd | VerifyQuickInfoCmd @@ -2258,6 +2634,124 @@ function generateImportFixAtPosition({ expectedTexts, preferences }: VerifyImpor return `f.VerifyImportFixAtPosition(t, []string{\n${expectedTexts.join(",\n")},\n}, ${preferences})`; } +function generateSignatureHelpExpected(opts: VerifySignatureHelpOptions): string { + const fields: string[] = []; + + if (opts.text !== undefined) { + fields.push(`Text: ${getGoStringLiteral(opts.text)}`); + } + if (opts.docComment !== undefined) { + fields.push(`DocComment: ${getGoStringLiteral(opts.docComment)}`); + } + if (opts.parameterCount !== undefined) { + fields.push(`ParameterCount: ${opts.parameterCount}`); + } + if (opts.parameterName !== undefined) { + fields.push(`ParameterName: ${getGoStringLiteral(opts.parameterName)}`); + } + if (opts.parameterSpan !== undefined) { + fields.push(`ParameterSpan: ${getGoStringLiteral(opts.parameterSpan)}`); + } + if (opts.parameterDocComment !== undefined) { + fields.push(`ParameterDocComment: ${getGoStringLiteral(opts.parameterDocComment)}`); + } + if (opts.overloadsCount !== undefined) { + fields.push(`OverloadsCount: ${opts.overloadsCount}`); + } + if (opts.overrideSelectedItemIndex !== undefined) { + fields.push(`OverrideSelectedItemIndex: ${opts.overrideSelectedItemIndex}`); + } + if (opts.isVariadic !== undefined) { + fields.push(`IsVariadic: ${opts.isVariadic}`); + fields.push(`IsVariadicSet: true`); + } + + return `fourslash.VerifySignatureHelpOptions{${fields.join(", ")}}`; +} + +function generateSignatureHelp({ options }: VerifySignatureHelpCmd): string { + const lines: string[] = []; + + for (const opts of options) { + const expected = generateSignatureHelpExpected(opts); + + // Add comments for unsupported options + const unsupportedComments: string[] = []; + + if (opts.marker !== undefined) { + const markers = Array.isArray(opts.marker) ? opts.marker : [opts.marker]; + for (const marker of markers) { + lines.push(`f.GoToMarker(t, ${getGoStringLiteral(marker)})`); + for (const comment of unsupportedComments) { + lines.push(comment); + } + lines.push(`f.VerifySignatureHelp(t, ${expected})`); + } + } + else { + // No marker specified, use current position + for (const comment of unsupportedComments) { + lines.push(comment); + } + lines.push(`f.VerifySignatureHelp(t, ${expected})`); + } + } + + return lines.join("\n"); +} + +function generateNoSignatureHelp({ markers }: VerifyNoSignatureHelpCmd): string { + if (markers.length === 1 && markers[0] === "...test.markerNames()") { + // All markers + return `f.VerifyNoSignatureHelpForMarkers(t, f.MarkerNames()...)`; + } + if (markers.length === 0) { + // Current position + return `f.VerifyNoSignatureHelp(t)`; + } + // Specific markers + const markerArgs = markers.map(m => getGoStringLiteral(m)).join(", "); + return `f.VerifyNoSignatureHelpForMarkers(t, ${markerArgs})`; +} + +function generateTriggerContext(triggerReason: SignatureHelpTriggerReason | undefined): string { + if (!triggerReason) { + return "nil"; + } + switch (triggerReason.kind) { + case "invoked": + return `&lsproto.SignatureHelpContext{TriggerKind: lsproto.SignatureHelpTriggerKindInvoked}`; + case "characterTyped": + return `&lsproto.SignatureHelpContext{TriggerKind: lsproto.SignatureHelpTriggerKindTriggerCharacter, TriggerCharacter: PtrTo(${getGoStringLiteral(triggerReason.triggerCharacter ?? "")}), IsRetrigger: false}`; + case "retrigger": + return `&lsproto.SignatureHelpContext{TriggerKind: lsproto.SignatureHelpTriggerKindTriggerCharacter, TriggerCharacter: PtrTo(${getGoStringLiteral(triggerReason.triggerCharacter ?? "")}), IsRetrigger: true}`; + default: + throw new Error(`Unknown trigger reason kind: ${triggerReason}`); + } +} + +function generateSignatureHelpPresent({ triggerReason, markers }: VerifySignatureHelpPresentCmd): string { + const context = generateTriggerContext(triggerReason); + if (markers.length === 0) { + // Current position + return `f.VerifySignatureHelpPresent(t, ${context})`; + } + // Specific markers + const markerArgs = markers.map(m => getGoStringLiteral(m)).join(", "); + return `f.VerifySignatureHelpPresentForMarkers(t, ${context}, ${markerArgs})`; +} + +function generateNoSignatureHelpForTriggerReason({ triggerReason, markers }: VerifyNoSignatureHelpForTriggerReasonCmd): string { + const context = generateTriggerContext(triggerReason); + if (markers.length === 0) { + // Current position + return `f.VerifyNoSignatureHelpWithContext(t, ${context})`; + } + // Specific markers + const markerArgs = markers.map(m => getGoStringLiteral(m)).join(", "); + return `f.VerifyNoSignatureHelpForMarkersWithContext(t, ${context}, ${markerArgs})`; +} + function generateNavigateTo({ args }: VerifyNavToCmd): string { return `f.VerifyWorkspaceSymbol(t, []*fourslash.VerifyWorkspaceSymbolCase{\n${args.join(", ")}})`; } @@ -2310,6 +2804,14 @@ function generateCmd(cmd: Cmd): string { return `f.VerifyBaselineNonSuggestionDiagnostics(t)`; case "verifyNavigateTo": return generateNavigateTo(cmd); + case "verifySignatureHelp": + return generateSignatureHelp(cmd); + case "verifyNoSignatureHelp": + return generateNoSignatureHelp(cmd); + case "verifySignatureHelpPresent": + return generateSignatureHelpPresent(cmd); + case "verifyNoSignatureHelpForTriggerReason": + return generateNoSignatureHelpForTriggerReason(cmd); default: let neverCommand: never = cmd; throw new Error(`Unknown command kind: ${neverCommand as Cmd["kind"]}`); diff --git a/internal/fourslash/_scripts/failingTests.txt b/internal/fourslash/_scripts/failingTests.txt index bb01a0e577..d9ed2dcb55 100644 --- a/internal/fourslash/_scripts/failingTests.txt +++ b/internal/fourslash/_scripts/failingTests.txt @@ -43,10 +43,17 @@ TestAutoImportTypeOnlyPreferred2 TestAutoImportVerbatimTypeOnly1 TestBestCommonTypeObjectLiterals TestBestCommonTypeObjectLiterals1 +TestCalledUnionsOfDissimilarTyeshaveGoodDisplay TestCodeCompletionEscaping TestCommentsEnumsFourslash +TestCommentsExternalModulesFourslash +TestCommentsImportDeclaration +TestCommentsInheritanceFourslash +TestCommentsInterfaceFourslash TestCommentsLinePreservation +TestCommentsOverloadsFourslash TestCommentsUnion +TestCommentsVariables TestCompletionAfterQuestionDot TestCompletionAutoInsertQuestionDot TestCompletionCloneQuestionToken @@ -227,6 +234,7 @@ TestCompletionWithConditionalOperatorMissingColon TestConstEnumQuickInfoAndCompletionList TestConstQuickInfoAndCompletionList TestContextuallyTypedFunctionExpressionGeneric1 +TestCrossFileQuickInfoExportedTypeDoesNotUseImportType TestDoubleUnderscoreCompletions TestEditJsdocType TestExportDefaultClass @@ -331,7 +339,6 @@ TestJsdocCallbackTag TestJsDocExtends TestJsDocFunctionSignatures10 TestJsDocFunctionSignatures11 -TestJsDocFunctionSignatures12 TestJsDocFunctionSignatures13 TestJsDocFunctionSignatures7 TestJsDocFunctionSignatures8 @@ -428,11 +435,13 @@ TestPathCompletionsTypesVersionsWildcard4 TestPathCompletionsTypesVersionsWildcard5 TestPathCompletionsTypesVersionsWildcard6 TestProtoVarVisibleWithOuterScopeUnderscoreProto +TestQualifyModuleTypeNames TestQuickInfo_notInsideComment TestQuickinfo01 TestQuickInfoAlias TestQuickInfoAssertionNodeNotReusedWhenTypeNotEquivalent1 TestQuickInfoBindingPatternInJsdocNoCrash1 +TestQuickInfoCanBeTruncated TestQuickInfoClassKeyword TestQuickInfoContextuallyTypedSignatureOptionalParameterFromIntersection1 TestQuickInfoContextualTyping @@ -541,7 +550,6 @@ TestRenameFromNodeModulesDep4 TestRenamePrivateFields TestReverseMappedTypeQuickInfo TestSelfReferencedExternalModule -TestSignatureHelpInferenceJsDocImportTag TestStringCompletionsImportOrExportSpecifier TestStringCompletionsVsEscaping TestSymbolCompletionLowerPriority diff --git a/internal/fourslash/_scripts/manualTests.txt b/internal/fourslash/_scripts/manualTests.txt index 1dfd6557eb..970916f313 100644 --- a/internal/fourslash/_scripts/manualTests.txt +++ b/internal/fourslash/_scripts/manualTests.txt @@ -13,3 +13,5 @@ quickInfoForOverloadOnConst1 renameDefaultKeyword renameForDefaultExport01 tsxCompletion12 +jsDocFunctionSignatures2 +jsDocFunctionSignatures12 diff --git a/internal/fourslash/fourslash.go b/internal/fourslash/fourslash.go index 90a701b36c..dbf7f02d82 100644 --- a/internal/fourslash/fourslash.go +++ b/internal/fourslash/fourslash.go @@ -1516,7 +1516,7 @@ func (f *FourslashTest) VerifyBaselineSignatureHelp(t *testing.T) { params := &lsproto.SignatureHelpParams{ TextDocument: lsproto.TextDocumentIdentifier{ - Uri: lsconv.FileNameToDocumentURI(f.activeFilename), + Uri: lsconv.FileNameToDocumentURI(marker.FileName()), }, Position: marker.LSPosition, } @@ -1547,9 +1547,18 @@ func (f *FourslashTest) VerifyBaselineSignatureHelp(t *testing.T) { signatureLine := sig.Label activeParamLine := "" + // Determine active parameter: per-signature takes precedence over top-level per LSP spec + // "If provided (or `null`), this is used in place of `SignatureHelp.activeParameter`." + var activeParamPtr *lsproto.UintegerOrNull + if sig.ActiveParameter != nil { + activeParamPtr = sig.ActiveParameter + } else { + activeParamPtr = item.ActiveParameter + } + // Show active parameter if specified, and the signature text. - if item.ActiveParameter != nil && sig.Parameters != nil { - activeParamIndex := int(*item.ActiveParameter.Uinteger) + if activeParamPtr != nil && activeParamPtr.Uinteger != nil && sig.Parameters != nil { + activeParamIndex := int(*activeParamPtr.Uinteger) if activeParamIndex >= 0 && activeParamIndex < len(*sig.Parameters) { activeParam := (*sig.Parameters)[activeParamIndex] @@ -2083,13 +2092,277 @@ func (f *FourslashTest) VerifyQuickInfoIs(t *testing.T, expectedText string, exp f.verifyHoverContent(t, hover.Contents, expectedText, expectedDocumentation, f.getCurrentPositionPrefix()) } +// VerifySignatureHelpOptions contains options for verifying signature help. +// All fields are optional - only specified fields will be verified. +type VerifySignatureHelpOptions struct { + // Text is the full signature text (e.g., "fn(x: string, y: number): void") + Text string + // DocComment is the documentation comment for the signature + DocComment string + // ParameterCount is the expected number of parameters + ParameterCount int + // ParameterName is the expected name of the active parameter + ParameterName string + // ParameterSpan is the expected label of the active parameter (e.g., "x: string") + ParameterSpan string + // ParameterDocComment is the documentation for the active parameter + ParameterDocComment string + // OverloadsCount is the expected number of overloads (signatures) + OverloadsCount int + // OverrideSelectedItemIndex overrides which signature to check (default: ActiveSignature) + OverrideSelectedItemIndex int + // IsVariadic indicates if the signature has a rest parameter + IsVariadic bool + // IsVariadicSet is true when IsVariadic was explicitly set (to distinguish from default false) + IsVariadicSet bool +} + +// VerifySignatureHelp verifies signature help at the current position matches the expected options. +func (f *FourslashTest) VerifySignatureHelp(t *testing.T, expected VerifySignatureHelpOptions) { + t.Helper() + prefix := f.getCurrentPositionPrefix() + params := &lsproto.SignatureHelpParams{ + TextDocument: lsproto.TextDocumentIdentifier{ + Uri: lsconv.FileNameToDocumentURI(f.activeFilename), + }, + Position: f.currentCaretPosition, + } + result := sendRequest(t, f, lsproto.TextDocumentSignatureHelpInfo, params) + help := result.SignatureHelp + if help == nil { + t.Fatalf("%sCould not get signature help", prefix) + } + + // Determine which signature to check + selectedIndex := 0 + if expected.OverrideSelectedItemIndex > 0 { + selectedIndex = expected.OverrideSelectedItemIndex + } else if help.ActiveSignature != nil { + selectedIndex = int(*help.ActiveSignature) + } + + if selectedIndex >= len(help.Signatures) { + t.Fatalf("%sSelected signature index %d out of range (have %d signatures)", prefix, selectedIndex, len(help.Signatures)) + } + + selectedSig := help.Signatures[selectedIndex] + + // Verify overloads count + if expected.OverloadsCount > 0 { + if len(help.Signatures) != expected.OverloadsCount { + t.Errorf("%sExpected %d overloads, got %d", prefix, expected.OverloadsCount, len(help.Signatures)) + } + } + + // Verify signature text + if expected.Text != "" { + if selectedSig.Label != expected.Text { + t.Errorf("%sExpected signature text %q, got %q", prefix, expected.Text, selectedSig.Label) + } + } + + // Verify doc comment + if expected.DocComment != "" { + actualDoc := "" + if selectedSig.Documentation != nil { + if selectedSig.Documentation.MarkupContent != nil { + actualDoc = selectedSig.Documentation.MarkupContent.Value + } else if selectedSig.Documentation.String != nil { + actualDoc = *selectedSig.Documentation.String + } + } + if actualDoc != expected.DocComment { + t.Errorf("%sExpected doc comment %q, got %q", prefix, expected.DocComment, actualDoc) + } + } + + // Verify parameter count + if expected.ParameterCount > 0 { + paramCount := 0 + if selectedSig.Parameters != nil { + paramCount = len(*selectedSig.Parameters) + } + if paramCount != expected.ParameterCount { + t.Errorf("%sExpected %d parameters, got %d", prefix, expected.ParameterCount, paramCount) + } + } + + // Get active parameter + var activeParamIndex int + if selectedSig.ActiveParameter != nil && selectedSig.ActiveParameter.Uinteger != nil { + activeParamIndex = int(*selectedSig.ActiveParameter.Uinteger) + } else if help.ActiveParameter != nil && help.ActiveParameter.Uinteger != nil { + activeParamIndex = int(*help.ActiveParameter.Uinteger) + } + + var activeParam *lsproto.ParameterInformation + if selectedSig.Parameters != nil && activeParamIndex < len(*selectedSig.Parameters) { + activeParam = (*selectedSig.Parameters)[activeParamIndex] + } + + // Verify parameter name + if expected.ParameterName != "" { + if activeParam == nil { + t.Errorf("%sExpected parameter name %q, but no active parameter", prefix, expected.ParameterName) + } else { + // Parameter name is extracted from the label + actualName := "" + if activeParam.Label.String != nil { + // Extract name from label like "x: string" -> "x" or "T extends Foo" -> "T" or "...x: any[]" -> "x" + label := *activeParam.Label.String + // Strip leading "..." for rest parameters + label = strings.TrimPrefix(label, "...") + if name, _, found := strings.Cut(label, ":"); found { + actualName = strings.TrimSpace(name) + } else if name, _, found := strings.Cut(label, " extends "); found { + actualName = strings.TrimSpace(name) + } else { + actualName = label + } + } + if actualName != expected.ParameterName { + t.Errorf("%sExpected parameter name %q, got %q", prefix, expected.ParameterName, actualName) + } + } + } + + // Verify parameter span (label) + if expected.ParameterSpan != "" { + if activeParam == nil { + t.Errorf("%sExpected parameter span %q, but no active parameter", prefix, expected.ParameterSpan) + } else { + actualSpan := "" + if activeParam.Label.String != nil { + actualSpan = *activeParam.Label.String + } + if actualSpan != expected.ParameterSpan { + t.Errorf("%sExpected parameter span %q, got %q", prefix, expected.ParameterSpan, actualSpan) + } + } + } + + // Verify parameter doc comment + if expected.ParameterDocComment != "" { + if activeParam == nil { + t.Errorf("%sExpected parameter doc comment %q, but no active parameter", prefix, expected.ParameterDocComment) + } else { + actualDoc := "" + if activeParam.Documentation != nil { + if activeParam.Documentation.MarkupContent != nil { + actualDoc = activeParam.Documentation.MarkupContent.Value + } else if activeParam.Documentation.String != nil { + actualDoc = *activeParam.Documentation.String + } + } + if actualDoc != expected.ParameterDocComment { + t.Errorf("%sExpected parameter doc comment %q, got %q", prefix, expected.ParameterDocComment, actualDoc) + } + } + } + + // Verify isVariadic (check if any parameter starts with "...") + if expected.IsVariadicSet { + actualIsVariadic := false + if selectedSig.Parameters != nil { + for _, param := range *selectedSig.Parameters { + if param.Label.String != nil && strings.HasPrefix(*param.Label.String, "...") { + actualIsVariadic = true + break + } + } + } + if actualIsVariadic != expected.IsVariadic { + t.Errorf("%sExpected isVariadic=%v, got %v", prefix, expected.IsVariadic, actualIsVariadic) + } + } +} + +// VerifyNoSignatureHelp verifies that no signature help is available at the current position. +func (f *FourslashTest) VerifyNoSignatureHelp(t *testing.T) { + t.Helper() + prefix := f.getCurrentPositionPrefix() + params := &lsproto.SignatureHelpParams{ + TextDocument: lsproto.TextDocumentIdentifier{ + Uri: lsconv.FileNameToDocumentURI(f.activeFilename), + }, + Position: f.currentCaretPosition, + } + result := sendRequest(t, f, lsproto.TextDocumentSignatureHelpInfo, params) + if result.SignatureHelp != nil && len(result.SignatureHelp.Signatures) > 0 { + t.Errorf("%sExpected no signature help, but got %d signatures", prefix, len(result.SignatureHelp.Signatures)) + } +} + +// VerifyNoSignatureHelpWithContext verifies that no signature help is available at the current position with a given context. +func (f *FourslashTest) VerifyNoSignatureHelpWithContext(t *testing.T, context *lsproto.SignatureHelpContext) { + t.Helper() + prefix := f.getCurrentPositionPrefix() + params := &lsproto.SignatureHelpParams{ + TextDocument: lsproto.TextDocumentIdentifier{ + Uri: lsconv.FileNameToDocumentURI(f.activeFilename), + }, + Position: f.currentCaretPosition, + Context: context, + } + result := sendRequest(t, f, lsproto.TextDocumentSignatureHelpInfo, params) + if result.SignatureHelp != nil && len(result.SignatureHelp.Signatures) > 0 { + t.Errorf("%sExpected no signature help, but got %d signatures", prefix, len(result.SignatureHelp.Signatures)) + } +} + +// VerifyNoSignatureHelpForMarkersWithContext verifies that no signature help is available at the given markers with a given context. +func (f *FourslashTest) VerifyNoSignatureHelpForMarkersWithContext(t *testing.T, context *lsproto.SignatureHelpContext, markers ...string) { + t.Helper() + for _, marker := range markers { + f.GoToMarker(t, marker) + f.VerifyNoSignatureHelpWithContext(t, context) + } +} + +// VerifySignatureHelpPresent verifies that signature help is available at the current position with a given context. +func (f *FourslashTest) VerifySignatureHelpPresent(t *testing.T, context *lsproto.SignatureHelpContext) { + t.Helper() + prefix := f.getCurrentPositionPrefix() + params := &lsproto.SignatureHelpParams{ + TextDocument: lsproto.TextDocumentIdentifier{ + Uri: lsconv.FileNameToDocumentURI(f.activeFilename), + }, + Position: f.currentCaretPosition, + Context: context, + } + result := sendRequest(t, f, lsproto.TextDocumentSignatureHelpInfo, params) + if result.SignatureHelp == nil || len(result.SignatureHelp.Signatures) == 0 { + t.Errorf("%sExpected signature help to be present, but got none", prefix) + } +} + +// VerifySignatureHelpPresentForMarkers verifies that signature help is available at the given markers with a given context. +func (f *FourslashTest) VerifySignatureHelpPresentForMarkers(t *testing.T, context *lsproto.SignatureHelpContext, markers ...string) { + t.Helper() + for _, marker := range markers { + f.GoToMarker(t, marker) + f.VerifySignatureHelpPresent(t, context) + } +} + +// VerifyNoSignatureHelpForMarkers verifies that no signature help is available at the given markers. +func (f *FourslashTest) VerifyNoSignatureHelpForMarkers(t *testing.T, markers ...string) { + t.Helper() + for _, marker := range markers { + f.GoToMarker(t, marker) + f.VerifyNoSignatureHelp(t) + } +} + type SignatureHelpCase struct { Context *lsproto.SignatureHelpContext MarkerInput MarkerInput Expected *lsproto.SignatureHelp } -func (f *FourslashTest) VerifySignatureHelp(t *testing.T, signatureHelpCases ...*SignatureHelpCase) { +// VerifySignatureHelpWithCases verifies signature help using detailed SignatureHelpCase structs. +// This is useful for more complex tests that need to verify the full signature help response. +func (f *FourslashTest) VerifySignatureHelpWithCases(t *testing.T, signatureHelpCases ...*SignatureHelpCase) { for _, option := range signatureHelpCases { switch marker := option.MarkerInput.(type) { case string: diff --git a/internal/fourslash/tests/gen/augmentedTypesModule2_test.go b/internal/fourslash/tests/gen/augmentedTypesModule2_test.go new file mode 100644 index 0000000000..c154fa8902 --- /dev/null +++ b/internal/fourslash/tests/gen/augmentedTypesModule2_test.go @@ -0,0 +1,40 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + . "github.com/microsoft/typescript-go/internal/fourslash/tests/util" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestAugmentedTypesModule2(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function /*11*/m2f(x: number) { }; +namespace m2f { export interface I { foo(): void } } +var x: m2f./*1*/ +var /*2*/r = m2f/*3*/;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyQuickInfoAt(t, "11", "function m2f(x: number): void\nnamespace m2f", "") + f.VerifyCompletions(t, "1", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Exact: []fourslash.CompletionsExpectedItem{ + "I", + }, + }, + }) + f.Insert(t, "I.") + f.VerifyCompletions(t, nil, nil) + f.Backspace(t, 1) + f.VerifyQuickInfoAt(t, "2", "var r: (x: number) => void", "") + f.GoToMarker(t, "3") + f.Insert(t, "(") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "m2f(x: number): void"}) +} diff --git a/internal/fourslash/tests/gen/augmentedTypesModule3_test.go b/internal/fourslash/tests/gen/augmentedTypesModule3_test.go new file mode 100644 index 0000000000..ba25d9da4d --- /dev/null +++ b/internal/fourslash/tests/gen/augmentedTypesModule3_test.go @@ -0,0 +1,39 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + . "github.com/microsoft/typescript-go/internal/fourslash/tests/util" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestAugmentedTypesModule3(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function m2g() { }; +module m2g { export class C { foo(x: number) { } } } +var x: m2g./*1*/; +var /*2*/r = m2g/*3*/;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyCompletions(t, "1", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Exact: []fourslash.CompletionsExpectedItem{ + "C", + }, + }, + }) + f.Insert(t, "C.") + f.VerifyCompletions(t, nil, nil) + f.Backspace(t, 1) + f.VerifyQuickInfoAt(t, "2", "var r: typeof m2g", "") + f.GoToMarker(t, "3") + f.Insert(t, "(") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "m2g(): void"}) +} diff --git a/internal/fourslash/tests/gen/augmentedTypesModule6_test.go b/internal/fourslash/tests/gen/augmentedTypesModule6_test.go new file mode 100644 index 0000000000..ac34839573 --- /dev/null +++ b/internal/fourslash/tests/gen/augmentedTypesModule6_test.go @@ -0,0 +1,81 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + . "github.com/microsoft/typescript-go/internal/fourslash/tests/util" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestAugmentedTypesModule6(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `declare class m3f { foo(x: number): void } +module m3f { export interface I { foo(): void } } +var x: m3f./*1*/ +var /*4*/r = new /*2*/m3f(/*3*/); +r./*5*/ +var r2: m3f.I = r; +r2./*6*/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyCompletions(t, "1", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + "I", + }, + Excludes: []string{ + "foo", + }, + }, + }) + f.Insert(t, "I;") + f.VerifyCompletions(t, "2", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + "m3f", + }, + }, + }) + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "m3f(): m3f"}) + f.VerifyQuickInfoAt(t, "4", "var r: m3f", "") + f.VerifyCompletions(t, "5", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + "foo", + }, + }, + }) + f.Insert(t, "foo(1)") + f.VerifyCompletions(t, "6", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + "foo", + }, + }, + }) + f.Insert(t, "foo(") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo(): void"}) +} diff --git a/internal/fourslash/tests/gen/callSignatureHelp_test.go b/internal/fourslash/tests/gen/callSignatureHelp_test.go new file mode 100644 index 0000000000..3d3d8f75b0 --- /dev/null +++ b/internal/fourslash/tests/gen/callSignatureHelp_test.go @@ -0,0 +1,22 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestCallSignatureHelp(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `interface C { + (): number; +} +var c: C; +c(/**/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "c(): number"}) +} diff --git a/internal/fourslash/tests/gen/calledUnionsOfDissimilarTyeshaveGoodDisplay_test.go b/internal/fourslash/tests/gen/calledUnionsOfDissimilarTyeshaveGoodDisplay_test.go new file mode 100644 index 0000000000..792902cdc9 --- /dev/null +++ b/internal/fourslash/tests/gen/calledUnionsOfDissimilarTyeshaveGoodDisplay_test.go @@ -0,0 +1,67 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestCalledUnionsOfDissimilarTyeshaveGoodDisplay(t *testing.T) { + t.Parallel() + t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `declare const callableThing1: + | ((o1: {x: number}) => void) + | ((o1: {y: number}) => void) + ; + +callableThing1(/*1*/); + +declare const callableThing2: + | ((o1: {x: number}) => void) + | ((o2: {y: number}) => void) + ; + +callableThing2(/*2*/); + +declare const callableThing3: + | ((o1: {x: number}) => void) + | ((o2: {y: number}) => void) + | ((o3: {z: number}) => void) + | ((o4: {u: number}) => void) + | ((o5: {v: number}) => void) + ; + +callableThing3(/*3*/); + +declare const callableThing4: + | ((o1: {x: number}) => void) + | ((o2: {y: number}) => void) + | ((o3: {z: number}) => void) + | ((o4: {u: number}) => void) + | ((o5: {v: number}) => void) + | ((o6: {w: number}) => void) + ; + +callableThing4(/*4*/); + +declare const callableThing5: + | ((a1: U) => void) + | (() => void) + ; + +callableThing5(/*5*/1) +` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "callableThing1(o1: { x: number; } & { y: number; }): void"}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "callableThing2(arg0: { x: number; } & { y: number; }): void"}) + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "callableThing3(arg0: { x: number; } & { y: number; } & { z: number; } & { u: number; } & { v: number; }): void"}) + f.GoToMarker(t, "4") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "callableThing4(arg0: { x: number; } & { y: number; } & { z: number; } & { u: number; } & { v: number; } & { w: number; }): void"}) + f.GoToMarker(t, "5") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "callableThing5(a1: number): void"}) +} diff --git a/internal/fourslash/tests/gen/classExtendsInterfaceSigHelp1_test.go b/internal/fourslash/tests/gen/classExtendsInterfaceSigHelp1_test.go new file mode 100644 index 0000000000..03c942bca6 --- /dev/null +++ b/internal/fourslash/tests/gen/classExtendsInterfaceSigHelp1_test.go @@ -0,0 +1,27 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestClassExtendsInterfaceSigHelp1(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class C { + public foo(x: string); + public foo(x: number); + public foo(x: any) { return x; } +} +interface I extends C { + other(x: any): any; +} +var i: I; +i.foo(/**/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterSpan: "x: string", OverloadsCount: 2}) +} diff --git a/internal/fourslash/tests/gen/commentsExternalModulesFourslash_test.go b/internal/fourslash/tests/gen/commentsExternalModulesFourslash_test.go new file mode 100644 index 0000000000..04a3debbe3 --- /dev/null +++ b/internal/fourslash/tests/gen/commentsExternalModulesFourslash_test.go @@ -0,0 +1,299 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + . "github.com/microsoft/typescript-go/internal/fourslash/tests/util" + "github.com/microsoft/typescript-go/internal/lsp/lsproto" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestCommentsExternalModulesFourslash(t *testing.T) { + t.Parallel() + t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: commentsExternalModules_file0.ts +/** Namespace comment*/ +export namespace m/*1*/1 { + /** b's comment*/ + export var b: number; + /** foo's comment*/ + function foo() { + return /*2*/b; + } + /** m2 comments*/ + export namespace m2 { + /** class comment;*/ + export class c { + }; + /** i*/ + export var i = new c(); + } + /** exported function*/ + export function fooExport() { + return f/*3q*/oo(/*3*/); + } +} +/*4*/m1./*5*/fooEx/*6q*/port(/*6*/); +var my/*7*/var = new m1.m2./*8*/c(); +// @Filename: commentsExternalModules_file1.ts +/**This is on import declaration*/ +import ex/*9*/tMod = require("./commentsExternalModules_file0"); +/*10*/extMod./*11*/m1./*12*/fooExp/*13q*/ort(/*13*/); +var new/*14*/Var = new extMod.m1.m2./*15*/c();` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToFile(t, "commentsExternalModules_file0.ts") + f.VerifyQuickInfoAt(t, "1", "namespace m1", "Namespace comment") + f.VerifyCompletions(t, "2", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "b", + Detail: PtrTo("var b: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "b's comment", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "foo", + Detail: PtrTo("function foo(): number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "foo's comment", + }, + }, + }, + }, + }, + }) + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "foo's comment"}) + f.VerifyQuickInfoAt(t, "3q", "function foo(): number", "foo's comment") + f.VerifyCompletions(t, "4", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "m1", + Detail: PtrTo("namespace m1"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "Namespace comment", + }, + }, + }, + }, + }, + }) + f.VerifyCompletions(t, "5", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "b", + Detail: PtrTo("var m1.b: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "b's comment", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "fooExport", + Detail: PtrTo("function m1.fooExport(): number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "exported function", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "m2", + Detail: PtrTo("namespace m1.m2"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "m2 comments", + }, + }, + }, + }, + }, + }) + f.GoToMarker(t, "6") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "exported function"}) + f.VerifyQuickInfoAt(t, "6q", "function m1.fooExport(): number", "exported function") + f.VerifyQuickInfoAt(t, "7", "var myvar: m1.m2.c", "") + f.VerifyCompletions(t, "8", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "c", + Detail: PtrTo("constructor m1.m2.c(): m1.m2.c"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "class comment;", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i", + Detail: PtrTo("var m1.m2.i: m1.m2.c"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i", + }, + }, + }, + }, + }, + }) + f.GoToFile(t, "commentsExternalModules_file1.ts") + f.VerifyQuickInfoAt(t, "9", "import extMod = require(\"./commentsExternalModules_file0\")", "This is on import declaration") + f.VerifyCompletions(t, "10", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "extMod", + Detail: PtrTo("import extMod = require(\"./commentsExternalModules_file0\")"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "This is on import declaration", + }, + }, + }, + }, + }, + }) + f.VerifyCompletions(t, "11", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "m1", + Detail: PtrTo("namespace extMod.m1"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "Namespace comment", + }, + }, + }, + }, + }, + }) + f.VerifyCompletions(t, "12", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "b", + Detail: PtrTo("var extMod.m1.b: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "b's comment", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "fooExport", + Detail: PtrTo("function extMod.m1.fooExport(): number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "exported function", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "m2", + Detail: PtrTo("namespace extMod.m1.m2"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "m2 comments", + }, + }, + }, + }, + }, + }) + f.GoToMarker(t, "13") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "exported function"}) + f.VerifyQuickInfoAt(t, "13q", "function extMod.m1.fooExport(): number", "exported function") + f.VerifyQuickInfoAt(t, "14", "var newVar: extMod.m1.m2.c", "") + f.VerifyCompletions(t, "15", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Exact: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "c", + Detail: PtrTo("constructor extMod.m1.m2.c(): extMod.m1.m2.c"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "class comment;", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i", + Detail: PtrTo("var extMod.m1.m2.i: extMod.m1.m2.c"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i", + }, + }, + }, + }, + }, + }) +} diff --git a/internal/fourslash/tests/gen/commentsImportDeclaration_test.go b/internal/fourslash/tests/gen/commentsImportDeclaration_test.go new file mode 100644 index 0000000000..8ee8ed112f --- /dev/null +++ b/internal/fourslash/tests/gen/commentsImportDeclaration_test.go @@ -0,0 +1,138 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + . "github.com/microsoft/typescript-go/internal/fourslash/tests/util" + "github.com/microsoft/typescript-go/internal/lsp/lsproto" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestCommentsImportDeclaration(t *testing.T) { + t.Parallel() + t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: commentsImportDeclaration_file0.ts +/** NamespaceComment*/ +export namespace m/*2*/1 { + /** b's comment*/ + export var b: number; + /** m2 comments*/ + export namespace m2 { + /** class comment;*/ + export class c { + }; + /** i*/ + export var i: c;; + } + /** exported function*/ + export function fooExport(): number; +} +// @Filename: commentsImportDeclaration_file1.ts +/// +/** Import declaration*/ +import /*3*/extMod = require("./commentsImportDeclaration_file0/*4*/"); +extMod./*6*/m1./*7*/fooEx/*8q*/port(/*8*/); +var new/*9*/Var = new extMod.m1.m2./*10*/c();` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyQuickInfoAt(t, "2", "namespace m1", "NamespaceComment") + f.VerifyQuickInfoAt(t, "3", "import extMod = require(\"./commentsImportDeclaration_file0\")", "Import declaration") + f.VerifyCompletions(t, "6", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Exact: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "m1", + Detail: PtrTo("namespace extMod.m1"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "NamespaceComment", + }, + }, + }, + }, + }, + }) + f.VerifyCompletions(t, "7", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Exact: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "b", + Detail: PtrTo("var extMod.m1.b: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "b's comment", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "fooExport", + Detail: PtrTo("function extMod.m1.fooExport(): number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "exported function", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "m2", + Detail: PtrTo("namespace extMod.m1.m2"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "m2 comments", + }, + }, + }, + }, + }, + }) + f.GoToMarker(t, "8") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "exported function"}) + f.VerifyQuickInfoAt(t, "8q", "function extMod.m1.fooExport(): number", "exported function") + f.VerifyQuickInfoAt(t, "9", "var newVar: extMod.m1.m2.c", "") + f.VerifyCompletions(t, "10", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Exact: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "c", + Detail: PtrTo("constructor extMod.m1.m2.c(): extMod.m1.m2.c"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "class comment;", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i", + Detail: PtrTo("var extMod.m1.m2.i: extMod.m1.m2.c"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i", + }, + }, + }, + }, + }, + }) +} diff --git a/internal/fourslash/tests/gen/commentsInheritanceFourslash_test.go b/internal/fourslash/tests/gen/commentsInheritanceFourslash_test.go new file mode 100644 index 0000000000..6ae984b809 --- /dev/null +++ b/internal/fourslash/tests/gen/commentsInheritanceFourslash_test.go @@ -0,0 +1,1305 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + . "github.com/microsoft/typescript-go/internal/fourslash/tests/util" + "github.com/microsoft/typescript-go/internal/lsp/lsproto" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestCommentsInheritanceFourslash(t *testing.T) { + t.Parallel() + t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `/** i1 is interface with properties*/ +interface i1 { + /** i1_p1*/ + i1_p1: number; + /** i1_f1*/ + i1_f1(): void; + /** i1_l1*/ + i1_l1: () => void; + i1_nc_p1: number; + i1_nc_f1(): void; + i1_nc_l1: () => void; + p1: number; + f1(): void; + l1: () => void; + nc_p1: number; + nc_f1(): void; + nc_l1: () => void; +} +class c1 implements i1 { + public i1_p1: number; + public i1_f1() { + } + public i1_l1: () => void; + public i1_nc_p1: number; + public i1_nc_f1() { + } + public i1_nc_l1: () => void; + /** c1_p1*/ + public p1: number; + /** c1_f1*/ + public f1() { + } + /** c1_l1*/ + public l1: () => void; + /** c1_nc_p1*/ + public nc_p1: number; + /** c1_nc_f1*/ + public nc_f1() { + } + /** c1_nc_l1*/ + public nc_l1: () => void; +} +var i1/*1iq*/_i: /*16i*/i1; +i1_i./*1*/i/*2q*/1_f1(/*2*/); +i1_i.i1_n/*3q*/c_f1(/*3*/); +i1_i.f/*4q*/1(/*4*/); +i1_i.nc/*5q*/_f1(/*5*/); +i1_i.i1/*l2q*/_l1(/*l2*/); +i1_i.i1_/*l3q*/nc_l1(/*l3*/); +i1_i.l/*l4q*/1(/*l4*/); +i1_i.nc/*l5q*/_l1(/*l5*/); +var c1/*6iq*/_i = new c1(); +c1_i./*6*/i1/*7q*/_f1(/*7*/); +c1_i.i1_nc/*8q*/_f1(/*8*/); +c1_i.f/*9q*/1(/*9*/); +c1_i.nc/*10q*/_f1(/*10*/); +c1_i.i1/*l7q*/_l1(/*l7*/); +c1_i.i1_n/*l8q*/c_l1(/*l8*/); +c1_i.l/*l9q*/1(/*l9*/); +c1_i.nc/*l10q*/_l1(/*l10*/); +// assign to interface +i1_i = c1_i; +i1_i./*11*/i1/*12q*/_f1(/*12*/); +i1_i.i1_nc/*13q*/_f1(/*13*/); +i1_i.f/*14q*/1(/*14*/); +i1_i.nc/*15q*/_f1(/*15*/); +i1_i.i1/*l12q*/_l1(/*l12*/); +i1_i.i1/*l13q*/_nc_l1(/*l13*/); +i1_i.l/*l14q*/1(/*l14*/); +i1_i.nc/*l15q*/_l1(/*l15*/); +/*16*/ +class c2 { + /** c2 c2_p1*/ + public c2_p1: number; + /** c2 c2_f1*/ + public c2_f1() { + } + /** c2 c2_prop*/ + public get c2_prop() { + return 10; + } + public c2_nc_p1: number; + public c2_nc_f1() { + } + public get c2_nc_prop() { + return 10; + } + /** c2 p1*/ + public p1: number; + /** c2 f1*/ + public f1() { + } + /** c2 prop*/ + public get prop() { + return 10; + } + public nc_p1: number; + public nc_f1() { + } + public get nc_prop() { + return 10; + } + /** c2 constructor*/ + constr/*55*/uctor(a: number) { + this.c2_p1 = a; + } +} +class c3 extends c2 { + cons/*56*/tructor() { + su/*18sq*/per(10); + this.p1 = s/*18spropq*/uper./*18spropProp*/c2_p1; + } + /** c3 p1*/ + public p1: number; + /** c3 f1*/ + public f1() { + } + /** c3 prop*/ + public get prop() { + return 10; + } + public nc_p1: number; + public nc_f1() { + } + public get nc_prop() { + return 10; + } +} +var c/*17iq*/2_i = new c/*17q*/2(/*17*/10); +var c/*18iq*/3_i = new c/*18q*/3(/*18*/); +c2_i./*19*/c2/*20q*/_f1(/*20*/); +c2_i.c2_nc/*21q*/_f1(/*21*/); +c2_i.f/*22q*/1(/*22*/); +c2_i.nc/*23q*/_f1(/*23*/); +c3_i./*24*/c2/*25q*/_f1(/*25*/); +c3_i.c2_nc/*26q*/_f1(/*26*/); +c3_i.f/*27q*/1(/*27*/); +c3_i.nc/*28q*/_f1(/*28*/); +// assign +c2_i = c3_i; +c2_i./*29*/c2/*30q*/_f1(/*30*/); +c2_i.c2_nc_/*31q*/f1(/*31*/); +c2_i.f/*32q*/1(/*32*/); +c2_i.nc/*33q*/_f1(/*33*/); +class c4 extends c2 { +} +var c4/*34iq*/_i = new c/*34q*/4(/*34*/10); +/*35*/ +interface i2 { + /** i2_p1*/ + i2_p1: number; + /** i2_f1*/ + i2_f1(): void; + /** i2_l1*/ + i2_l1: () => void; + i2_nc_p1: number; + i2_nc_f1(): void; + i2_nc_l1: () => void; + /** i2 p1*/ + p1: number; + /** i2 f1*/ + f1(): void; + /** i2 l1*/ + l1: () => void; + nc_p1: number; + nc_f1(): void; + nc_l1: () => void; +} +interface i3 extends i2 { + /** i3 p1*/ + p1: number; + /** i3 f1*/ + f1(): void; + /** i3 l1*/ + l1: () => void; + nc_p1: number; + nc_f1(): void; + nc_l1: () => void; +} +var i2/*36iq*/_i: /*51i*/i2; +var i3/*37iq*/_i: i3; +i2_i./*36*/i2/*37q*/_f1(/*37*/); +i2_i.i2_n/*38q*/c_f1(/*38*/); +i2_i.f/*39q*/1(/*39*/); +i2_i.nc/*40q*/_f1(/*40*/); +i2_i.i2_/*l37q*/l1(/*l37*/); +i2_i.i2_nc/*l38q*/_l1(/*l38*/); +i2_i.l/*l39q*/1(/*l39*/); +i2_i.nc_/*l40q*/l1(/*l40*/); +i3_i./*41*/i2_/*42q*/f1(/*42*/); +i3_i.i2_nc/*43q*/_f1(/*43*/); +i3_i.f/*44q*/1(/*44*/); +i3_i.nc_/*45q*/f1(/*45*/); +i3_i.i2_/*l42q*/l1(/*l42*/); +i3_i.i2_nc/*l43q*/_l1(/*l43*/); +i3_i.l/*l44q*/1(/*l44*/); +i3_i.nc_/*l45q*/l1(/*l45*/); +// assign to interface +i2_i = i3_i; +i2_i./*46*/i2/*47q*/_f1(/*47*/); +i2_i.i2_nc_/*48q*/f1(/*48*/); +i2_i.f/*49q*/1(/*49*/); +i2_i.nc/*50q*/_f1(/*50*/); +i2_i.i2_/*l47q*/l1(/*l47*/); +i2_i.i2_nc/*l48q*/_l1(/*l48*/); +i2_i.l/*l49q*/1(/*l49*/); +i2_i.nc_/*l50q*/l1(/*l50*/); +/*51*/ +/**c5 class*/ +class c5 { + public b: number; +} +class c6 extends c5 { + public d; + const/*57*/ructor() { + /*52*/super(); + this.d = /*53*/super./*54*/b; + } +}` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyCompletions(t, []string{"1", "11"}, &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "i1_p1", + Detail: PtrTo("(property) i1.i1_p1: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i1_p1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i1_f1", + Detail: PtrTo("(method) i1.i1_f1(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i1_f1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i1_l1", + Detail: PtrTo("(property) i1.i1_l1: () => void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i1_l1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i1_nc_p1", + Detail: PtrTo("(property) i1.i1_nc_p1: number"), + }, + &lsproto.CompletionItem{ + Label: "i1_nc_f1", + Detail: PtrTo("(method) i1.i1_nc_f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "i1_nc_l1", + Detail: PtrTo("(property) i1.i1_nc_l1: () => void"), + }, + &lsproto.CompletionItem{ + Label: "p1", + Detail: PtrTo("(property) i1.p1: number"), + }, + &lsproto.CompletionItem{ + Label: "f1", + Detail: PtrTo("(method) i1.f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "l1", + Detail: PtrTo("(property) i1.l1: () => void"), + }, + &lsproto.CompletionItem{ + Label: "nc_p1", + Detail: PtrTo("(property) i1.nc_p1: number"), + }, + &lsproto.CompletionItem{ + Label: "nc_f1", + Detail: PtrTo("(method) i1.nc_f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "nc_l1", + Detail: PtrTo("(property) i1.nc_l1: () => void"), + }, + }, + }, + }) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "i1_f1"}) + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "4") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "5") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l4") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l5") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.VerifyQuickInfoAt(t, "1iq", "var i1_i: i1", "") + f.VerifyQuickInfoAt(t, "2q", "(method) i1.i1_f1(): void", "i1_f1") + f.VerifyQuickInfoAt(t, "3q", "(method) i1.i1_nc_f1(): void", "") + f.VerifyQuickInfoAt(t, "4q", "(method) i1.f1(): void", "") + f.VerifyQuickInfoAt(t, "5q", "(method) i1.nc_f1(): void", "") + f.VerifyQuickInfoAt(t, "l2q", "(property) i1.i1_l1: () => void", "i1_l1") + f.VerifyQuickInfoAt(t, "l3q", "(property) i1.i1_nc_l1: () => void", "") + f.VerifyQuickInfoAt(t, "l4q", "(property) i1.l1: () => void", "") + f.VerifyQuickInfoAt(t, "l5q", "(property) i1.nc_l1: () => void", "") + f.VerifyCompletions(t, "6", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "i1_p1", + Detail: PtrTo("(property) c1.i1_p1: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i1_p1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i1_f1", + Detail: PtrTo("(method) c1.i1_f1(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i1_f1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i1_l1", + Detail: PtrTo("(property) c1.i1_l1: () => void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i1_l1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i1_nc_p1", + Detail: PtrTo("(property) c1.i1_nc_p1: number"), + }, + &lsproto.CompletionItem{ + Label: "i1_nc_f1", + Detail: PtrTo("(method) c1.i1_nc_f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "i1_nc_l1", + Detail: PtrTo("(property) c1.i1_nc_l1: () => void"), + }, + &lsproto.CompletionItem{ + Label: "p1", + Detail: PtrTo("(property) c1.p1: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c1_p1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "f1", + Detail: PtrTo("(method) c1.f1(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c1_f1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "l1", + Detail: PtrTo("(property) c1.l1: () => void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c1_l1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "nc_p1", + Detail: PtrTo("(property) c1.nc_p1: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c1_nc_p1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "nc_f1", + Detail: PtrTo("(method) c1.nc_f1(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c1_nc_f1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "nc_l1", + Detail: PtrTo("(property) c1.nc_l1: () => void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c1_nc_l1", + }, + }, + }, + }, + }, + }) + f.GoToMarker(t, "7") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "i1_f1"}) + f.GoToMarker(t, "9") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c1_f1"}) + f.GoToMarker(t, "10") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c1_nc_f1"}) + f.GoToMarker(t, "l9") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c1_l1"}) + f.GoToMarker(t, "l10") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c1_nc_l1"}) + f.GoToMarker(t, "8") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l7") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l8") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.VerifyQuickInfoAt(t, "6iq", "var c1_i: c1", "") + f.VerifyQuickInfoAt(t, "7q", "(method) c1.i1_f1(): void", "i1_f1") + f.VerifyQuickInfoAt(t, "8q", "(method) c1.i1_nc_f1(): void", "") + f.VerifyQuickInfoAt(t, "9q", "(method) c1.f1(): void", "c1_f1") + f.VerifyQuickInfoAt(t, "10q", "(method) c1.nc_f1(): void", "c1_nc_f1") + f.VerifyQuickInfoAt(t, "l7q", "(property) c1.i1_l1: () => void", "i1_l1") + f.VerifyQuickInfoAt(t, "l8q", "(property) c1.i1_nc_l1: () => void", "") + f.VerifyQuickInfoAt(t, "l9q", "(property) c1.l1: () => void", "c1_l1") + f.VerifyQuickInfoAt(t, "l10q", "(property) c1.nc_l1: () => void", "c1_nc_l1") + f.VerifyCompletions(t, "11", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "i1_p1", + Detail: PtrTo("(property) i1.i1_p1: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i1_p1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i1_f1", + Detail: PtrTo("(method) i1.i1_f1(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i1_f1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i1_l1", + Detail: PtrTo("(property) i1.i1_l1: () => void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i1_l1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i1_nc_p1", + Detail: PtrTo("(property) i1.i1_nc_p1: number"), + }, + &lsproto.CompletionItem{ + Label: "i1_nc_f1", + Detail: PtrTo("(method) i1.i1_nc_f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "i1_nc_l1", + Detail: PtrTo("(property) i1.i1_nc_l1: () => void"), + }, + &lsproto.CompletionItem{ + Label: "p1", + Detail: PtrTo("(property) i1.p1: number"), + }, + &lsproto.CompletionItem{ + Label: "f1", + Detail: PtrTo("(method) i1.f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "l1", + Detail: PtrTo("(property) i1.l1: () => void"), + }, + &lsproto.CompletionItem{ + Label: "nc_p1", + Detail: PtrTo("(property) i1.nc_p1: number"), + }, + &lsproto.CompletionItem{ + Label: "nc_f1", + Detail: PtrTo("(method) i1.nc_f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "nc_l1", + Detail: PtrTo("(property) i1.nc_l1: () => void"), + }, + }, + }, + }) + f.GoToMarker(t, "12") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "i1_f1"}) + f.GoToMarker(t, "13") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "14") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "15") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l12") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l13") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l14") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l15") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.VerifyQuickInfoAt(t, "12q", "(method) i1.i1_f1(): void", "i1_f1") + f.VerifyQuickInfoAt(t, "13q", "(method) i1.i1_nc_f1(): void", "") + f.VerifyQuickInfoAt(t, "14q", "(method) i1.f1(): void", "") + f.VerifyQuickInfoAt(t, "15q", "(method) i1.nc_f1(): void", "") + f.VerifyQuickInfoAt(t, "l12q", "(property) i1.i1_l1: () => void", "i1_l1") + f.VerifyQuickInfoAt(t, "l13q", "(property) i1.i1_nc_l1: () => void", "") + f.VerifyQuickInfoAt(t, "l14q", "(property) i1.l1: () => void", "") + f.VerifyQuickInfoAt(t, "l15q", "(property) i1.nc_l1: () => void", "") + f.VerifyCompletions(t, "16", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "i1_i", + Detail: PtrTo("var i1_i: i1"), + }, + &lsproto.CompletionItem{ + Label: "c1", + Detail: PtrTo("class c1"), + }, + &lsproto.CompletionItem{ + Label: "c1_i", + Detail: PtrTo("var c1_i: c1"), + }, + }, + Excludes: []string{ + "i1", + }, + }, + }) + f.VerifyCompletions(t, "16i", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "i1", + Detail: PtrTo("interface i1"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i1 is interface with properties", + }, + }, + }, + }, + }, + }) + f.VerifyQuickInfoAt(t, "17iq", "var c2_i: c2", "") + f.VerifyQuickInfoAt(t, "18iq", "var c3_i: c3", "") + f.GoToMarker(t, "17") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c2 constructor"}) + f.GoToMarker(t, "18") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.VerifyQuickInfoAt(t, "18sq", "constructor c2(a: number): c2", "c2 constructor") + f.VerifyQuickInfoAt(t, "18spropq", "class c2", "") + f.VerifyQuickInfoAt(t, "18spropProp", "(property) c2.c2_p1: number", "c2 c2_p1") + f.VerifyQuickInfoAt(t, "17q", "constructor c2(a: number): c2", "c2 constructor") + f.VerifyQuickInfoAt(t, "18q", "constructor c3(): c3", "") + f.VerifyCompletions(t, []string{"19", "29"}, &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "c2_p1", + Detail: PtrTo("(property) c2.c2_p1: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c2 c2_p1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "c2_f1", + Detail: PtrTo("(method) c2.c2_f1(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c2 c2_f1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "c2_prop", + Detail: PtrTo("(property) c2.c2_prop: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c2 c2_prop", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "c2_nc_p1", + Detail: PtrTo("(property) c2.c2_nc_p1: number"), + }, + &lsproto.CompletionItem{ + Label: "c2_nc_f1", + Detail: PtrTo("(method) c2.c2_nc_f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "c2_nc_prop", + Detail: PtrTo("(property) c2.c2_nc_prop: number"), + }, + &lsproto.CompletionItem{ + Label: "p1", + Detail: PtrTo("(property) c2.p1: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c2 p1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "f1", + Detail: PtrTo("(method) c2.f1(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c2 f1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "prop", + Detail: PtrTo("(property) c2.prop: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c2 prop", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "nc_p1", + Detail: PtrTo("(property) c2.nc_p1: number"), + }, + &lsproto.CompletionItem{ + Label: "nc_f1", + Detail: PtrTo("(method) c2.nc_f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "nc_prop", + Detail: PtrTo("(property) c2.nc_prop: number"), + }, + }, + }, + }) + f.GoToMarker(t, "20") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c2 c2_f1"}) + f.GoToMarker(t, "22") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c2 f1"}) + f.GoToMarker(t, "21") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "23") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.VerifyQuickInfoAt(t, "20q", "(method) c2.c2_f1(): void", "c2 c2_f1") + f.VerifyQuickInfoAt(t, "21q", "(method) c2.c2_nc_f1(): void", "") + f.VerifyQuickInfoAt(t, "22q", "(method) c2.f1(): void", "c2 f1") + f.VerifyQuickInfoAt(t, "23q", "(method) c2.nc_f1(): void", "") + f.VerifyCompletions(t, "24", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "c2_p1", + Detail: PtrTo("(property) c2.c2_p1: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c2 c2_p1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "c2_f1", + Detail: PtrTo("(method) c2.c2_f1(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c2 c2_f1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "c2_prop", + Detail: PtrTo("(property) c2.c2_prop: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c2 c2_prop", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "c2_nc_p1", + Detail: PtrTo("(property) c2.c2_nc_p1: number"), + }, + &lsproto.CompletionItem{ + Label: "c2_nc_f1", + Detail: PtrTo("(method) c2.c2_nc_f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "c2_nc_prop", + Detail: PtrTo("(property) c2.c2_nc_prop: number"), + }, + &lsproto.CompletionItem{ + Label: "p1", + Detail: PtrTo("(property) c3.p1: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c3 p1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "f1", + Detail: PtrTo("(method) c3.f1(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c3 f1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "prop", + Detail: PtrTo("(property) c3.prop: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "c3 prop", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "nc_p1", + Detail: PtrTo("(property) c3.nc_p1: number"), + }, + &lsproto.CompletionItem{ + Label: "nc_f1", + Detail: PtrTo("(method) c3.nc_f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "nc_prop", + Detail: PtrTo("(property) c3.nc_prop: number"), + }, + }, + }, + }) + f.GoToMarker(t, "25") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c2 c2_f1"}) + f.GoToMarker(t, "27") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c3 f1"}) + f.GoToMarker(t, "26") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "28") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.VerifyQuickInfoAt(t, "25q", "(method) c2.c2_f1(): void", "c2 c2_f1") + f.VerifyQuickInfoAt(t, "26q", "(method) c2.c2_nc_f1(): void", "") + f.VerifyQuickInfoAt(t, "27q", "(method) c3.f1(): void", "c3 f1") + f.VerifyQuickInfoAt(t, "28q", "(method) c3.nc_f1(): void", "") + f.GoToMarker(t, "30") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c2 c2_f1"}) + f.GoToMarker(t, "32") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c2 f1"}) + f.GoToMarker(t, "31") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "33") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.VerifyQuickInfoAt(t, "30q", "(method) c2.c2_f1(): void", "c2 c2_f1") + f.VerifyQuickInfoAt(t, "31q", "(method) c2.c2_nc_f1(): void", "") + f.VerifyQuickInfoAt(t, "32q", "(method) c2.f1(): void", "c2 f1") + f.VerifyQuickInfoAt(t, "33q", "(method) c2.nc_f1(): void", "") + f.GoToMarker(t, "34") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c2 constructor"}) + f.VerifyQuickInfoAt(t, "34iq", "var c4_i: c4", "") + f.VerifyQuickInfoAt(t, "34q", "constructor c4(a: number): c4", "c2 constructor") + f.VerifyCompletions(t, "35", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "c2", + Detail: PtrTo("class c2"), + }, + &lsproto.CompletionItem{ + Label: "c2_i", + Detail: PtrTo("var c2_i: c2"), + }, + &lsproto.CompletionItem{ + Label: "c3", + Detail: PtrTo("class c3"), + }, + &lsproto.CompletionItem{ + Label: "c3_i", + Detail: PtrTo("var c3_i: c3"), + }, + &lsproto.CompletionItem{ + Label: "c4", + Detail: PtrTo("class c4"), + }, + &lsproto.CompletionItem{ + Label: "c4_i", + Detail: PtrTo("var c4_i: c4"), + }, + }, + }, + }) + f.VerifyCompletions(t, []string{"36", "46"}, &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "i2_p1", + Detail: PtrTo("(property) i2.i2_p1: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i2_p1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i2_f1", + Detail: PtrTo("(method) i2.i2_f1(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i2_f1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i2_l1", + Detail: PtrTo("(property) i2.i2_l1: () => void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i2_l1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i2_nc_p1", + Detail: PtrTo("(property) i2.i2_nc_p1: number"), + }, + &lsproto.CompletionItem{ + Label: "i2_nc_f1", + Detail: PtrTo("(method) i2.i2_nc_f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "i2_nc_l1", + Detail: PtrTo("(property) i2.i2_nc_l1: () => void"), + }, + &lsproto.CompletionItem{ + Label: "p1", + Detail: PtrTo("(property) i2.p1: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i2 p1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "f1", + Detail: PtrTo("(method) i2.f1(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i2 f1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "l1", + Detail: PtrTo("(property) i2.l1: () => void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i2 l1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "nc_p1", + Detail: PtrTo("(property) i2.nc_p1: number"), + }, + &lsproto.CompletionItem{ + Label: "nc_f1", + Detail: PtrTo("(method) i2.nc_f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "nc_l1", + Detail: PtrTo("(property) i2.nc_l1: () => void"), + }, + }, + }, + }) + f.GoToMarker(t, "37") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "i2_f1"}) + f.GoToMarker(t, "39") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "i2 f1"}) + f.GoToMarker(t, "38") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "40") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l37") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l37") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l39") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l40") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.VerifyQuickInfoAt(t, "36iq", "var i2_i: i2", "") + f.VerifyQuickInfoAt(t, "37iq", "var i3_i: i3", "") + f.VerifyQuickInfoAt(t, "37q", "(method) i2.i2_f1(): void", "i2_f1") + f.VerifyQuickInfoAt(t, "38q", "(method) i2.i2_nc_f1(): void", "") + f.VerifyQuickInfoAt(t, "39q", "(method) i2.f1(): void", "i2 f1") + f.VerifyQuickInfoAt(t, "40q", "(method) i2.nc_f1(): void", "") + f.VerifyQuickInfoAt(t, "l37q", "(property) i2.i2_l1: () => void", "i2_l1") + f.VerifyQuickInfoAt(t, "l38q", "(property) i2.i2_nc_l1: () => void", "") + f.VerifyQuickInfoAt(t, "l39q", "(property) i2.l1: () => void", "i2 l1") + f.VerifyQuickInfoAt(t, "l40q", "(property) i2.nc_l1: () => void", "") + f.VerifyCompletions(t, "41", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "i2_p1", + Detail: PtrTo("(property) i2.i2_p1: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i2_p1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i2_f1", + Detail: PtrTo("(method) i2.i2_f1(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i2_f1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i2_l1", + Detail: PtrTo("(property) i2.i2_l1: () => void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i2_l1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i2_nc_p1", + Detail: PtrTo("(property) i2.i2_nc_p1: number"), + }, + &lsproto.CompletionItem{ + Label: "i2_nc_f1", + Detail: PtrTo("(method) i2.i2_nc_f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "i2_nc_l1", + Detail: PtrTo("(property) i2.i2_nc_l1: () => void"), + }, + &lsproto.CompletionItem{ + Label: "p1", + Detail: PtrTo("(property) i3.p1: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i3 p1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "f1", + Detail: PtrTo("(method) i3.f1(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i3 f1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "l1", + Detail: PtrTo("(property) i3.l1: () => void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i3 l1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "nc_p1", + Detail: PtrTo("(property) i3.nc_p1: number"), + }, + &lsproto.CompletionItem{ + Label: "nc_f1", + Detail: PtrTo("(method) i3.nc_f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "nc_l1", + Detail: PtrTo("(property) i3.nc_l1: () => void"), + }, + }, + }, + }) + f.GoToMarker(t, "42") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "i2_f1"}) + f.GoToMarker(t, "44") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "i3 f1"}) + f.GoToMarker(t, "43") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "45") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l42") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l43") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l44") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l45") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.VerifyQuickInfoAt(t, "42q", "(method) i2.i2_f1(): void", "i2_f1") + f.VerifyQuickInfoAt(t, "43q", "(method) i2.i2_nc_f1(): void", "") + f.VerifyQuickInfoAt(t, "44q", "(method) i3.f1(): void", "i3 f1") + f.VerifyQuickInfoAt(t, "45q", "(method) i3.nc_f1(): void", "") + f.VerifyQuickInfoAt(t, "l42q", "(property) i2.i2_l1: () => void", "i2_l1") + f.VerifyQuickInfoAt(t, "l43q", "(property) i2.i2_nc_l1: () => void", "") + f.VerifyQuickInfoAt(t, "l44q", "(property) i3.l1: () => void", "i3 l1") + f.VerifyQuickInfoAt(t, "l45q", "(property) i3.nc_l1: () => void", "") + f.VerifyCompletions(t, "46", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "i2_p1", + Detail: PtrTo("(property) i2.i2_p1: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i2_p1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i2_f1", + Detail: PtrTo("(method) i2.i2_f1(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i2_f1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i2_l1", + Detail: PtrTo("(property) i2.i2_l1: () => void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i2_l1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i2_nc_p1", + Detail: PtrTo("(property) i2.i2_nc_p1: number"), + }, + &lsproto.CompletionItem{ + Label: "i2_nc_f1", + Detail: PtrTo("(method) i2.i2_nc_f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "i2_nc_l1", + Detail: PtrTo("(property) i2.i2_nc_l1: () => void"), + }, + &lsproto.CompletionItem{ + Label: "p1", + Detail: PtrTo("(property) i2.p1: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i2 p1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "f1", + Detail: PtrTo("(method) i2.f1(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i2 f1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "l1", + Detail: PtrTo("(property) i2.l1: () => void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i2 l1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "nc_p1", + Detail: PtrTo("(property) i2.nc_p1: number"), + }, + &lsproto.CompletionItem{ + Label: "nc_f1", + Detail: PtrTo("(method) i2.nc_f1(): void"), + }, + &lsproto.CompletionItem{ + Label: "nc_l1", + Detail: PtrTo("(property) i2.nc_l1: () => void"), + }, + }, + }, + }) + f.GoToMarker(t, "47") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "i2_f1"}) + f.GoToMarker(t, "49") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "i2 f1"}) + f.GoToMarker(t, "48") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l47") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l48") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l49") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.GoToMarker(t, "l50") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.VerifyQuickInfoAt(t, "47q", "(method) i2.i2_f1(): void", "i2_f1") + f.VerifyQuickInfoAt(t, "48q", "(method) i2.i2_nc_f1(): void", "") + f.VerifyQuickInfoAt(t, "49q", "(method) i2.f1(): void", "i2 f1") + f.VerifyQuickInfoAt(t, "50q", "(method) i2.nc_f1(): void", "") + f.VerifyQuickInfoAt(t, "l47q", "(property) i2.i2_l1: () => void", "i2_l1") + f.VerifyQuickInfoAt(t, "l48q", "(property) i2.i2_nc_l1: () => void", "") + f.VerifyQuickInfoAt(t, "l49q", "(property) i2.l1: () => void", "i2 l1") + f.VerifyQuickInfoAt(t, "l40q", "(property) i2.nc_l1: () => void", "") + f.VerifyCompletions(t, "51", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "i2_i", + Detail: PtrTo("var i2_i: i2"), + }, + &lsproto.CompletionItem{ + Label: "i3_i", + Detail: PtrTo("var i3_i: i3"), + }, + }, + Excludes: []string{ + "i2", + "i3", + }, + }, + }) + f.VerifyCompletions(t, "51i", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "i2", + Detail: PtrTo("interface i2"), + }, + &lsproto.CompletionItem{ + Label: "i3", + Detail: PtrTo("interface i3"), + }, + }, + }, + }) + f.VerifyQuickInfoAt(t, "52", "constructor c5(): c5", "c5 class") + f.VerifyQuickInfoAt(t, "53", "class c5", "c5 class") + f.VerifyQuickInfoAt(t, "54", "(property) c5.b: number", "") + f.VerifyQuickInfoAt(t, "55", "constructor c2(a: number): c2", "c2 constructor") + f.VerifyQuickInfoAt(t, "56", "constructor c3(): c3", "") + f.VerifyQuickInfoAt(t, "57", "constructor c6(): c6", "") +} diff --git a/internal/fourslash/tests/gen/commentsInterfaceFourslash_test.go b/internal/fourslash/tests/gen/commentsInterfaceFourslash_test.go new file mode 100644 index 0000000000..98e6b9dd65 --- /dev/null +++ b/internal/fourslash/tests/gen/commentsInterfaceFourslash_test.go @@ -0,0 +1,417 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + . "github.com/microsoft/typescript-go/internal/fourslash/tests/util" + "github.com/microsoft/typescript-go/internal/lsp/lsproto" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestCommentsInterfaceFourslash(t *testing.T) { + t.Parallel() + t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `/** this is interface 1*/ +interface i/*1*/1 { +} +var i1/*2*/_i: i1; +interface nc_/*3*/i1 { +} +var nc_/*4*/i1_i: nc_i1; +/** this is interface 2 with members*/ +interface i/*5*/2 { + /** this is x*/ + x: number; + /** this is foo*/ + foo: (/**param help*/b: number) => string; + /** this is indexer*/ + [/**string param*/i: string]: number; + /**new method*/ + new (/** param*/i: i1); + nc_x: number; + nc_foo: (b: number) => string; + [i: number]: number; + /** this is call signature*/ + (/**paramhelp a*/a: number,/**paramhelp b*/ b: number) : number; + /** this is fnfoo*/ + fnfoo(/**param help*/b: number): string; + nc_fnfoo(b: number): string; +} +var i2/*6*/_i: /*34i*/i2; +var i2_i/*7*/_x = i2_i./*8*/x; +var i2_i/*9*/_foo = i2_i.f/*10*/oo; +var i2_i_f/*11*/oo_r = i2_i.f/*12q*/oo(/*12*/30); +var i2_i_i2_/*13*/si = i2/*13q*/_i["hello"]; +var i2_i_i2/*14*/_ii = i2/*14q*/_i[30]; +var i2_/*15*/i_n = new i2/*16q*/_i(/*16*/i1_i); +var i2_i/*17*/_nc_x = i2_i.n/*18*/c_x; +var i2_i_/*19*/nc_foo = i2_i.n/*20*/c_foo; +var i2_i_nc_f/*21*/oo_r = i2_i.nc/*22q*/_foo(/*22*/30); +var i2/*23*/_i_r = i2/*24q*/_i(/*24*/10, /*25*/20); +var i2_i/*26*/_fnfoo = i2_i.fn/*27*/foo; +var i2_i_/*28*/fnfoo_r = i2_i.fn/*29q*/foo(/*29*/10); +var i2_i/*30*/_nc_fnfoo = i2_i.nc_fn/*31*/foo; +var i2_i_nc_/*32*/fnfoo_r = i2_i.nc/*33q*/_fnfoo(/*33*/10); +/*34*/ +interface i3 { + /** Comment i3 x*/ + x: number; + /** Function i3 f*/ + f(/**number parameter*/a: number): string; + /** i3 l*/ + l: (/**comment i3 l b*/b: number) => string; + nc_x: number; + nc_f(a: number): string; + nc_l: (b: number) => string; +} +var i3_i: i3; +i3_i = { + /*35*/f: /**own f*/ (/**i3_i a*/a: number) => "Hello" + /*36*/a, + l: this./*37*/f, + /** own x*/ + x: this.f(/*38*/10), + nc_x: this.l(/*39*/this.x), + nc_f: this.f, + nc_l: this.l +}; +/*40*/i/*40q*/3_i./*41*/f(/*42*/10); +i3_i./*43q*/l(/*43*/10); +i3_i.nc_/*44q*/f(/*44*/10); +i3_i.nc/*45q*/_l(/*45*/10);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyQuickInfoAt(t, "1", "interface i1", "this is interface 1") + f.VerifyQuickInfoAt(t, "2", "var i1_i: i1", "") + f.VerifyQuickInfoAt(t, "3", "interface nc_i1", "") + f.VerifyQuickInfoAt(t, "4", "var nc_i1_i: nc_i1", "") + f.VerifyQuickInfoAt(t, "5", "interface i2", "this is interface 2 with members") + f.VerifyQuickInfoAt(t, "6", "var i2_i: i2", "") + f.VerifyQuickInfoAt(t, "7", "var i2_i_x: number", "") + f.VerifyQuickInfoAt(t, "8", "(property) i2.x: number", "this is x") + f.VerifyCompletions(t, "8", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &[]string{}, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Exact: CompletionFunctionMembersWithPrototypePlus( + []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "x", + Detail: PtrTo("(property) i2.x: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "this is x", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "foo", + Detail: PtrTo("(property) i2.foo: (b: number) => string"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "this is foo", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "nc_x", + Detail: PtrTo("(property) i2.nc_x: number"), + }, + &lsproto.CompletionItem{ + Label: "nc_foo", + Detail: PtrTo("(property) i2.nc_foo: (b: number) => string"), + }, + &lsproto.CompletionItem{ + Label: "fnfoo", + Detail: PtrTo("(method) i2.fnfoo(b: number): string"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "this is fnfoo", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "nc_fnfoo", + Detail: PtrTo("(method) i2.nc_fnfoo(b: number): string"), + }, + }), + }, + }) + f.VerifyQuickInfoAt(t, "9", "var i2_i_foo: (b: number) => string", "") + f.VerifyQuickInfoAt(t, "10", "(property) i2.foo: (b: number) => string", "this is foo") + f.VerifyQuickInfoAt(t, "11", "var i2_i_foo_r: string", "") + f.GoToMarker(t, "12") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "", ParameterDocComment: "param help"}) + f.VerifyQuickInfoAt(t, "12q", "(property) i2.foo: (b: number) => string", "this is foo") + f.VerifyQuickInfoAt(t, "13", "var i2_i_i2_si: number", "") + f.VerifyQuickInfoAt(t, "13q", "var i2_i: i2", "") + f.VerifyQuickInfoAt(t, "14", "var i2_i_i2_ii: number", "") + f.VerifyQuickInfoAt(t, "14q", "var i2_i: i2", "") + f.VerifyQuickInfoAt(t, "15", "var i2_i_n: any", "") + f.GoToMarker(t, "16") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "new method", ParameterDocComment: "param"}) + f.VerifyQuickInfoAt(t, "16q", "var i2_i: i2\nnew (i: i1) => any", "new method") + f.VerifyQuickInfoAt(t, "17", "var i2_i_nc_x: number", "") + f.VerifyQuickInfoAt(t, "18", "(property) i2.nc_x: number", "") + f.VerifyQuickInfoAt(t, "19", "var i2_i_nc_foo: (b: number) => string", "") + f.VerifyQuickInfoAt(t, "20", "(property) i2.nc_foo: (b: number) => string", "") + f.VerifyQuickInfoAt(t, "21", "var i2_i_nc_foo_r: string", "") + f.GoToMarker(t, "22") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.VerifyQuickInfoAt(t, "22q", "(property) i2.nc_foo: (b: number) => string", "") + f.VerifyQuickInfoAt(t, "23", "var i2_i_r: number", "") + f.GoToMarker(t, "24") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "this is call signature", ParameterDocComment: "paramhelp a"}) + f.VerifyQuickInfoAt(t, "24q", "var i2_i: i2\n(a: number, b: number) => number", "this is call signature") + f.GoToMarker(t, "25") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "this is call signature", ParameterDocComment: "paramhelp b"}) + f.VerifyQuickInfoAt(t, "26", "var i2_i_fnfoo: (b: number) => string", "") + f.VerifyQuickInfoAt(t, "27", "(method) i2.fnfoo(b: number): string", "this is fnfoo") + f.VerifyQuickInfoAt(t, "28", "var i2_i_fnfoo_r: string", "") + f.GoToMarker(t, "29") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "this is fnfoo", ParameterDocComment: "param help"}) + f.VerifyQuickInfoAt(t, "29q", "(method) i2.fnfoo(b: number): string", "this is fnfoo") + f.VerifyQuickInfoAt(t, "30", "var i2_i_nc_fnfoo: (b: number) => string", "") + f.VerifyQuickInfoAt(t, "31", "(method) i2.nc_fnfoo(b: number): string", "") + f.VerifyQuickInfoAt(t, "32", "var i2_i_nc_fnfoo_r: string", "") + f.GoToMarker(t, "33") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.VerifyQuickInfoAt(t, "33q", "(method) i2.nc_fnfoo(b: number): string", "") + f.VerifyCompletions(t, "34", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "i1_i", + Detail: PtrTo("var i1_i: i1"), + }, + &lsproto.CompletionItem{ + Label: "nc_i1_i", + Detail: PtrTo("var nc_i1_i: nc_i1"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i2_i", + Detail: PtrTo("var i2_i: i2"), + }, + &lsproto.CompletionItem{ + Label: "i2_i_x", + Detail: PtrTo("var i2_i_x: number"), + }, + &lsproto.CompletionItem{ + Label: "i2_i_foo", + Detail: PtrTo("var i2_i_foo: (b: number) => string"), + }, + &lsproto.CompletionItem{ + Label: "i2_i_foo_r", + Detail: PtrTo("var i2_i_foo_r: string"), + }, + &lsproto.CompletionItem{ + Label: "i2_i_i2_si", + Detail: PtrTo("var i2_i_i2_si: number"), + }, + &lsproto.CompletionItem{ + Label: "i2_i_i2_ii", + Detail: PtrTo("var i2_i_i2_ii: number"), + }, + &lsproto.CompletionItem{ + Label: "i2_i_n", + Detail: PtrTo("var i2_i_n: any"), + }, + &lsproto.CompletionItem{ + Label: "i2_i_nc_x", + Detail: PtrTo("var i2_i_nc_x: number"), + }, + &lsproto.CompletionItem{ + Label: "i2_i_nc_foo", + Detail: PtrTo("var i2_i_nc_foo: (b: number) => string"), + }, + &lsproto.CompletionItem{ + Label: "i2_i_nc_foo_r", + Detail: PtrTo("var i2_i_nc_foo_r: string"), + }, + &lsproto.CompletionItem{ + Label: "i2_i_r", + Detail: PtrTo("var i2_i_r: number"), + }, + &lsproto.CompletionItem{ + Label: "i2_i_fnfoo", + Detail: PtrTo("var i2_i_fnfoo: (b: number) => string"), + }, + &lsproto.CompletionItem{ + Label: "i2_i_fnfoo_r", + Detail: PtrTo("var i2_i_fnfoo_r: string"), + }, + &lsproto.CompletionItem{ + Label: "i2_i_nc_fnfoo", + Detail: PtrTo("var i2_i_nc_fnfoo: (b: number) => string"), + }, + &lsproto.CompletionItem{ + Label: "i2_i_nc_fnfoo_r", + Detail: PtrTo("var i2_i_nc_fnfoo_r: string"), + }, + }, + Excludes: []string{ + "i1", + "nc_i1", + "i2", + }, + }, + }) + f.VerifyCompletions(t, "34i", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "i1", + Detail: PtrTo("interface i1"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "this is interface 1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "nc_i1", + Detail: PtrTo("interface nc_i1"), + }, + &lsproto.CompletionItem{ + Label: "i2", + Detail: PtrTo("interface i2"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "this is interface 2 with members", + }, + }, + }, + }, + }, + }) + f.VerifyCompletions(t, "36", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "a", + Detail: PtrTo("(parameter) a: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i3_i a", + }, + }, + }, + }, + }, + }) + f.VerifyQuickInfoAt(t, "40q", "var i3_i: i3", "") + f.VerifyCompletions(t, "40", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "i3_i", + Detail: PtrTo("var i3_i: i3"), + }, + }, + Excludes: []string{ + "i3", + }, + }, + }) + f.GoToMarker(t, "41") + f.VerifyQuickInfoIs(t, "(method) i3.f(a: number): string", "Function i3 f") + f.VerifyCompletions(t, "41", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Exact: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "f", + Detail: PtrTo("(method) i3.f(a: number): string"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "Function i3 f", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "l", + Detail: PtrTo("(property) i3.l: (b: number) => string"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "i3 l", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "nc_f", + Detail: PtrTo("(method) i3.nc_f(a: number): string"), + }, + &lsproto.CompletionItem{ + Label: "nc_l", + Detail: PtrTo("(property) i3.nc_l: (b: number) => string"), + }, + &lsproto.CompletionItem{ + Label: "nc_x", + Detail: PtrTo("(property) i3.nc_x: number"), + }, + &lsproto.CompletionItem{ + Label: "x", + Detail: PtrTo("(property) i3.x: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "Comment i3 x", + }, + }, + }, + }, + }, + }) + f.GoToMarker(t, "42") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "Function i3 f", ParameterDocComment: "number parameter"}) + f.GoToMarker(t, "43") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "", ParameterDocComment: "comment i3 l b"}) + f.VerifyQuickInfoAt(t, "43q", "(property) i3.l: (b: number) => string", "i3 l") + f.GoToMarker(t, "44") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.VerifyQuickInfoAt(t, "44q", "(method) i3.nc_f(a: number): string", "") + f.GoToMarker(t, "45") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: ""}) + f.VerifyQuickInfoAt(t, "45q", "(property) i3.nc_l: (b: number) => string", "") +} diff --git a/internal/fourslash/tests/gen/commentsOverloadsFourslash_test.go b/internal/fourslash/tests/gen/commentsOverloadsFourslash_test.go new file mode 100644 index 0000000000..7788139fb9 --- /dev/null +++ b/internal/fourslash/tests/gen/commentsOverloadsFourslash_test.go @@ -0,0 +1,723 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + . "github.com/microsoft/typescript-go/internal/fourslash/tests/util" + "github.com/microsoft/typescript-go/internal/lsp/lsproto" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestCommentsOverloadsFourslash(t *testing.T) { + t.Parallel() + t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `/** this is signature 1*/ +function /*1*/f1(/**param a*/a: number): number; +function /*2*/f1(b: string): number; +function /*3*/f1(aOrb: any) { + return 10; +} +f/*4q*/1(/*4*/"hello"); +f/*o4q*/1(/*o4*/10); +function /*5*/f2(/**param a*/a: number): number; +/** this is signature 2*/ +function /*6*/f2(b: string): number; +/** this is f2 var comment*/ +function /*7*/f2(aOrb: any) { + return 10; +} +f/*8q*/2(/*8*/"hello"); +f/*o8q*/2(/*o8*/10); +function /*9*/f3(a: number): number; +function /*10*/f3(b: string): number; +function /*11*/f3(aOrb: any) { + return 10; +} +f/*12q*/3(/*12*/"hello"); +f/*o12q*/3(/*o12*/10); +/** this is signature 4 - with number parameter*/ +function /*13*/f4(/**param a*/a: number): number; +/** this is signature 4 - with string parameter*/ +function /*14*/f4(b: string): number; +function /*15*/f4(aOrb: any) { + return 10; +} +f/*16q*/4(/*16*/"hello"); +f/*o16q*/4(/*o16*/10); +/*17*/ +interface i1 { + /**this signature 1*/ + (/**param a*/ a: number): number; + /**this is signature 2*/ + (b: string): number; + /** foo 1*/ + foo(a: number): number; + /** foo 2*/ + foo(b: string): number; + foo2(a: number): number; + /** foo2 2*/ + foo2(b: string): number; + foo3(a: number): number; + foo3(b: string): number; + /** foo4 1*/ + foo4(a: number): number; + foo4(b: string): number; + /** new 1*/ + new (a: string); + new (b: number); +} +var i1_i: i1; +interface i2 { + new (a: string); + /** new 2*/ + new (b: number); + (a: number): number; + /**this is signature 2*/ + (b: string): number; +} +var i2_i: i2; +interface i3 { + /** new 1*/ + new (a: string); + /** new 2*/ + new (b: number); + /**this is signature 1*/ + (a: number): number; + (b: string): number; +} +var i3_i: i3; +interface i4 { + new (a: string); + new (b: number); + (a: number): number; + (b: string): number; +} +var i4_i: i4; +new /*18*/i1/*19q*/_i(/*19*/10); +new i/*20q*/1_i(/*20*/"Hello"); +i/*21q*/1_i(/*21*/10); +i/*22q*/1_i(/*22*/"hello"); +i1_i./*23*/f/*24q*/oo(/*24*/10); +i1_i.f/*25q*/oo(/*25*/"hello"); +i1_i.fo/*26q*/o2(/*26*/10); +i1_i.fo/*27q*/o2(/*27*/"hello"); +i1_i.fo/*28q*/o3(/*28*/10); +i1_i.fo/*29q*/o3(/*29*/"hello"); +i1_i.fo/*30q*/o4(/*30*/10); +i1_i.fo/*31q*/o4(/*31*/"hello"); +new i2/*32q*/_i(/*32*/10); +new i2/*33q*/_i(/*33*/"Hello"); +i/*34q*/2_i(/*34*/10); +i2/*35q*/_i(/*35*/"hello"); +new i/*36q*/3_i(/*36*/10); +new i3/*37q*/_i(/*37*/"Hello"); +i3/*38q*/_i(/*38*/10); +i3/*39q*/_i(/*39*/"hello"); +new i4/*40q*/_i(/*40*/10); +new i/*41q*/4_i(/*41*/"Hello"); +i4/*42q*/_i(/*42*/10); +i4/*43q*/_i(/*43*/"hello"); +class c { + public /*93*/prop1(a: number): number; + public /*94*/prop1(b: string): number; + public /*95*/prop1(aorb: any) { + return 10; + } + /** prop2 1*/ + public /*96*/prop2(a: number): number; + public /*97*/prop2(b: string): number; + public /*98*/prop2(aorb: any) { + return 10; + } + public /*99*/prop3(a: number): number; + /** prop3 2*/ + public /*100*/prop3(b: string): number; + public /*101*/prop3(aorb: any) { + return 10; + } + /** prop4 1*/ + public /*102*/prop4(a: number): number; + /** prop4 2*/ + public /*103*/prop4(b: string): number; + public /*104*/prop4(aorb: any) { + return 10; + } + /** prop5 1*/ + public /*105*/prop5(a: number): number; + /** prop5 2*/ + public /*106*/prop5(b: string): number; + /** Prop5 implementaion*/ + public /*107*/prop5(aorb: any) { + return 10; + } +} +class c1 { + /*78*/constructor(a: number); + /*79*/constructor(b: string); + /*80*/constructor(aorb: any) { + } +} +class c2 { + /** c2 1*/ + /*81*/constructor(a: number); + /*82*/constructor(b: string); + /*83*/constructor(aorb: any) { + } +} +class c3 { + /*84*/constructor(a: number); + /** c3 2*/ + /*85*/constructor(b: string); + /*86*/constructor(aorb: any) { + } +} +class c4 { + /** c4 1*/ + /*87*/constructor(a: number); + /** c4 2*/ + /*88*/constructor(b: string); + /*89*/constructor(aorb: any) { + } +} +class c5 { + /** c5 1*/ + /*90*/constructor(a: number); + /** c5 2*/ + /*91*/constructor(b: string); + /** c5 implementation*/ + /*92*/constructor(aorb: any) { + } +} +var c_i = new c(); +c_i./*44*/pro/*45q*/p1(/*45*/10); +c_i.pr/*46q*/op1(/*46*/"hello"); +c_i.pr/*47q*/op2(/*47*/10); +c_i.pr/*48q*/op2(/*48*/"hello"); +c_i.pro/*49q*/p3(/*49*/10); +c_i.pr/*50q*/op3(/*50*/"hello"); +c_i.pr/*51q*/op4(/*51*/10); +c_i.pr/*52q*/op4(/*52*/"hello"); +c_i.pr/*53q*/op5(/*53*/10); +c_i.pr/*54q*/op5(/*54*/"hello"); +var c1/*66*/_i_1 = new c/*55q*/1(/*55*/10); +var c1_i_2 = new c/*56q*/1(/*56*/"hello"); +var c2_i_1 = new c/*57q*/2(/*57*/10); +var c/*67*/2_i_2 = new c/*58q*/2(/*58*/"hello"); +var c3_i_1 = new c/*59q*/3(/*59*/10); +var c/*68*/3_i_2 = new c/*60q*/3(/*60*/"hello"); +var c4/*69*/_i_1 = new c/*61q*/4(/*61*/10); +var c4_i_2 = new c/*62q*/4(/*62*/"hello"); +var c/*70*/5_i_1 = new c/*63q*/5(/*63*/10); +var c5_i_2 = new c/*64q*/5(/*64*/"hello"); +/** This is multiOverload F1 1*/ +function multiOverload(a: number): string; +/** This is multiOverload F1 2*/ +function multiOverload(b: string): string; +/** This is multiOverload F1 3*/ +function multiOverload(c: boolean): string; +/** This is multiOverload Implementation */ +function multiOverload(d): string { + return "Hello"; +} +multiOverl/*71*/oad(10); +multiOverl/*72*/oad("hello"); +multiOverl/*73*/oad(true); +/** This is ambient F1 1*/ +declare function ambientF1(a: number): string; +/** This is ambient F1 2*/ +declare function ambientF1(b: string): string; +/** This is ambient F1 3*/ +declare function ambientF1(c: boolean): boolean; +/*65*/ +ambient/*74*/F1(10); +ambient/*75*/F1("hello"); +ambient/*76*/F1(true); +function foo(a/*77*/a: i3) { +} +foo(null);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyQuickInfoAt(t, "1", "function f1(a: number): number (+1 overload)", "this is signature 1") + f.VerifyQuickInfoAt(t, "2", "function f1(b: string): number (+1 overload)", "this is signature 1") + f.VerifyQuickInfoAt(t, "3", "function f1(a: number): number (+1 overload)", "this is signature 1") + f.VerifyQuickInfoAt(t, "4q", "function f1(b: string): number (+1 overload)", "this is signature 1") + f.VerifyQuickInfoAt(t, "o4q", "function f1(a: number): number (+1 overload)", "this is signature 1") + f.GoToMarker(t, "4") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.GoToMarker(t, "o4") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "this is signature 1", ParameterDocComment: "param a", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "5", "function f2(a: number): number (+1 overload)", "") + f.VerifyQuickInfoAt(t, "6", "function f2(b: string): number (+1 overload)", "this is signature 2") + f.VerifyQuickInfoAt(t, "7", "function f2(a: number): number (+1 overload)", "") + f.VerifyQuickInfoAt(t, "8q", "function f2(b: string): number (+1 overload)", "this is signature 2") + f.VerifyQuickInfoAt(t, "o8q", "function f2(a: number): number (+1 overload)", "") + f.GoToMarker(t, "8") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "this is signature 2", OverloadsCount: 2}) + f.GoToMarker(t, "o8") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterDocComment: "param a", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "9", "function f3(a: number): number (+1 overload)", "") + f.VerifyQuickInfoAt(t, "10", "function f3(b: string): number (+1 overload)", "") + f.VerifyQuickInfoAt(t, "11", "function f3(a: number): number (+1 overload)", "") + f.VerifyQuickInfoAt(t, "12q", "function f3(b: string): number (+1 overload)", "") + f.VerifyQuickInfoAt(t, "o12q", "function f3(a: number): number (+1 overload)", "") + f.GoToMarker(t, "12") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.GoToMarker(t, "o12") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "13", "function f4(a: number): number (+1 overload)", "this is signature 4 - with number parameter") + f.VerifyQuickInfoAt(t, "14", "function f4(b: string): number (+1 overload)", "this is signature 4 - with string parameter") + f.VerifyQuickInfoAt(t, "15", "function f4(a: number): number (+1 overload)", "this is signature 4 - with number parameter") + f.VerifyQuickInfoAt(t, "16q", "function f4(b: string): number (+1 overload)", "this is signature 4 - with string parameter") + f.VerifyQuickInfoAt(t, "o16q", "function f4(a: number): number (+1 overload)", "this is signature 4 - with number parameter") + f.GoToMarker(t, "16") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "this is signature 4 - with string parameter", OverloadsCount: 2}) + f.GoToMarker(t, "o16") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "this is signature 4 - with number parameter", ParameterDocComment: "param a", OverloadsCount: 2}) + f.VerifyCompletions(t, "17", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "f1", + Detail: PtrTo("function f1(a: number): number (+1 overload)"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "this is signature 1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "f2", + Detail: PtrTo("function f2(a: number): number (+1 overload)"), + }, + &lsproto.CompletionItem{ + Label: "f3", + Detail: PtrTo("function f3(a: number): number (+1 overload)"), + }, + &lsproto.CompletionItem{ + Label: "f4", + Detail: PtrTo("function f4(a: number): number (+1 overload)"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "this is signature 4 - with number parameter", + }, + }, + }, + }, + }, + }) + f.VerifyCompletions(t, "18", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "i1_i", + Detail: PtrTo("var i1_i: i1\nnew (b: number) => any (+1 overload)"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "new 1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i2_i", + Detail: PtrTo("var i2_i: i2\nnew (a: string) => any (+1 overload)"), + }, + &lsproto.CompletionItem{ + Label: "i3_i", + Detail: PtrTo("var i3_i: i3\nnew (a: string) => any (+1 overload)"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "new 1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "i4_i", + Detail: PtrTo("var i4_i: i4\nnew (a: string) => any (+1 overload)"), + }, + }, + Excludes: []string{ + "i1", + "i2", + "i3", + "i4", + }, + }, + }) + f.GoToMarker(t, "19") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "19q", "var i1_i: i1\nnew (b: number) => any (+1 overload)", "new 1") + f.GoToMarker(t, "20") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "new 1", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "20q", "var i1_i: i1\nnew (a: string) => any (+1 overload)", "new 1") + f.GoToMarker(t, "21") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "this signature 1", ParameterDocComment: "param a", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "21q", "var i1_i: i1\n(a: number) => number (+1 overload)", "this signature 1") + f.GoToMarker(t, "22") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "this is signature 2", OverloadsCount: 2}) + f.GoToMarker(t, "22q") + f.VerifyQuickInfoAt(t, "22q", "var i1_i: i1\n(b: string) => number (+1 overload)", "this is signature 2") + f.VerifyCompletions(t, "23", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "foo", + Detail: PtrTo("(method) i1.foo(a: number): number (+1 overload)"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "foo 1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "foo2", + Detail: PtrTo("(method) i1.foo2(a: number): number (+1 overload)"), + }, + &lsproto.CompletionItem{ + Label: "foo3", + Detail: PtrTo("(method) i1.foo3(a: number): number (+1 overload)"), + }, + &lsproto.CompletionItem{ + Label: "foo4", + Detail: PtrTo("(method) i1.foo4(a: number): number (+1 overload)"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "foo4 1", + }, + }, + }, + }, + }, + }) + f.GoToMarker(t, "24") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "foo 1", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "24q", "(method) i1.foo(a: number): number (+1 overload)", "foo 1") + f.GoToMarker(t, "25") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "foo 2", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "25q", "(method) i1.foo(b: string): number (+1 overload)", "foo 2") + f.GoToMarker(t, "26") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "26q", "(method) i1.foo2(a: number): number (+1 overload)", "") + f.GoToMarker(t, "27") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "foo2 2", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "27q", "(method) i1.foo2(b: string): number (+1 overload)", "foo2 2") + f.GoToMarker(t, "28") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "28q", "(method) i1.foo3(a: number): number (+1 overload)", "") + f.GoToMarker(t, "29") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "29q", "(method) i1.foo3(b: string): number (+1 overload)", "") + f.GoToMarker(t, "30") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "foo4 1", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "30q", "(method) i1.foo4(a: number): number (+1 overload)", "foo4 1") + f.GoToMarker(t, "31") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "31q", "(method) i1.foo4(b: string): number (+1 overload)", "foo4 1") + f.GoToMarker(t, "32") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "new 2", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "32q", "var i2_i: i2\nnew (b: number) => any (+1 overload)", "new 2") + f.GoToMarker(t, "33") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "33q", "var i2_i: i2\nnew (a: string) => any (+1 overload)", "") + f.GoToMarker(t, "34") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "34q", "var i2_i: i2\n(a: number) => number (+1 overload)", "") + f.GoToMarker(t, "35") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "this is signature 2", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "35q", "var i2_i: i2\n(b: string) => number (+1 overload)", "this is signature 2") + f.GoToMarker(t, "36") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "new 2", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "36q", "var i3_i: i3\nnew (b: number) => any (+1 overload)", "new 2") + f.GoToMarker(t, "37") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "new 1", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "37q", "var i3_i: i3\nnew (a: string) => any (+1 overload)", "new 1") + f.GoToMarker(t, "38") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "this is signature 1", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "38q", "var i3_i: i3\n(a: number) => number (+1 overload)", "this is signature 1") + f.GoToMarker(t, "39") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "39q", "var i3_i: i3\n(b: string) => number (+1 overload)", "this is signature 1") + f.GoToMarker(t, "40") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "40q", "var i4_i: i4\nnew (b: number) => any (+1 overload)", "") + f.GoToMarker(t, "41") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "41q", "var i4_i: i4\nnew (a: string) => any (+1 overload)", "") + f.GoToMarker(t, "42") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "42q", "var i4_i: i4\n(a: number) => number (+1 overload)", "") + f.GoToMarker(t, "43") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "43q", "var i4_i: i4\n(b: string) => number (+1 overload)", "") + f.VerifyCompletions(t, "44", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Exact: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "prop1", + Detail: PtrTo("(method) c.prop1(a: number): number (+1 overload)"), + }, + &lsproto.CompletionItem{ + Label: "prop2", + Detail: PtrTo("(method) c.prop2(a: number): number (+1 overload)"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "prop2 1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "prop3", + Detail: PtrTo("(method) c.prop3(a: number): number (+1 overload)"), + }, + &lsproto.CompletionItem{ + Label: "prop4", + Detail: PtrTo("(method) c.prop4(a: number): number (+1 overload)"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "prop4 1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "prop5", + Detail: PtrTo("(method) c.prop5(a: number): number (+1 overload)"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "prop5 1", + }, + }, + }, + }, + }, + }) + f.GoToMarker(t, "45") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "45q", "(method) c.prop1(a: number): number (+1 overload)", "") + f.GoToMarker(t, "46") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "46q", "(method) c.prop1(b: string): number (+1 overload)", "") + f.GoToMarker(t, "47") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "prop2 1", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "47q", "(method) c.prop2(a: number): number (+1 overload)", "prop2 1") + f.GoToMarker(t, "48") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "48q", "(method) c.prop2(b: string): number (+1 overload)", "prop2 1") + f.GoToMarker(t, "49") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "49q", "(method) c.prop3(a: number): number (+1 overload)", "") + f.GoToMarker(t, "50") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "prop3 2", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "50q", "(method) c.prop3(b: string): number (+1 overload)", "prop3 2") + f.GoToMarker(t, "51") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "prop4 1", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "51q", "(method) c.prop4(a: number): number (+1 overload)", "prop4 1") + f.GoToMarker(t, "52") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "prop4 2", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "52q", "(method) c.prop4(b: string): number (+1 overload)", "prop4 2") + f.GoToMarker(t, "53") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "prop5 1", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "53q", "(method) c.prop5(a: number): number (+1 overload)", "prop5 1") + f.GoToMarker(t, "54") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "prop5 2", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "54q", "(method) c.prop5(b: string): number (+1 overload)", "prop5 2") + f.GoToMarker(t, "55") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "55q", "constructor c1(a: number): c1 (+1 overload)", "") + f.GoToMarker(t, "56") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "56q", "constructor c1(b: string): c1 (+1 overload)", "") + f.GoToMarker(t, "57") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c2 1", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "57q", "constructor c2(a: number): c2 (+1 overload)", "c2 1") + f.GoToMarker(t, "58") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "58q", "constructor c2(b: string): c2 (+1 overload)", "c2 1") + f.GoToMarker(t, "59") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "59q", "constructor c3(a: number): c3 (+1 overload)", "") + f.GoToMarker(t, "60") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c3 2", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "60q", "constructor c3(b: string): c3 (+1 overload)", "c3 2") + f.GoToMarker(t, "61") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c4 1", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "61q", "constructor c4(a: number): c4 (+1 overload)", "c4 1") + f.GoToMarker(t, "62") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c4 2", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "62q", "constructor c4(b: string): c4 (+1 overload)", "c4 2") + f.GoToMarker(t, "63") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c5 1", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "63q", "constructor c5(a: number): c5 (+1 overload)", "c5 1") + f.GoToMarker(t, "64") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "c5 2", OverloadsCount: 2}) + f.VerifyQuickInfoAt(t, "64q", "constructor c5(b: string): c5 (+1 overload)", "c5 2") + f.VerifyCompletions(t, "65", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "c", + Detail: PtrTo("class c"), + }, + &lsproto.CompletionItem{ + Label: "c1", + Detail: PtrTo("class c1"), + }, + &lsproto.CompletionItem{ + Label: "c2", + Detail: PtrTo("class c2"), + }, + &lsproto.CompletionItem{ + Label: "c3", + Detail: PtrTo("class c3"), + }, + &lsproto.CompletionItem{ + Label: "c4", + Detail: PtrTo("class c4"), + }, + &lsproto.CompletionItem{ + Label: "c5", + Detail: PtrTo("class c5"), + }, + &lsproto.CompletionItem{ + Label: "c_i", + Detail: PtrTo("var c_i: c"), + }, + &lsproto.CompletionItem{ + Label: "c1_i_1", + Detail: PtrTo("var c1_i_1: c1"), + }, + &lsproto.CompletionItem{ + Label: "c2_i_1", + Detail: PtrTo("var c2_i_1: c2"), + }, + &lsproto.CompletionItem{ + Label: "c3_i_1", + Detail: PtrTo("var c3_i_1: c3"), + }, + &lsproto.CompletionItem{ + Label: "c4_i_1", + Detail: PtrTo("var c4_i_1: c4"), + }, + &lsproto.CompletionItem{ + Label: "c5_i_1", + Detail: PtrTo("var c5_i_1: c5"), + }, + &lsproto.CompletionItem{ + Label: "c1_i_2", + Detail: PtrTo("var c1_i_2: c1"), + }, + &lsproto.CompletionItem{ + Label: "c2_i_2", + Detail: PtrTo("var c2_i_2: c2"), + }, + &lsproto.CompletionItem{ + Label: "c3_i_2", + Detail: PtrTo("var c3_i_2: c3"), + }, + &lsproto.CompletionItem{ + Label: "c4_i_2", + Detail: PtrTo("var c4_i_2: c4"), + }, + &lsproto.CompletionItem{ + Label: "c5_i_2", + Detail: PtrTo("var c5_i_2: c5"), + }, + &lsproto.CompletionItem{ + Label: "multiOverload", + Detail: PtrTo("function multiOverload(a: number): string (+2 overloads)"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "This is multiOverload F1 1", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "ambientF1", + Detail: PtrTo("function ambientF1(a: number): string (+2 overloads)"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "This is ambient F1 1", + }, + }, + }, + }, + }, + }) + f.VerifyQuickInfoAt(t, "66", "var c1_i_1: c1", "") + f.VerifyQuickInfoAt(t, "67", "var c2_i_2: c2", "") + f.VerifyQuickInfoAt(t, "68", "var c3_i_2: c3", "") + f.VerifyQuickInfoAt(t, "69", "var c4_i_1: c4", "") + f.VerifyQuickInfoAt(t, "70", "var c5_i_1: c5", "") + f.VerifyQuickInfoAt(t, "71", "function multiOverload(a: number): string (+2 overloads)", "This is multiOverload F1 1") + f.VerifyQuickInfoAt(t, "72", "function multiOverload(b: string): string (+2 overloads)", "This is multiOverload F1 2") + f.VerifyQuickInfoAt(t, "73", "function multiOverload(c: boolean): string (+2 overloads)", "This is multiOverload F1 3") + f.VerifyQuickInfoAt(t, "74", "function ambientF1(a: number): string (+2 overloads)", "This is ambient F1 1") + f.VerifyQuickInfoAt(t, "75", "function ambientF1(b: string): string (+2 overloads)", "This is ambient F1 2") + f.VerifyQuickInfoAt(t, "76", "function ambientF1(c: boolean): boolean (+2 overloads)", "This is ambient F1 3") + f.VerifyQuickInfoAt(t, "77", "(parameter) aa: i3", "") + f.VerifyQuickInfoAt(t, "78", "constructor c1(a: number): c1 (+1 overload)", "") + f.VerifyQuickInfoAt(t, "79", "constructor c1(b: string): c1 (+1 overload)", "") + f.VerifyQuickInfoAt(t, "80", "constructor c1(a: number): c1 (+1 overload)", "") + f.VerifyQuickInfoAt(t, "81", "constructor c2(a: number): c2 (+1 overload)", "c2 1") + f.VerifyQuickInfoAt(t, "82", "constructor c2(b: string): c2 (+1 overload)", "c2 1") + f.VerifyQuickInfoAt(t, "83", "constructor c2(a: number): c2 (+1 overload)", "c2 1") + f.VerifyQuickInfoAt(t, "84", "constructor c3(a: number): c3 (+1 overload)", "") + f.VerifyQuickInfoAt(t, "85", "constructor c3(b: string): c3 (+1 overload)", "c3 2") + f.VerifyQuickInfoAt(t, "86", "constructor c3(a: number): c3 (+1 overload)", "") + f.VerifyQuickInfoAt(t, "87", "constructor c4(a: number): c4 (+1 overload)", "c4 1") + f.VerifyQuickInfoAt(t, "88", "constructor c4(b: string): c4 (+1 overload)", "c4 2") + f.VerifyQuickInfoAt(t, "89", "constructor c4(a: number): c4 (+1 overload)", "c4 1") + f.VerifyQuickInfoAt(t, "90", "constructor c5(a: number): c5 (+1 overload)", "c5 1") + f.VerifyQuickInfoAt(t, "91", "constructor c5(b: string): c5 (+1 overload)", "c5 2") + f.VerifyQuickInfoAt(t, "92", "constructor c5(a: number): c5 (+1 overload)", "c5 1") + f.VerifyQuickInfoAt(t, "93", "(method) c.prop1(a: number): number (+1 overload)", "") + f.VerifyQuickInfoAt(t, "94", "(method) c.prop1(b: string): number (+1 overload)", "") + f.VerifyQuickInfoAt(t, "95", "(method) c.prop1(a: number): number (+1 overload)", "") + f.VerifyQuickInfoAt(t, "96", "(method) c.prop2(a: number): number (+1 overload)", "prop2 1") + f.VerifyQuickInfoAt(t, "97", "(method) c.prop2(b: string): number (+1 overload)", "prop2 1") + f.VerifyQuickInfoAt(t, "98", "(method) c.prop2(a: number): number (+1 overload)", "prop2 1") + f.VerifyQuickInfoAt(t, "99", "(method) c.prop3(a: number): number (+1 overload)", "") + f.VerifyQuickInfoAt(t, "100", "(method) c.prop3(b: string): number (+1 overload)", "prop3 2") + f.VerifyQuickInfoAt(t, "101", "(method) c.prop3(a: number): number (+1 overload)", "") + f.VerifyQuickInfoAt(t, "102", "(method) c.prop4(a: number): number (+1 overload)", "prop4 1") + f.VerifyQuickInfoAt(t, "103", "(method) c.prop4(b: string): number (+1 overload)", "prop4 2") + f.VerifyQuickInfoAt(t, "104", "(method) c.prop4(a: number): number (+1 overload)", "prop4 1") + f.VerifyQuickInfoAt(t, "105", "(method) c.prop5(a: number): number (+1 overload)", "prop5 1") + f.VerifyQuickInfoAt(t, "106", "(method) c.prop5(b: string): number (+1 overload)", "prop5 2") + f.VerifyQuickInfoAt(t, "107", "(method) c.prop5(a: number): number (+1 overload)", "prop5 1") +} diff --git a/internal/fourslash/tests/gen/commentsVariables_test.go b/internal/fourslash/tests/gen/commentsVariables_test.go new file mode 100644 index 0000000000..5720736e1c --- /dev/null +++ b/internal/fourslash/tests/gen/commentsVariables_test.go @@ -0,0 +1,231 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + . "github.com/microsoft/typescript-go/internal/fourslash/tests/util" + "github.com/microsoft/typescript-go/internal/lsp/lsproto" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestCommentsVariables(t *testing.T) { + t.Parallel() + t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `/** This is my variable*/ +var myV/*1*/ariable = 10; +/*2*/ +/** d variable*/ +var d = 10; +myVariable = d; +/*3*/ +/** foos comment*/ +function foo() { +} +/** fooVar comment*/ +var foo/*12*/Var: () => void; +/*4*/ +f/*5q*/oo(/*5*/); +fo/*6q*/oVar(/*6*/); +fo/*13*/oVar = f/*14*/oo; +/*7*/ +f/*8q*/oo(/*8*/); +foo/*9q*/Var(/*9*/); +var fooVarVar = /*9aq*/fooVar; +/**class comment*/ +class c { + /** constructor comment*/ + constructor() { + } +} +/**instance comment*/ +var i = new c(); +/*10*/ +/** interface comments*/ +interface i1 { +} +/**interface instance comments*/ +var i1_i: i1; +/*11*/ +function foo2(a: number): void; +function foo2(b: string): void; +function foo2(aOrb) { +} +var x = fo/*15*/o2;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyQuickInfoAt(t, "1", "var myVariable: number", "This is my variable") + f.VerifyCompletions(t, "2", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "myVariable", + Detail: PtrTo("var myVariable: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "This is my variable", + }, + }, + }, + }, + }, + }) + f.VerifyCompletions(t, "3", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "myVariable", + Detail: PtrTo("var myVariable: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "This is my variable", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "d", + Detail: PtrTo("var d: number"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "d variable", + }, + }, + }, + }, + }, + }) + f.VerifyCompletions(t, "4", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "foo", + Detail: PtrTo("function foo(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "foos comment", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "fooVar", + Detail: PtrTo("var fooVar: () => void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "fooVar comment", + }, + }, + }, + }, + }, + }) + f.GoToMarker(t, "5") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "foos comment"}) + f.VerifyQuickInfoAt(t, "5q", "function foo(): void", "foos comment") + f.GoToMarker(t, "6") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "fooVar comment"}) + f.VerifyQuickInfoAt(t, "6q", "var fooVar: () => void", "fooVar comment") + f.VerifyCompletions(t, "7", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "foo", + Detail: PtrTo("function foo(): void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "foos comment", + }, + }, + }, + &lsproto.CompletionItem{ + Label: "fooVar", + Detail: PtrTo("var fooVar: () => void"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "fooVar comment", + }, + }, + }, + }, + }, + }) + f.GoToMarker(t, "8") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "foos comment"}) + f.VerifyQuickInfoAt(t, "8q", "function foo(): void", "foos comment") + f.GoToMarker(t, "9") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "fooVar comment"}) + f.VerifyQuickInfoAt(t, "9q", "var fooVar: () => void", "fooVar comment") + f.VerifyQuickInfoAt(t, "9aq", "var fooVar: () => void", "fooVar comment") + f.VerifyCompletions(t, "10", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "i", + Detail: PtrTo("var i: c"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "instance comment", + }, + }, + }, + }, + }, + }) + f.VerifyCompletions(t, "11", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "i1_i", + Detail: PtrTo("var i1_i: i1"), + Documentation: &lsproto.StringOrMarkupContent{ + MarkupContent: &lsproto.MarkupContent{ + Kind: lsproto.MarkupKindMarkdown, + Value: "interface instance comments", + }, + }, + }, + }, + }, + }) + f.VerifyQuickInfoAt(t, "12", "var fooVar: () => void", "fooVar comment") + f.VerifyQuickInfoAt(t, "13", "var fooVar: () => void", "fooVar comment") + f.VerifyQuickInfoAt(t, "14", "function foo(): void", "foos comment") + f.VerifyQuickInfoAt(t, "15", "function foo2(a: number): void (+1 overload)", "") +} diff --git a/internal/fourslash/tests/gen/crossFileQuickInfoExportedTypeDoesNotUseImportType_test.go b/internal/fourslash/tests/gen/crossFileQuickInfoExportedTypeDoesNotUseImportType_test.go new file mode 100644 index 0000000000..b3396057da --- /dev/null +++ b/internal/fourslash/tests/gen/crossFileQuickInfoExportedTypeDoesNotUseImportType_test.go @@ -0,0 +1,29 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestCrossFileQuickInfoExportedTypeDoesNotUseImportType(t *testing.T) { + t.Parallel() + t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: b.ts +export interface B {} +export function foob(): { + x: B, + y: B +} { + return null as any; +} +// @Filename: a.ts +import { foob } from "./b"; +const thing/*1*/ = foob(/*2*/);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyQuickInfoAt(t, "1", "const thing: {\n x: B;\n y: B;\n}", "") + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foob(): { x: B; y: B; }"}) +} diff --git a/internal/fourslash/tests/gen/functionOverloadCount_test.go b/internal/fourslash/tests/gen/functionOverloadCount_test.go new file mode 100644 index 0000000000..7393730e7b --- /dev/null +++ b/internal/fourslash/tests/gen/functionOverloadCount_test.go @@ -0,0 +1,27 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestFunctionOverloadCount(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class C1 { + public attr(): string; + public attr(i: number): string; + public attr(i: number, x: boolean): string; + public attr(i?: any, x?: any) { + return "hi"; + } +} +var i = new C1; +i.attr(/*1*/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 3}) +} diff --git a/internal/fourslash/tests/gen/functionProperty_test.go b/internal/fourslash/tests/gen/functionProperty_test.go new file mode 100644 index 0000000000..1151c7daa6 --- /dev/null +++ b/internal/fourslash/tests/gen/functionProperty_test.go @@ -0,0 +1,76 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + . "github.com/microsoft/typescript-go/internal/fourslash/tests/util" + "github.com/microsoft/typescript-go/internal/lsp/lsproto" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestFunctionProperty(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `var a = { + x(a: number) { } +}; + +var b = { + x: function (a: number) { } +}; + +var c = { + x: (a: number) => { } +}; +a.x(/*signatureA*/1); +b.x(/*signatureB*/1); +c.x(/*signatureC*/1); +a./*completionA*/; +b./*completionB*/; +c./*completionC*/; +a./*quickInfoA*/x; +b./*quickInfoB*/x; +c./*quickInfoC*/x;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "signatureA") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "x(a: number): void"}) + f.GoToMarker(t, "signatureB") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "x(a: number): void"}) + f.GoToMarker(t, "signatureC") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "x(a: number): void"}) + f.VerifyCompletions(t, "completionA", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Exact: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "x", + Detail: PtrTo("(method) x(a: number): void"), + }, + }, + }, + }) + f.VerifyCompletions(t, []string{"completionB", "completionC"}, &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Exact: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "x", + Detail: PtrTo("(property) x: (a: number) => void"), + }, + }, + }, + }) + f.VerifyQuickInfoAt(t, "quickInfoA", "(method) x(a: number): void", "") + f.VerifyQuickInfoAt(t, "quickInfoB", "(property) x: (a: number) => void", "") + f.VerifyQuickInfoAt(t, "quickInfoC", "(property) x: (a: number) => void", "") +} diff --git a/internal/fourslash/tests/gen/genericFunctionReturnType2_test.go b/internal/fourslash/tests/gen/genericFunctionReturnType2_test.go new file mode 100644 index 0000000000..ef559c20e8 --- /dev/null +++ b/internal/fourslash/tests/gen/genericFunctionReturnType2_test.go @@ -0,0 +1,30 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestGenericFunctionReturnType2(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class C { + constructor(x: T) { } + foo(x: T) { + return (a: T) => x; + } +} +var x = new C(1); +var /*2*/r = x.foo(/*1*/3); +var /*4*/r2 = r(/*3*/4);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo(x: number): (a: number) => number"}) + f.VerifyQuickInfoAt(t, "2", "var r: (a: number) => number", "") + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "r(a: number): number"}) + f.VerifyQuickInfoAt(t, "4", "var r2: number", "") +} diff --git a/internal/fourslash/tests/gen/genericFunctionReturnType_test.go b/internal/fourslash/tests/gen/genericFunctionReturnType_test.go new file mode 100644 index 0000000000..6e16b2e2d9 --- /dev/null +++ b/internal/fourslash/tests/gen/genericFunctionReturnType_test.go @@ -0,0 +1,27 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestGenericFunctionReturnType(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function foo(x: T, y: U): (a: U) => T { + var z = y; + return (z) => x; +} +var /*2*/r = foo(/*1*/1, ""); +var /*4*/r2 = r(/*3*/"");` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo(x: number, y: string): (a: string) => number"}) + f.VerifyQuickInfoAt(t, "2", "var r: (a: string) => number", "") + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "r(a: string): number"}) + f.VerifyQuickInfoAt(t, "4", "var r2: number", "") +} diff --git a/internal/fourslash/tests/gen/genericFunctionSignatureHelp1_test.go b/internal/fourslash/tests/gen/genericFunctionSignatureHelp1_test.go new file mode 100644 index 0000000000..c10ee2c96e --- /dev/null +++ b/internal/fourslash/tests/gen/genericFunctionSignatureHelp1_test.go @@ -0,0 +1,19 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestGenericFunctionSignatureHelp1(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function f(a: T): T { return null; } +f(/**/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f(a: unknown): unknown"}) +} diff --git a/internal/fourslash/tests/gen/genericFunctionSignatureHelp2_test.go b/internal/fourslash/tests/gen/genericFunctionSignatureHelp2_test.go new file mode 100644 index 0000000000..d6d967e0d2 --- /dev/null +++ b/internal/fourslash/tests/gen/genericFunctionSignatureHelp2_test.go @@ -0,0 +1,19 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestGenericFunctionSignatureHelp2(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `var f = (a: T) => a; +f(/**/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f(a: unknown): unknown"}) +} diff --git a/internal/fourslash/tests/gen/genericFunctionSignatureHelp3MultiFile_test.go b/internal/fourslash/tests/gen/genericFunctionSignatureHelp3MultiFile_test.go new file mode 100644 index 0000000000..f200b766cb --- /dev/null +++ b/internal/fourslash/tests/gen/genericFunctionSignatureHelp3MultiFile_test.go @@ -0,0 +1,52 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestGenericFunctionSignatureHelp3MultiFile(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: genericFunctionSignatureHelp_0.ts +function foo1(x: number, callback: (y1: T) => number) { } +// @Filename: genericFunctionSignatureHelp_1.ts +function foo2(x: number, callback: (y2: T) => number) { } +// @Filename: genericFunctionSignatureHelp_2.ts +function foo3(x: number, callback: (y3: T) => number) { } +// @Filename: genericFunctionSignatureHelp_3.ts +function foo4(x: number, callback: (y4: T) => number) { } +// @Filename: genericFunctionSignatureHelp_4.ts +function foo5(x: number, callback: (y5: T) => number) { } +// @Filename: genericFunctionSignatureHelp_5.ts +function foo6(x: number, callback: (y6: T) => number) { } +// @Filename: genericFunctionSignatureHelp_6.ts +function foo7(x: number, callback: (y7: T) => number) { } +// @Filename: genericFunctionSignatureHelp_7.ts +foo1(/*1*/ // signature help shows y as T +foo2(1,/*2*/ // signature help shows y as {} +foo3(1, (/*3*/ // signature help shows y as T +foo4(1,/*4*/ // signature help shows y as string +foo5(1, (/*5*/ // signature help shows y as T +foo6(1, (/*7*/ // signature help shows y as T` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo1(x: number, callback: (y1: unknown) => number): void"}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo2(x: number, callback: (y2: unknown) => number): void"}) + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "callback(y3: unknown): number"}) + f.GoToMarker(t, "4") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo4(x: number, callback: (y4: string) => number): void"}) + f.GoToMarker(t, "5") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "callback(y5: string): number"}) + f.GoToMarker(t, "6") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo6(x: number, callback: (y6: unknown) => number): void"}) + f.Insert(t, "string>(null,null);") + f.GoToMarker(t, "7") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo7(x: number, callback: (y7: unknown) => number): void"}) +} diff --git a/internal/fourslash/tests/gen/genericFunctionSignatureHelp3_test.go b/internal/fourslash/tests/gen/genericFunctionSignatureHelp3_test.go new file mode 100644 index 0000000000..c444ff117b --- /dev/null +++ b/internal/fourslash/tests/gen/genericFunctionSignatureHelp3_test.go @@ -0,0 +1,45 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestGenericFunctionSignatureHelp3(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function foo1(x: number, callback: (y1: T) => number) { } +function foo2(x: number, callback: (y2: T) => number) { } +function foo3(x: number, callback: (y3: T) => number) { } +function foo4(x: number, callback: (y4: T) => number) { } +function foo5(x: number, callback: (y5: T) => number) { } +function foo6(x: number, callback: (y6: T) => number) { } +function foo7(x: number, callback: (y7: T) => number) { } + IDE shows the results on the right of each line, fourslash says different +foo1(/*1*/ // signature help shows y as T +foo2(1,/*2*/ // signature help shows y as {} +foo3(1, (/*3*/ // signature help shows y as T +foo4(1,/*4*/ // signature help shows y as string +foo5(1, (/*5*/ // signature help shows y as T +foo6(1, (/*7*/ // signature help shows y as T` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo1(x: number, callback: (y1: unknown) => number): void"}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo2(x: number, callback: (y2: unknown) => number): void"}) + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "callback(y3: unknown): number"}) + f.GoToMarker(t, "4") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo4(x: number, callback: (y4: string) => number): void"}) + f.GoToMarker(t, "5") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "callback(y5: string): number"}) + f.GoToMarker(t, "6") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo6(x: number, callback: (y6: unknown) => number): void"}) + f.Insert(t, "string>(null,null);") + f.GoToMarker(t, "7") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo7(x: number, callback: (y7: unknown) => number): void"}) +} diff --git a/internal/fourslash/tests/gen/genericParameterHelpConstructorCalls_test.go b/internal/fourslash/tests/gen/genericParameterHelpConstructorCalls_test.go new file mode 100644 index 0000000000..21ec562487 --- /dev/null +++ b/internal/fourslash/tests/gen/genericParameterHelpConstructorCalls_test.go @@ -0,0 +1,37 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestGenericParameterHelpConstructorCalls(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `interface IFoo { } + +class testClass { + constructor(a:T, b:U, c:M){ } +} + +// Constructor calls +new testClass(null, null, null) +new testClass<,,/*constructor4*/>(null, null, null) +new testClass(null, null, null)` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "constructor1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "testClass(a: T, b: U, c: M): testClass", ParameterName: "T", ParameterSpan: "T extends IFoo"}) + f.GoToMarker(t, "constructor2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "U", ParameterSpan: "U"}) + f.GoToMarker(t, "constructor3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "T", ParameterSpan: "T extends IFoo"}) + f.GoToMarker(t, "constructor4") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "M", ParameterSpan: "M extends IFoo"}) + f.GoToMarker(t, "constructor5") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "U", ParameterSpan: "U"}) +} diff --git a/internal/fourslash/tests/gen/genericParameterHelpTypeReferences_test.go b/internal/fourslash/tests/gen/genericParameterHelpTypeReferences_test.go new file mode 100644 index 0000000000..38c4e064e7 --- /dev/null +++ b/internal/fourslash/tests/gen/genericParameterHelpTypeReferences_test.go @@ -0,0 +1,44 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestGenericParameterHelpTypeReferences(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `interface IFoo { } + +class testClass { + constructor(a:T, b:U, c:M){ } +} + +// Generic types +testClass extends testClass; + +interface I {} +let i: I; + +type Ty = T; +let t: Ty;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "type1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "testClass", ParameterName: "T", ParameterSpan: "T extends IFoo"}) + f.GoToMarker(t, "type2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "testClass", ParameterName: "T", ParameterSpan: "T extends IFoo"}) + f.GoToMarker(t, "type3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "testClass", ParameterName: "T", ParameterSpan: "T extends IFoo"}) + f.GoToMarker(t, "type4") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "M", ParameterSpan: "M extends IFoo"}) + f.GoToMarker(t, "interface") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "I", ParameterName: "T", ParameterSpan: "T"}) + f.GoToMarker(t, "typeAlias") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "Ty", ParameterName: "T", ParameterSpan: "T"}) +} diff --git a/internal/fourslash/tests/gen/genericParameterHelp_test.go b/internal/fourslash/tests/gen/genericParameterHelp_test.go new file mode 100644 index 0000000000..ef6233c17e --- /dev/null +++ b/internal/fourslash/tests/gen/genericParameterHelp_test.go @@ -0,0 +1,37 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestGenericParameterHelp(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `interface IFoo { } + +function testFunction(a: T, b: U, c: M): M { + return null; +} + +// Function calls +testFunction(/*3*/ +testFunction(null, null, null); +testFunction<, ,/*5*/>(null, null, null);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "testFunction(a: T, b: U, c: M): M", ParameterCount: 3, ParameterName: "T", ParameterSpan: "T extends IFoo"}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "U", ParameterSpan: "U"}) + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "a", ParameterSpan: "a: any"}) + f.GoToMarker(t, "4") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "M", ParameterSpan: "M extends IFoo"}) + f.GoToMarker(t, "5") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "M", ParameterSpan: "M extends IFoo"}) +} diff --git a/internal/fourslash/tests/gen/getJavaScriptCompletions16_test.go b/internal/fourslash/tests/gen/getJavaScriptCompletions16_test.go new file mode 100644 index 0000000000..589716950f --- /dev/null +++ b/internal/fourslash/tests/gen/getJavaScriptCompletions16_test.go @@ -0,0 +1,75 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + . "github.com/microsoft/typescript-go/internal/fourslash/tests/util" + "github.com/microsoft/typescript-go/internal/lsp/lsproto" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestGetJavaScriptCompletions16(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @allowNonTsExtensions: true +// @Filename: file.js +"use strict"; + +class Something { + + /** + * @param {number} a + */ + constructor(a, b) { + a/*body*/ + } + + /** + * @param {number} a + */ + method(a) { + a/*method*/ + } +} +let x = new Something(/*sig*/);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "body") + f.Insert(t, ".") + f.VerifyCompletions(t, nil, &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "toFixed", + Kind: PtrTo(lsproto.CompletionItemKindMethod), + }, + }, + }, + }) + f.Backspace(t, 1) + f.GoToMarker(t, "sig") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "Something(a: number, b: any): Something"}) + f.GoToMarker(t, "method") + f.Insert(t, ".") + f.VerifyCompletions(t, nil, &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + &lsproto.CompletionItem{ + Label: "toFixed", + Kind: PtrTo(lsproto.CompletionItemKindMethod), + }, + }, + }, + }) +} diff --git a/internal/fourslash/tests/gen/jsSignature-41059_test.go b/internal/fourslash/tests/gen/jsSignature-41059_test.go new file mode 100644 index 0000000000..36cfdbdfbc --- /dev/null +++ b/internal/fourslash/tests/gen/jsSignature-41059_test.go @@ -0,0 +1,21 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestJsSignature_41059(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @lib: esnext +// @allowNonTsExtensions: true +// @Filename: Foo.js +a.next(/**/);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "Generator.next(): IteratorResult", OverloadsCount: 2}) +} diff --git a/internal/fourslash/tests/gen/noSignatureHelpOnNewKeyword_test.go b/internal/fourslash/tests/gen/noSignatureHelpOnNewKeyword_test.go new file mode 100644 index 0000000000..521179cda4 --- /dev/null +++ b/internal/fourslash/tests/gen/noSignatureHelpOnNewKeyword_test.go @@ -0,0 +1,21 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestNoSignatureHelpOnNewKeyword(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class Foo { } +new/*1*/ Foo +new /*2*/Foo(/*3*/)` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyNoSignatureHelpForMarkers(t, "1", "2") + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "Foo(): Foo"}) +} diff --git a/internal/fourslash/tests/gen/overloadOnConstCallSignature_test.go b/internal/fourslash/tests/gen/overloadOnConstCallSignature_test.go new file mode 100644 index 0000000000..e79a5785b4 --- /dev/null +++ b/internal/fourslash/tests/gen/overloadOnConstCallSignature_test.go @@ -0,0 +1,26 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestOverloadOnConstCallSignature(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `var foo: { + (name: string): string; + (name: 'order'): string; + (name: 'content'): string; + (name: 'done'): string; +} +var /*2*/x = foo(/*1*/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo(name: \"order\"): string", OverloadsCount: 4}) + f.Insert(t, "\"hi\"") + f.VerifyQuickInfoAt(t, "2", "var x: string", "") +} diff --git a/internal/fourslash/tests/gen/qualifyModuleTypeNames_test.go b/internal/fourslash/tests/gen/qualifyModuleTypeNames_test.go new file mode 100644 index 0000000000..c26c2b8363 --- /dev/null +++ b/internal/fourslash/tests/gen/qualifyModuleTypeNames_test.go @@ -0,0 +1,20 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestQualifyModuleTypeNames(t *testing.T) { + t.Parallel() + t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `module m { export class c { } }; +function x(arg: m.c) { return arg; } +x(/**/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "x(arg: m.c): m.c"}) +} diff --git a/internal/fourslash/tests/gen/quickInfoCanBeTruncated_test.go b/internal/fourslash/tests/gen/quickInfoCanBeTruncated_test.go new file mode 100644 index 0000000000..8116b9a75b --- /dev/null +++ b/internal/fourslash/tests/gen/quickInfoCanBeTruncated_test.go @@ -0,0 +1,539 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestQuickInfoCanBeTruncated(t *testing.T) { + t.Parallel() + t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @noLib: true +interface Foo { + _0: 0; + _1: 1; + _2: 2; + _3: 3; + _4: 4; + _5: 5; + _6: 6; + _7: 7; + _8: 8; + _9: 9; + _10: 10; + _11: 11; + _12: 12; + _13: 13; + _14: 14; + _15: 15; + _16: 16; + _17: 17; + _18: 18; + _19: 19; + _20: 20; + _21: 21; + _22: 22; + _23: 23; + _24: 24; + _25: 25; + _26: 26; + _27: 27; + _28: 28; + _29: 29; + _30: 30; + _31: 31; + _32: 32; + _33: 33; + _34: 34; + _35: 35; + _36: 36; + _37: 37; + _38: 38; + _39: 39; + _40: 40; + _41: 41; + _42: 42; + _43: 43; + _44: 44; + _45: 45; + _46: 46; + _47: 47; + _48: 48; + _49: 49; + _50: 50; + _51: 51; + _52: 52; + _53: 53; + _54: 54; + _55: 55; + _56: 56; + _57: 57; + _58: 58; + _59: 59; + _60: 60; + _61: 61; + _62: 62; + _63: 63; + _64: 64; + _65: 65; + _66: 66; + _67: 67; + _68: 68; + _69: 69; + _70: 70; + _71: 71; + _72: 72; + _73: 73; + _74: 74; + _75: 75; + _76: 76; + _77: 77; + _78: 78; + _79: 79; + _80: 80; + _81: 81; + _82: 82; + _83: 83; + _84: 84; + _85: 85; + _86: 86; + _87: 87; + _88: 88; + _89: 89; + _90: 90; + _91: 91; + _92: 92; + _93: 93; + _94: 94; + _95: 95; + _96: 96; + _97: 97; + _98: 98; + _99: 99; + _100: 100; + _101: 101; + _102: 102; + _103: 103; + _104: 104; + _105: 105; + _106: 106; + _107: 107; + _108: 108; + _109: 109; + _110: 110; + _111: 111; + _112: 112; + _113: 113; + _114: 114; + _115: 115; + _116: 116; + _117: 117; + _118: 118; + _119: 119; + _120: 120; + _121: 121; + _122: 122; + _123: 123; + _124: 124; + _125: 125; + _126: 126; + _127: 127; + _128: 128; + _129: 129; + _130: 130; + _131: 131; + _132: 132; + _133: 133; + _134: 134; + _135: 135; + _136: 136; + _137: 137; + _138: 138; + _139: 139; + _140: 140; + _141: 141; + _142: 142; + _143: 143; + _144: 144; + _145: 145; + _146: 146; + _147: 147; + _148: 148; + _149: 149; + _150: 150; + _151: 151; + _152: 152; + _153: 153; + _154: 154; + _155: 155; + _156: 156; + _157: 157; + _158: 158; + _159: 159; + _160: 160; + _161: 161; + _162: 162; + _163: 163; + _164: 164; + _165: 165; + _166: 166; + _167: 167; + _168: 168; + _169: 169; + _170: 170; + _171: 171; + _172: 172; + _173: 173; + _174: 174; + _175: 175; + _176: 176; + _177: 177; + _178: 178; + _179: 179; + _180: 180; + _181: 181; + _182: 182; + _183: 183; + _184: 184; + _185: 185; + _186: 186; + _187: 187; + _188: 188; + _189: 189; + _190: 190; + _191: 191; + _192: 192; + _193: 193; + _194: 194; + _195: 195; + _196: 196; + _197: 197; + _198: 198; + _199: 199; + _200: 200; + _201: 201; + _202: 202; + _203: 203; + _204: 204; + _205: 205; + _206: 206; + _207: 207; + _208: 208; + _209: 209; + _210: 210; + _211: 211; + _212: 212; + _213: 213; + _214: 214; + _215: 215; + _216: 216; + _217: 217; + _218: 218; + _219: 219; + _220: 220; + _221: 221; + _222: 222; + _223: 223; + _224: 224; + _225: 225; + _226: 226; + _227: 227; + _228: 228; + _229: 229; + _230: 230; + _231: 231; + _232: 232; + _233: 233; + _234: 234; + _235: 235; + _236: 236; + _237: 237; + _238: 238; + _239: 239; + _240: 240; + _241: 241; + _242: 242; + _243: 243; + _244: 244; + _245: 245; + _246: 246; + _247: 247; + _248: 248; + _249: 249; + _250: 250; + _251: 251; + _252: 252; + _253: 253; + _254: 254; + _255: 255; + _256: 256; + _257: 257; + _258: 258; + _259: 259; + _260: 260; + _261: 261; + _262: 262; + _263: 263; + _264: 264; + _265: 265; + _266: 266; + _267: 267; + _268: 268; + _269: 269; + _270: 270; + _271: 271; + _272: 272; + _273: 273; + _274: 274; + _275: 275; + _276: 276; + _277: 277; + _278: 278; + _279: 279; + _280: 280; + _281: 281; + _282: 282; + _283: 283; + _284: 284; + _285: 285; + _286: 286; + _287: 287; + _288: 288; + _289: 289; + _290: 290; + _291: 291; + _292: 292; + _293: 293; + _294: 294; + _295: 295; + _296: 296; + _297: 297; + _298: 298; + _299: 299; + _300: 300; + _301: 301; + _302: 302; + _303: 303; + _304: 304; + _305: 305; + _306: 306; + _307: 307; + _308: 308; + _309: 309; + _310: 310; + _311: 311; + _312: 312; + _313: 313; + _314: 314; + _315: 315; + _316: 316; + _317: 317; + _318: 318; + _319: 319; + _320: 320; + _321: 321; + _322: 322; + _323: 323; + _324: 324; + _325: 325; + _326: 326; + _327: 327; + _328: 328; + _329: 329; + _330: 330; + _331: 331; + _332: 332; + _333: 333; + _334: 334; + _335: 335; + _336: 336; + _337: 337; + _338: 338; + _339: 339; + _340: 340; + _341: 341; + _342: 342; + _343: 343; + _344: 344; + _345: 345; + _346: 346; + _347: 347; + _348: 348; + _349: 349; + _350: 350; + _351: 351; + _352: 352; + _353: 353; + _354: 354; + _355: 355; + _356: 356; + _357: 357; + _358: 358; + _359: 359; + _360: 360; + _361: 361; + _362: 362; + _363: 363; + _364: 364; + _365: 365; + _366: 366; + _367: 367; + _368: 368; + _369: 369; + _370: 370; + _371: 371; + _372: 372; + _373: 373; + _374: 374; + _375: 375; + _376: 376; + _377: 377; + _378: 378; + _379: 379; + _380: 380; + _381: 381; + _382: 382; + _383: 383; + _384: 384; + _385: 385; + _386: 386; + _387: 387; + _388: 388; + _389: 389; + _390: 390; + _391: 391; + _392: 392; + _393: 393; + _394: 394; + _395: 395; + _396: 396; + _397: 397; + _398: 398; + _399: 399; + _400: 400; + _401: 401; + _402: 402; + _403: 403; + _404: 404; + _405: 405; + _406: 406; + _407: 407; + _408: 408; + _409: 409; + _410: 410; + _411: 411; + _412: 412; + _413: 413; + _414: 414; + _415: 415; + _416: 416; + _417: 417; + _418: 418; + _419: 419; + _420: 420; + _421: 421; + _422: 422; + _423: 423; + _424: 424; + _425: 425; + _426: 426; + _427: 427; + _428: 428; + _429: 429; + _430: 430; + _431: 431; + _432: 432; + _433: 433; + _434: 434; + _435: 435; + _436: 436; + _437: 437; + _438: 438; + _439: 439; + _440: 440; + _441: 441; + _442: 442; + _443: 443; + _444: 444; + _445: 445; + _446: 446; + _447: 447; + _448: 448; + _449: 449; + _450: 450; + _451: 451; + _452: 452; + _453: 453; + _454: 454; + _455: 455; + _456: 456; + _457: 457; + _458: 458; + _459: 459; + _460: 460; + _461: 461; + _462: 462; + _463: 463; + _464: 464; + _465: 465; + _466: 466; + _467: 467; + _468: 468; + _469: 469; + _470: 470; + _471: 471; + _472: 472; + _473: 473; + _474: 474; + _475: 475; + _476: 476; + _477: 477; + _478: 478; + _479: 479; + _480: 480; + _481: 481; + _482: 482; + _483: 483; + _484: 484; + _485: 485; + _486: 486; + _487: 487; + _488: 488; + _489: 489; + _490: 490; + _491: 491; + _492: 492; + _493: 493; + _494: 494; + _495: 495; + _496: 496; + _497: 497; + _498: 498; + _499: 499; +} +type A/*1*/ = keyof Foo; +type Exclude = T extends U ? never : T; +type Less/*2*/ = Exclude; +function f(s: T, x: Exclude, y: string) {} +f("_499", /*3*/); +type Decomposed/*4*/ = {[K in A]: Foo[K]} +type LongTuple/*5*/ = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17.18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70]; +type DeeplyMapped/*6*/ = {[K in keyof Foo]: {[K2 in keyof Foo]: [K, K2, Foo[K], Foo[K2]]}}` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifyQuickInfoIs(t, "type A = keyof Foo", "") + f.GoToMarker(t, "2") + f.VerifyQuickInfoIs(t, "type Less = \"_1\" | \"_10\" | \"_100\" | \"_101\" | \"_102\" | \"_103\" | \"_104\" | \"_105\" | \"_106\" | \"_107\" | \"_108\" | \"_109\" | \"_11\" | \"_110\" | \"_111\" | \"_112\" | \"_113\" | \"_114\" | \"_115\" | \"_116\" | \"_117\" | \"_118\" | \"_119\" | \"_12\" | \"_120\" | \"_121\" | \"_122\" | \"_123\" | \"_124\" | \"_125\" | \"_126\" | \"_127\" | \"_128\" | \"_129\" | \"_13\" | \"_130\" | \"_131\" | \"_132\" | \"_133\" | \"_134\" | \"_135\" | \"_136\" | \"_137\" | \"_138\" | \"_139\" | \"_14\" | \"_140\" | \"_141\" | \"_142\" | \"_143\" | \"_144\" | \"_145\" | \"_146\" | \"_147\" | \"_148\" | \"_149\" | \"_15\" | \"_150\" | \"_151\" | \"_152\" | \"_153\" | \"_154\" | \"_155\" | \"_156\" | ... 434 more ... | \"_99\"", "") + f.GoToMarker(t, "3") + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f(s: \"_499\", x: \"_0\" | \"_1\" | \"_10\" | \"_100\" | \"_101\" | \"_102\" | \"_103\" | \"_104\" | \"_105\" | \"_106\" | \"_107\" | \"_108\" | \"_109\" | \"_11\" | \"_110\" | \"_111\" | \"_112\" | \"_113\" | \"_114\" | \"_115\" | \"_116\" | ... 477 more ... | \"_99\", y: string): void"}) + f.GoToMarker(t, "4") + f.VerifyQuickInfoIs(t, "type Decomposed = {\n _0: 0;\n _1: 1;\n _10: 10;\n _100: 100;\n _101: 101;\n _102: 102;\n _103: 103;\n _104: 104;\n _105: 105;\n _106: 106;\n _107: 107;\n _108: 108;\n _109: 109;\n _11: 11;\n _110: 110;\n _111: 111;\n _112: 112;\n _113: 113;\n _114: 114;\n _115: 115;\n _116: 116;\n _117: 117;\n _118: 118;\n _119: 119;\n _12: 12;\n _120: 120;\n _121: 121;\n _122: 122;\n _123: 123;\n _124: 124;\n _125: 125;\n _126: 126;\n _127: 127;\n _128: 128;\n _129: 129;\n _13: 13;\n _130: 130;\n _131: 131;\n _132: 132;\n _133: 133;\n _134: 134;\n _135: 135;\n _136: 136;\n _137: 137;\n _138: 138;\n _139: 139;\n _14: 14;\n _140: 140;\n _141: 141;\n _142: 142;\n _143: 143;\n _144: 144;\n _145: 145;\n _146: 146;\n _147: 147;\n _148: 148;\n _149: 149;\n _15: 15;\n _150: 150;\n _151: 151;\n _152: 152;\n _153: 153;\n _154: 154;\n _155: 155;\n _156: 156;\n _157: 157;\n ... 433 more ...;\n _99: 99;\n}", "") + f.GoToMarker(t, "5") + f.VerifyQuickInfoIs(t, "type LongTuple = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17.18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70]", "") + f.GoToMarker(t, "6") + f.VerifyQuickInfoIs(t, "type DeeplyMapped = {\n _0: {\n _0: [\"_0\", \"_0\", 0, 0];\n _1: [\"_0\", \"_1\", 0, 1];\n _2: [\"_0\", \"_2\", 0, 2];\n _3: [\"_0\", \"_3\", 0, 3];\n _4: [\"_0\", \"_4\", 0, 4];\n _5: [\"_0\", \"_5\", 0, 5];\n _6: [\"_0\", \"_6\", 0, 6];\n _7: [\"_0\", \"_7\", 0, 7];\n _8: [\"_0\", \"_8\", 0, 8];\n _9: [\"_0\", \"_9\", 0, 9];\n _10: [\"_0\", \"_10\", 0, 10];\n _11: [\"_0\", \"_11\", 0, 11];\n _12: [\"_0\", \"_12\", 0, 12];\n _13: [\"_0\", \"_13\", 0, 13];\n _14: [\"_0\", \"_14\", 0, 14];\n _15: [\"_0\", \"_15\", 0, 15];\n _16: [\"_0\", \"_16\", 0, 16];\n _17: [\"_0\", \"_17\", 0, 17];\n _18: [\"_0\", \"_18\", 0, 18];\n _19: [\"_0\", \"_19\", 0, 19];\n _20: [\"_0\", \"_20\", 0, 20];\n _21: [\"_0\", \"_21\", 0, 21];\n ... 477 more ...;\n _499: [...];\n };\n ... 498 more ...;\n _499: {\n ...;\n };\n}", "") +} diff --git a/internal/fourslash/tests/gen/quickInfoInFunctionTypeReference2_test.go b/internal/fourslash/tests/gen/quickInfoInFunctionTypeReference2_test.go new file mode 100644 index 0000000000..5bdbed9ab2 --- /dev/null +++ b/internal/fourslash/tests/gen/quickInfoInFunctionTypeReference2_test.go @@ -0,0 +1,25 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestQuickInfoInFunctionTypeReference2(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class C { + map(fn: (/*1*/k: string, /*2*/value: T, context: any) => void, context: any) { + } +} +var c: C; +c.map(/*3*/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyQuickInfoAt(t, "1", "(parameter) k: string", "") + f.VerifyQuickInfoAt(t, "2", "(parameter) value: T", "") + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "map(fn: (k: string, value: number, context: any) => void, context: any): void"}) +} diff --git a/internal/fourslash/tests/gen/quickInfoOnConstructorWithGenericParameter_test.go b/internal/fourslash/tests/gen/quickInfoOnConstructorWithGenericParameter_test.go new file mode 100644 index 0000000000..4cedc7f35a --- /dev/null +++ b/internal/fourslash/tests/gen/quickInfoOnConstructorWithGenericParameter_test.go @@ -0,0 +1,36 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestQuickInfoOnConstructorWithGenericParameter(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `interface I { + x: number; +} +class Foo { + y: T; +} +class A { + foo() { } +} +class B extends A { + constructor(a: Foo, b: number) { + super(); + } +} +var x = new /*2*/B(/*1*/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "B(a: Foo, b: number): B"}) + f.Insert(t, "null,") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "B(a: Foo, b: number): B"}) + f.Insert(t, "10);") + f.VerifyQuickInfoAt(t, "2", "constructor B(a: Foo, b: number): B", "") +} diff --git a/internal/fourslash/tests/gen/quickInfoOnPrivateConstructorCall_test.go b/internal/fourslash/tests/gen/quickInfoOnPrivateConstructorCall_test.go new file mode 100644 index 0000000000..69e2bcb699 --- /dev/null +++ b/internal/fourslash/tests/gen/quickInfoOnPrivateConstructorCall_test.go @@ -0,0 +1,20 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestQuickInfoOnPrivateConstructorCall(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class A { + private constructor() {} +} +var x = new A(/*1*/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyNoSignatureHelpForMarkers(t, "1") +} diff --git a/internal/fourslash/tests/gen/quickInfoOnProtectedConstructorCall_test.go b/internal/fourslash/tests/gen/quickInfoOnProtectedConstructorCall_test.go new file mode 100644 index 0000000000..d813af222b --- /dev/null +++ b/internal/fourslash/tests/gen/quickInfoOnProtectedConstructorCall_test.go @@ -0,0 +1,20 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestQuickInfoOnProtectedConstructorCall(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class A { + protected constructor() {} +} +var x = new A(/*1*/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyNoSignatureHelpForMarkers(t, "1") +} diff --git a/internal/fourslash/tests/gen/restArgSignatureHelp_test.go b/internal/fourslash/tests/gen/restArgSignatureHelp_test.go new file mode 100644 index 0000000000..e21c943bd8 --- /dev/null +++ b/internal/fourslash/tests/gen/restArgSignatureHelp_test.go @@ -0,0 +1,19 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestRestArgSignatureHelp(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function f(...x: any[]) { } +f(/**/);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "x", IsVariadic: true, IsVariadicSet: true}) +} diff --git a/internal/fourslash/tests/gen/signatureHelp01_test.go b/internal/fourslash/tests/gen/signatureHelp01_test.go new file mode 100644 index 0000000000..51a44dfc95 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelp01_test.go @@ -0,0 +1,24 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelp01(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function foo(data: number) { +} + +function bar { + foo(/*1*/) +}` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.MarkTestAsStradaServer() + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{DocComment: "", ParameterCount: 1}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpAnonymousFunction_test.go b/internal/fourslash/tests/gen/signatureHelpAnonymousFunction_test.go new file mode 100644 index 0000000000..07e9d233b2 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpAnonymousFunction_test.go @@ -0,0 +1,23 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpAnonymousFunction(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `var anonymousFunctionTest = function(n: number, s: string): (a: number, b: string) => string { + return null; +} +anonymousFunctionTest(5, "")(/*anonymousFunction1*/1, /*anonymousFunction2*/"");` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "anonymousFunction1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "(a: number, b: string): string", ParameterCount: 2, ParameterName: "a", ParameterSpan: "a: number"}) + f.GoToMarker(t, "anonymousFunction2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "b", ParameterSpan: "b: string"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpAtEOF2_test.go b/internal/fourslash/tests/gen/signatureHelpAtEOF2_test.go new file mode 100644 index 0000000000..cf028e144c --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpAtEOF2_test.go @@ -0,0 +1,19 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/lsp/lsproto" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpAtEOF2(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `console.log() +/**/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyNoSignatureHelpForMarkersWithContext(t, &lsproto.SignatureHelpContext{TriggerKind: lsproto.SignatureHelpTriggerKindInvoked}, "") +} diff --git a/internal/fourslash/tests/gen/signatureHelpAtEOF_test.go b/internal/fourslash/tests/gen/signatureHelpAtEOF_test.go new file mode 100644 index 0000000000..9e4ea644c3 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpAtEOF_test.go @@ -0,0 +1,21 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpAtEOF(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function Foo(arg1: string, arg2: string) { +} + +Foo(/**/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "Foo(arg1: string, arg2: string): void", ParameterCount: 2, ParameterName: "arg1", ParameterSpan: "arg1: string"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpBeforeSemicolon1_test.go b/internal/fourslash/tests/gen/signatureHelpBeforeSemicolon1_test.go new file mode 100644 index 0000000000..3760063b14 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpBeforeSemicolon1_test.go @@ -0,0 +1,21 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpBeforeSemicolon1(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function Foo(arg1: string, arg2: string) { +} + +Foo(/**/;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "Foo(arg1: string, arg2: string): void", ParameterCount: 2, ParameterName: "arg1", ParameterSpan: "arg1: string"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpCallExpressionTuples_test.go b/internal/fourslash/tests/gen/signatureHelpCallExpressionTuples_test.go new file mode 100644 index 0000000000..0fde9e1a6e --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpCallExpressionTuples_test.go @@ -0,0 +1,38 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpCallExpressionTuples(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function fnTest(str: string, num: number) { } +declare function wrap(fn: (...a: A) => R) : (...a: A) => R; +var fnWrapped = wrap(fnTest); +fnWrapped/*3*/(/*1*/'', /*2*/5); +function fnTestVariadic (str: string, ...num: number[]) { } +var fnVariadicWrapped = wrap(fnTestVariadic); +fnVariadicWrapped/*4*/(/*5*/'', /*6*/5); +function fnNoParams () { } +var fnNoParamsWrapped = wrap(fnNoParams); +fnNoParamsWrapped/*7*/(/*8*/);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyQuickInfoAt(t, "3", "var fnWrapped: (str: string, num: number) => void", "") + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "fnWrapped(str: string, num: number): void", ParameterCount: 2, ParameterName: "str", ParameterSpan: "str: string"}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "num", ParameterSpan: "num: number"}) + f.VerifyQuickInfoAt(t, "4", "var fnVariadicWrapped: (str: string, ...num: number[]) => void", "") + f.GoToMarker(t, "5") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "fnVariadicWrapped(str: string, ...num: number[]): void", ParameterCount: 2, ParameterName: "str", ParameterSpan: "str: string", IsVariadic: true, IsVariadicSet: true}) + f.GoToMarker(t, "6") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "num", ParameterSpan: "...num: number[]", IsVariadic: true, IsVariadicSet: true}) + f.VerifyQuickInfoAt(t, "7", "var fnNoParamsWrapped: () => void", "") + f.GoToMarker(t, "8") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "fnNoParamsWrapped(): void", ParameterCount: 0}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpCallExpression_test.go b/internal/fourslash/tests/gen/signatureHelpCallExpression_test.go new file mode 100644 index 0000000000..cfe7cab60d --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpCallExpression_test.go @@ -0,0 +1,21 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpCallExpression(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function fnTest(str: string, num: number) { } +fnTest(/*1*/'', /*2*/5);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "fnTest(str: string, num: number): void", ParameterCount: 2, ParameterName: "str", ParameterSpan: "str: string"}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "num", ParameterSpan: "num: number"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpConstructExpression_test.go b/internal/fourslash/tests/gen/signatureHelpConstructExpression_test.go new file mode 100644 index 0000000000..62a180e587 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpConstructExpression_test.go @@ -0,0 +1,21 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpConstructExpression(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class sampleCls { constructor(str: string, num: number) { } } +var x = new sampleCls(/*1*/"", /*2*/5);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "sampleCls(str: string, num: number): sampleCls", ParameterCount: 2, ParameterName: "str", ParameterSpan: "str: string"}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "num", ParameterSpan: "num: number"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpConstructorInheritance_test.go b/internal/fourslash/tests/gen/signatureHelpConstructorInheritance_test.go new file mode 100644 index 0000000000..f7327f47c0 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpConstructorInheritance_test.go @@ -0,0 +1,29 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpConstructorInheritance(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class base { + constructor(s: string); + constructor(n: number); + constructor(a: any) { } +} +class B1 extends base { } +class B2 extends B1 { } +class B3 extends B2 { + constructor() { + super(/*indirectSuperCall*/3); + } +}` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "indirectSuperCall") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "B2(n: number): B2", ParameterCount: 1, ParameterName: "n", ParameterSpan: "n: number", OverloadsCount: 2}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpConstructorOverload_test.go b/internal/fourslash/tests/gen/signatureHelpConstructorOverload_test.go new file mode 100644 index 0000000000..854bd98673 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpConstructorOverload_test.go @@ -0,0 +1,22 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpConstructorOverload(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class clsOverload { constructor(); constructor(test: string); constructor(test?: string) { } } +var x = new clsOverload(/*1*/); +var y = new clsOverload(/*2*/'');` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "clsOverload(): clsOverload", ParameterCount: 0, OverloadsCount: 2}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "clsOverload(test: string): clsOverload", ParameterCount: 1, ParameterName: "test", ParameterSpan: "test: string", OverloadsCount: 2}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpEmptyList_test.go b/internal/fourslash/tests/gen/signatureHelpEmptyList_test.go new file mode 100644 index 0000000000..f3231311f5 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpEmptyList_test.go @@ -0,0 +1,25 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpEmptyList(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function Foo(arg1: string, arg2: string) { +} + +Foo(/*1*/); +function Bar(arg1: string, arg2: string) { } +Bar();` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "Foo(arg1: string, arg2: string): void", ParameterCount: 2, ParameterName: "arg1", ParameterSpan: "arg1: string"}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "Bar(arg1: string, arg2: string): void"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpExpandedRestTuples_test.go b/internal/fourslash/tests/gen/signatureHelpExpandedRestTuples_test.go new file mode 100644 index 0000000000..56adbfcbff --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpExpandedRestTuples_test.go @@ -0,0 +1,28 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpExpandedRestTuples(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `export function complex(item: string, another: string, ...rest: [] | [settings: object, errorHandler: (err: Error) => void] | [errorHandler: (err: Error) => void, ...mixins: object[]]) { + +} + +complex(/*1*/); +complex("ok", "ok", /*2*/); +complex("ok", "ok", e => void e, {}, /*3*/);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "complex(item: string, another: string): void", ParameterCount: 2, ParameterName: "item", ParameterSpan: "item: string", OverloadsCount: 3, IsVariadic: false, IsVariadicSet: true}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "complex(item: string, another: string, settings: object, errorHandler: (err: Error) => void): void", ParameterCount: 4, ParameterName: "settings", ParameterSpan: "settings: object", OverloadsCount: 3, IsVariadic: false, IsVariadicSet: true}) + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "complex(item: string, another: string, errorHandler: (err: Error) => void, ...mixins: object[]): void", OverloadsCount: 3, IsVariadic: true, IsVariadicSet: true}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpExpandedRestUnlabeledTuples_test.go b/internal/fourslash/tests/gen/signatureHelpExpandedRestUnlabeledTuples_test.go new file mode 100644 index 0000000000..f6bc89adb8 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpExpandedRestUnlabeledTuples_test.go @@ -0,0 +1,28 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpExpandedRestUnlabeledTuples(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `export function complex(item: string, another: string, ...rest: [] | [object, (err: Error) => void] | [(err: Error) => void, ...object[]]) { + +} + +complex(/*1*/); +complex("ok", "ok", /*2*/); +complex("ok", "ok", e => void e, {}, /*3*/);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "complex(item: string, another: string): void", ParameterCount: 2, ParameterName: "item", ParameterSpan: "item: string", OverloadsCount: 3, IsVariadic: false, IsVariadicSet: true}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "complex(item: string, another: string, rest_0: object, rest_1: (err: Error) => void): void", ParameterCount: 4, ParameterName: "rest_0", ParameterSpan: "rest_0: object", OverloadsCount: 3, IsVariadic: false, IsVariadicSet: true}) + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "complex(item: string, another: string, rest_0: (err: Error) => void, ...rest: object[]): void", OverloadsCount: 3, IsVariadic: true, IsVariadicSet: true}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpExpandedTuplesArgumentIndex_test.go b/internal/fourslash/tests/gen/signatureHelpExpandedTuplesArgumentIndex_test.go new file mode 100644 index 0000000000..bb6dc6c9df --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpExpandedTuplesArgumentIndex_test.go @@ -0,0 +1,40 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpExpandedTuplesArgumentIndex(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function foo(...args: [string, string] | [number, string, string] +) { + +} + +foo(123/*1*/,) +foo(""/*2*/, ""/*3*/) +foo(123/*4*/, ""/*5*/, ) +foo(123/*6*/, ""/*7*/, ""/*8*/)` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo(args_0: number, args_1: string, args_2: string): void", ParameterCount: 3, ParameterName: "args_0", ParameterSpan: "args_0: number", OverloadsCount: 2, OverrideSelectedItemIndex: 1, IsVariadic: false, IsVariadicSet: true}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo(args_0: string, args_1: string): void", ParameterCount: 2, ParameterName: "args_0", ParameterSpan: "args_0: string", OverloadsCount: 2, OverrideSelectedItemIndex: 0, IsVariadic: false, IsVariadicSet: true}) + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo(args_0: string, args_1: string): void", ParameterCount: 2, ParameterName: "args_1", ParameterSpan: "args_1: string", OverloadsCount: 2, OverrideSelectedItemIndex: 0, IsVariadic: false, IsVariadicSet: true}) + f.GoToMarker(t, "4") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo(args_0: number, args_1: string, args_2: string): void", ParameterCount: 3, ParameterName: "args_0", ParameterSpan: "args_0: number", OverloadsCount: 2, OverrideSelectedItemIndex: 1, IsVariadic: false, IsVariadicSet: true}) + f.GoToMarker(t, "5") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo(args_0: number, args_1: string, args_2: string): void", ParameterCount: 3, ParameterName: "args_1", ParameterSpan: "args_1: string", OverloadsCount: 2, OverrideSelectedItemIndex: 1, IsVariadic: false, IsVariadicSet: true}) + f.GoToMarker(t, "6") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo(args_0: number, args_1: string, args_2: string): void", ParameterCount: 3, ParameterName: "args_0", ParameterSpan: "args_0: number", OverloadsCount: 2, OverrideSelectedItemIndex: 1, IsVariadic: false, IsVariadicSet: true}) + f.GoToMarker(t, "7") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo(args_0: number, args_1: string, args_2: string): void", ParameterCount: 3, ParameterName: "args_1", ParameterSpan: "args_1: string", OverloadsCount: 2, OverrideSelectedItemIndex: 1, IsVariadic: false, IsVariadicSet: true}) + f.GoToMarker(t, "8") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo(args_0: number, args_1: string, args_2: string): void", ParameterCount: 3, ParameterName: "args_2", ParameterSpan: "args_2: string", OverloadsCount: 2, OverrideSelectedItemIndex: 1, IsVariadic: false, IsVariadicSet: true}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpExplicitTypeArguments_test.go b/internal/fourslash/tests/gen/signatureHelpExplicitTypeArguments_test.go new file mode 100644 index 0000000000..69e2863709 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpExplicitTypeArguments_test.go @@ -0,0 +1,51 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpExplicitTypeArguments(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `declare function f(x: T, y: U): T; +f(/*1*/); +f(/*2*/); +f(/*3*/); +f(/*4*/); +interface A { a: number } +interface B extends A { b: string } +declare function g(x: T, y: U, z: V): T; +declare function h(x: T, y: U, z: V): T; +declare function j(x: T, y: U, z: V): T; +g(/*5*/); +h(/*6*/); +j(/*7*/); +g(/*8*/); +h(/*9*/); +j(/*10*/);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f(x: number, y: string): number"}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f(x: boolean, y: string): boolean"}) + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f(x: number, y: string): number"}) + f.GoToMarker(t, "4") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f(x: number, y: string): number"}) + f.GoToMarker(t, "5") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "g(x: unknown, y: unknown, z: B): unknown"}) + f.GoToMarker(t, "6") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "h(x: unknown, y: unknown, z: A): unknown"}) + f.GoToMarker(t, "7") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "j(x: unknown, y: unknown, z: B): unknown"}) + f.GoToMarker(t, "8") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "g(x: number, y: unknown, z: B): number"}) + f.GoToMarker(t, "9") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "h(x: number, y: unknown, z: A): number"}) + f.GoToMarker(t, "10") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "j(x: number, y: unknown, z: B): number"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpFilteredTriggers03_test.go b/internal/fourslash/tests/gen/signatureHelpFilteredTriggers03_test.go new file mode 100644 index 0000000000..491965d7db --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpFilteredTriggers03_test.go @@ -0,0 +1,30 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + . "github.com/microsoft/typescript-go/internal/fourslash/tests/util" + "github.com/microsoft/typescript-go/internal/lsp/lsproto" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpFilteredTriggers03(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `declare class ViewJayEss { + constructor(obj: object); +} +new ViewJayEss({ + methods: { + sayHello/**/ + } +});` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.Insert(t, "(") + f.VerifyNoSignatureHelpWithContext(t, &lsproto.SignatureHelpContext{TriggerKind: lsproto.SignatureHelpTriggerKindTriggerCharacter, TriggerCharacter: PtrTo("("), IsRetrigger: false}) + f.Insert(t, ") {},") + f.VerifyNoSignatureHelpWithContext(t, &lsproto.SignatureHelpContext{TriggerKind: lsproto.SignatureHelpTriggerKindTriggerCharacter, TriggerCharacter: PtrTo(","), IsRetrigger: false}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpForNonlocalTypeDoesNotUseImportType_test.go b/internal/fourslash/tests/gen/signatureHelpForNonlocalTypeDoesNotUseImportType_test.go new file mode 100644 index 0000000000..65d55d2c94 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpForNonlocalTypeDoesNotUseImportType_test.go @@ -0,0 +1,24 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpForNonlocalTypeDoesNotUseImportType(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: exporter.ts +export interface Thing {} +export const Foo: () => Thing = null as any; +// @Filename: usage.ts +import {Foo} from "./exporter" +function f(p = Foo()): void {} +f(/*1*/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f(p?: Thing): void"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpForOptionalMethods_test.go b/internal/fourslash/tests/gen/signatureHelpForOptionalMethods_test.go new file mode 100644 index 0000000000..6ed2736e1e --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpForOptionalMethods_test.go @@ -0,0 +1,27 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpForOptionalMethods(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @strict: true +interface Obj { + optionalMethod?: (current: any) => any; +}; + +const o: Obj = { + optionalMethod(/*1*/) { + return {}; + } +};` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "optionalMethod(current: any): any", ParameterName: "current", ParameterSpan: "current: any"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpForSignatureWithUnreachableType_test.go b/internal/fourslash/tests/gen/signatureHelpForSignatureWithUnreachableType_test.go new file mode 100644 index 0000000000..4b1a3b25ba --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpForSignatureWithUnreachableType_test.go @@ -0,0 +1,28 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpForSignatureWithUnreachableType(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: /node_modules/foo/node_modules/bar/index.d.ts +export interface SomeType { + x?: number; +} +// @Filename: /node_modules/foo/index.d.ts +import { SomeType } from "bar"; +export function func(param: T): void; +export function func(param: T, other: T): void; +// @Filename: /usage.ts +import { func } from "foo"; +func({/*1*/});` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "func(param: {}): void", OverloadsCount: 2}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpForSuperCalls1_test.go b/internal/fourslash/tests/gen/signatureHelpForSuperCalls1_test.go new file mode 100644 index 0000000000..74b1cc4f09 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpForSuperCalls1_test.go @@ -0,0 +1,35 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpForSuperCalls1(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class A { } +class B extends A { } +class C extends B { + constructor() { + super(/*1*/ // sig help here? + } +} +class A2 { } +class B2 extends A2 { + constructor(x:number) {} + } +class C2 extends B2 { + constructor() { + super(/*2*/ // sig help here? + } +}` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "B(): B"}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "B2(x: number): B2"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpFunctionOverload_test.go b/internal/fourslash/tests/gen/signatureHelpFunctionOverload_test.go new file mode 100644 index 0000000000..af2f952789 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpFunctionOverload_test.go @@ -0,0 +1,24 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpFunctionOverload(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function functionOverload(); +function functionOverload(test: string); +function functionOverload(test?: string) { } +functionOverload(/*functionOverload1*/); +functionOverload(""/*functionOverload2*/);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "functionOverload1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "functionOverload(): any", ParameterCount: 0, OverloadsCount: 2}) + f.GoToMarker(t, "functionOverload2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "functionOverload(test: string): any", ParameterName: "test", ParameterSpan: "test: string", OverloadsCount: 2}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpFunctionParameter_test.go b/internal/fourslash/tests/gen/signatureHelpFunctionParameter_test.go new file mode 100644 index 0000000000..a783d4cfb4 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpFunctionParameter_test.go @@ -0,0 +1,22 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpFunctionParameter(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function parameterFunction(callback: (a: number, b: string) => void) { + callback(/*parameterFunction1*/5, /*parameterFunction2*/""); +}` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "parameterFunction1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "callback(a: number, b: string): void", ParameterCount: 2, ParameterName: "a", ParameterSpan: "a: number"}) + f.GoToMarker(t, "parameterFunction2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "callback(a: number, b: string): void", ParameterName: "b", ParameterSpan: "b: string"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpImplicitConstructor_test.go b/internal/fourslash/tests/gen/signatureHelpImplicitConstructor_test.go new file mode 100644 index 0000000000..43998ca977 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpImplicitConstructor_test.go @@ -0,0 +1,20 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpImplicitConstructor(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class ImplicitConstructor { +} +var implicitConstructor = new ImplicitConstructor(/**/);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "ImplicitConstructor(): ImplicitConstructor", ParameterCount: 0}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpImportStarFromExportEquals_test.go b/internal/fourslash/tests/gen/signatureHelpImportStarFromExportEquals_test.go new file mode 100644 index 0000000000..475da83c31 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpImportStarFromExportEquals_test.go @@ -0,0 +1,25 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpImportStarFromExportEquals(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @allowJs: true +// @Filename: /node_modules/@types/abs/index.d.ts +declare function abs(str: string): string; +export = abs; +// @Filename: /a.js +import * as abs from "abs"; +abs/**/;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.Insert(t, "(") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "abs(str: string): string"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpInAdjacentBlockBody_test.go b/internal/fourslash/tests/gen/signatureHelpInAdjacentBlockBody_test.go new file mode 100644 index 0000000000..937e13c24f --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpInAdjacentBlockBody_test.go @@ -0,0 +1,23 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/lsp/lsproto" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpInAdjacentBlockBody(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `declare function foo(...args); + +foo(() => {/*1*/}/*2*/)` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelpPresent(t, &lsproto.SignatureHelpContext{TriggerKind: lsproto.SignatureHelpTriggerKindInvoked}) + f.GoToMarker(t, "2") + f.VerifySignatureHelpPresent(t, &lsproto.SignatureHelpContext{TriggerKind: lsproto.SignatureHelpTriggerKindInvoked}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpInCallback_test.go b/internal/fourslash/tests/gen/signatureHelpInCallback_test.go new file mode 100644 index 0000000000..42addb67ba --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpInCallback_test.go @@ -0,0 +1,22 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpInCallback(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `declare function forEach(f: () => void); +forEach(/*1*/() => { + /*2*/ +});` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "forEach(f: () => void): any"}) + f.VerifyNoSignatureHelpForMarkers(t, "2") +} diff --git a/internal/fourslash/tests/gen/signatureHelpInCompleteGenericsCall_test.go b/internal/fourslash/tests/gen/signatureHelpInCompleteGenericsCall_test.go new file mode 100644 index 0000000000..e27da68a51 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpInCompleteGenericsCall_test.go @@ -0,0 +1,20 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpInCompleteGenericsCall(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function foo(x: number, callback: (x: T) => number) { +} +foo(/*1*/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo(x: number, callback: (x: unknown) => number): void"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpInFunctionCallOnFunctionDeclarationInMultipleFiles_test.go b/internal/fourslash/tests/gen/signatureHelpInFunctionCallOnFunctionDeclarationInMultipleFiles_test.go new file mode 100644 index 0000000000..5a1e0912e8 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpInFunctionCallOnFunctionDeclarationInMultipleFiles_test.go @@ -0,0 +1,23 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpInFunctionCallOnFunctionDeclarationInMultipleFiles(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: signatureHelpInFunctionCallOnFunctionDeclarationInMultipleFiles_file0.ts +declare function fn(x: string, y: number); +// @Filename: signatureHelpInFunctionCallOnFunctionDeclarationInMultipleFiles_file1.ts +declare function fn(x: string); +// @Filename: signatureHelpInFunctionCallOnFunctionDeclarationInMultipleFiles_file2.ts +fn(/*1*/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpInFunctionCall_test.go b/internal/fourslash/tests/gen/signatureHelpInFunctionCall_test.go new file mode 100644 index 0000000000..19a79bd9e3 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpInFunctionCall_test.go @@ -0,0 +1,20 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpInFunctionCall(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `var items = []; +items.forEach(item => { + for (/**/ +});` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyNoSignatureHelpForMarkers(t, "") +} diff --git a/internal/fourslash/tests/gen/signatureHelpInParenthetical_test.go b/internal/fourslash/tests/gen/signatureHelpInParenthetical_test.go new file mode 100644 index 0000000000..c6f3abdadc --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpInParenthetical_test.go @@ -0,0 +1,21 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpInParenthetical(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class base { constructor (public n: number, public y: string) { } } +(new base(/**/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "n"}) + f.Insert(t, "0, ") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "y"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpInRecursiveType_test.go b/internal/fourslash/tests/gen/signatureHelpInRecursiveType_test.go new file mode 100644 index 0000000000..cf194418d7 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpInRecursiveType_test.go @@ -0,0 +1,28 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpInRecursiveType(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `type Tail = + ((...args: T) => any) extends ((head: any, ...tail: infer R) => any) ? R : never; + +type Reverse = _Reverse; + +type _Reverse = { + 1: Result, + 0: _Reverse, 0>, +}[Source extends [] ? 1 : 0]; + +type Foo = Reverse<[0,/**/]>;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "Reverse"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpIncompleteCalls_test.go b/internal/fourslash/tests/gen/signatureHelpIncompleteCalls_test.go new file mode 100644 index 0000000000..8b5deb54f9 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpIncompleteCalls_test.go @@ -0,0 +1,35 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpIncompleteCalls(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `module IncompleteCalls { + class Foo { + public f1() { } + public f2(n: number): number { return 0; } + public f3(n: number, s: string) : string { return ""; } + } + var x = new Foo(); + x.f1(); + x.f2(5); + x.f3(5, ""); + x.f1(/*incompleteCalls1*/ + x.f2(5,/*incompleteCalls2*/ + x.f3(5,/*incompleteCalls3*/ +}` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "incompleteCalls1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f1(): void", ParameterCount: 0}) + f.GoToMarker(t, "incompleteCalls2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f2(n: number): number", ParameterCount: 1}) + f.GoToMarker(t, "incompleteCalls3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f3(n: number, s: string): string", ParameterCount: 2, ParameterName: "s", ParameterSpan: "s: string"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpInferenceJsDocImportTag_test.go b/internal/fourslash/tests/gen/signatureHelpInferenceJsDocImportTag_test.go index 6a53358869..4c1e13b5d3 100644 --- a/internal/fourslash/tests/gen/signatureHelpInferenceJsDocImportTag_test.go +++ b/internal/fourslash/tests/gen/signatureHelpInferenceJsDocImportTag_test.go @@ -9,7 +9,7 @@ import ( func TestSignatureHelpInferenceJsDocImportTag(t *testing.T) { t.Parallel() - t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") const content = `// @allowJS: true // @checkJs: true diff --git a/internal/fourslash/tests/gen/signatureHelpInference_test.go b/internal/fourslash/tests/gen/signatureHelpInference_test.go new file mode 100644 index 0000000000..f80acdb1bd --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpInference_test.go @@ -0,0 +1,19 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpInference(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `declare function f(a: T, b: T, c: T): void; +f("x", /**/);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f(a: \"x\", b: \"x\", c: \"x\"): void", ParameterCount: 3, ParameterName: "b", ParameterSpan: "b: \"x\""}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpJSMissingIdentifier_test.go b/internal/fourslash/tests/gen/signatureHelpJSMissingIdentifier_test.go new file mode 100644 index 0000000000..b54cda28d1 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpJSMissingIdentifier_test.go @@ -0,0 +1,20 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpJSMissingIdentifier(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @allowJs: true +// @checkJs: true +// @Filename: test.js +log(/**/)` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyNoSignatureHelpForMarkers(t, "") +} diff --git a/internal/fourslash/tests/gen/signatureHelpJSX_test.go b/internal/fourslash/tests/gen/signatureHelpJSX_test.go new file mode 100644 index 0000000000..503cbb08b6 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpJSX_test.go @@ -0,0 +1,23 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + . "github.com/microsoft/typescript-go/internal/fourslash/tests/util" + "github.com/microsoft/typescript-go/internal/lsp/lsproto" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpJSX(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `//@Filename: test.tsx +//@jsx: react +declare var React: any; +const z =
{[].map(x => "" }; +objectLiteral.f(/*objectLiteral1*/4, /*objectLiteral2*/"");` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "objectLiteral1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f(a: number, b: string): string", ParameterCount: 2, ParameterName: "a", ParameterSpan: "a: number"}) + f.GoToMarker(t, "objectLiteral2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f(a: number, b: string): string", ParameterName: "b", ParameterSpan: "b: string"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpOnDeclaration_test.go b/internal/fourslash/tests/gen/signatureHelpOnDeclaration_test.go new file mode 100644 index 0000000000..1d81083fa6 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpOnDeclaration_test.go @@ -0,0 +1,18 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpOnDeclaration(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function f(a: any): a is T {} +function f3(a: any, ...b): a is number {} +f1(/*1*/) +f2(/*2*/) +f3(/*3*/)` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f1(a: any): a is number"}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f2(a: any): a is unknown"}) + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f3(a: any, ...b: any[]): a is number", IsVariadic: true, IsVariadicSet: true}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpOptionalCall2_test.go b/internal/fourslash/tests/gen/signatureHelpOptionalCall2_test.go new file mode 100644 index 0000000000..ffbabdeed1 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpOptionalCall2_test.go @@ -0,0 +1,19 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpOptionalCall2(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `declare const fnTest: undefined | ((str: string, num: number) => void); +fnTest?.(/*1*/);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "fnTest(str: string, num: number): void", ParameterCount: 2, ParameterName: "str", ParameterSpan: "str: string"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpOptionalCall_test.go b/internal/fourslash/tests/gen/signatureHelpOptionalCall_test.go new file mode 100644 index 0000000000..ab2a5b583e --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpOptionalCall_test.go @@ -0,0 +1,19 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpOptionalCall(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function fnTest(str: string, num: number) { } +fnTest?.(/*1*/);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "fnTest(str: string, num: number): void", ParameterCount: 2, ParameterName: "str", ParameterSpan: "str: string"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpSimpleConstructorCall_test.go b/internal/fourslash/tests/gen/signatureHelpSimpleConstructorCall_test.go new file mode 100644 index 0000000000..f353fe4270 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpSimpleConstructorCall_test.go @@ -0,0 +1,24 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpSimpleConstructorCall(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class ConstructorCall { + constructor(str: string, num: number) { + } +} +var x = new ConstructorCall(/*constructorCall1*/1,/*constructorCall2*/2);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "constructorCall1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "ConstructorCall(str: string, num: number): ConstructorCall", ParameterName: "str", ParameterSpan: "str: string"}) + f.GoToMarker(t, "constructorCall2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "ConstructorCall(str: string, num: number): ConstructorCall", ParameterName: "num", ParameterSpan: "num: number"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpSimpleFunctionCall_test.go b/internal/fourslash/tests/gen/signatureHelpSimpleFunctionCall_test.go new file mode 100644 index 0000000000..16376e0c8b --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpSimpleFunctionCall_test.go @@ -0,0 +1,24 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpSimpleFunctionCall(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// Simple function test +function functionCall(str: string, num: number) { +} +functionCall(/*functionCall1*/); +functionCall("", /*functionCall2*/1);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "functionCall1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "functionCall(str: string, num: number): void", ParameterName: "str", ParameterSpan: "str: string"}) + f.GoToMarker(t, "functionCall2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "functionCall(str: string, num: number): void", ParameterName: "num", ParameterSpan: "num: number"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpSimpleSuperCall_test.go b/internal/fourslash/tests/gen/signatureHelpSimpleSuperCall_test.go new file mode 100644 index 0000000000..cf5c61d06d --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpSimpleSuperCall_test.go @@ -0,0 +1,26 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpSimpleSuperCall(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class SuperCallBase { + constructor(b: boolean) { + } +} +class SuperCall extends SuperCallBase { + constructor() { + super(/*superCall*/); + } +}` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "superCall") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "SuperCallBase(b: boolean): SuperCallBase", ParameterName: "b", ParameterSpan: "b: boolean"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpSuperConstructorOverload_test.go b/internal/fourslash/tests/gen/signatureHelpSuperConstructorOverload_test.go new file mode 100644 index 0000000000..578df8497f --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpSuperConstructorOverload_test.go @@ -0,0 +1,35 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpSuperConstructorOverload(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class SuperOverloadBase { + constructor(); + constructor(test: string); + constructor(test?: string) { + } +} +class SuperOverLoad1 extends SuperOverloadBase { + constructor() { + super(/*superOverload1*/); + } +} +class SuperOverLoad2 extends SuperOverloadBase { + constructor() { + super(""/*superOverload2*/); + } +}` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "superOverload1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "SuperOverloadBase(): SuperOverloadBase", ParameterCount: 0, OverloadsCount: 2}) + f.GoToMarker(t, "superOverload2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "SuperOverloadBase(test: string): SuperOverloadBase", ParameterCount: 1, ParameterName: "test", ParameterSpan: "test: string", OverloadsCount: 2}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpTaggedTemplatesNegatives1_test.go b/internal/fourslash/tests/gen/signatureHelpTaggedTemplatesNegatives1_test.go new file mode 100644 index 0000000000..7a7180dc7b --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpTaggedTemplatesNegatives1_test.go @@ -0,0 +1,20 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpTaggedTemplatesNegatives1(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function f(templateStrings, x, y, z) { return 10; } +function g(templateStrings, x, y, z) { return ""; } + +/*1*/f/*2*/ /*3*/` + "`" + ` qwerty ${ 123 } asdf ${ 41234 } zxcvb ${ g ` + "`" + ` ` + "`" + ` } ` + "`" + `/*4*/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyNoSignatureHelpForMarkers(t, f.MarkerNames()...) +} diff --git a/internal/fourslash/tests/gen/signatureHelpTaggedTemplatesNegatives2_test.go b/internal/fourslash/tests/gen/signatureHelpTaggedTemplatesNegatives2_test.go new file mode 100644 index 0000000000..7f95691123 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpTaggedTemplatesNegatives2_test.go @@ -0,0 +1,20 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpTaggedTemplatesNegatives2(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function foo(strs, ...rest) { +} + +/*1*/fo/*2*/o /*3*/` + "`" + `abcd${0 + 1}abcd{1 + 1}` + "`" + `/*4*/ /*5*/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyNoSignatureHelpForMarkers(t, f.MarkerNames()...) +} diff --git a/internal/fourslash/tests/gen/signatureHelpTaggedTemplatesNegatives3_test.go b/internal/fourslash/tests/gen/signatureHelpTaggedTemplatesNegatives3_test.go new file mode 100644 index 0000000000..0903890598 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpTaggedTemplatesNegatives3_test.go @@ -0,0 +1,20 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpTaggedTemplatesNegatives3(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function foo(strs, ...rest) { +} + +/*1*/fo/*2*/o /*3*/` + "`" + `abcd${0 + 1}abcd{1 + 1}abcd` + "`" + `/*4*/ /*5*/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyNoSignatureHelpForMarkers(t, f.MarkerNames()...) +} diff --git a/internal/fourslash/tests/gen/signatureHelpTaggedTemplatesNegatives4_test.go b/internal/fourslash/tests/gen/signatureHelpTaggedTemplatesNegatives4_test.go new file mode 100644 index 0000000000..b625a1b41f --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpTaggedTemplatesNegatives4_test.go @@ -0,0 +1,20 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpTaggedTemplatesNegatives4(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function foo(strs, ...rest) { +} + +/*1*/fo/*2*/o /*3*/` + "`" + `` + "`" + `/*4*/ /*5*/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyNoSignatureHelpForMarkers(t, f.MarkerNames()...) +} diff --git a/internal/fourslash/tests/gen/signatureHelpTaggedTemplatesNegatives5_test.go b/internal/fourslash/tests/gen/signatureHelpTaggedTemplatesNegatives5_test.go new file mode 100644 index 0000000000..000b4b66b4 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpTaggedTemplatesNegatives5_test.go @@ -0,0 +1,20 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpTaggedTemplatesNegatives5(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function foo(strs, ...rest) { +} + +/*1*/fo/*2*/o /*3*/` + "`" + `abcd` + "`" + `/*4*/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyNoSignatureHelpForMarkers(t, f.MarkerNames()...) +} diff --git a/internal/fourslash/tests/gen/signatureHelpThis_test.go b/internal/fourslash/tests/gen/signatureHelpThis_test.go new file mode 100644 index 0000000000..6da2a1f286 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpThis_test.go @@ -0,0 +1,55 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpThis(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class Foo { + public implicitAny(n: number) { + } + public explicitThis(this: this, n: number) { + console.log(this); + } + public explicitClass(this: Foo, n: number) { + console.log(this); + } +} + +function implicitAny(x: number): void { + return this; +} +function explicitVoid(this: void, x: number): void { + return this; +} +function explicitLiteral(this: { n: number }, x: number): void { + console.log(this); +} +let foo = new Foo(); +foo.implicitAny(/*1*/); +foo.explicitThis(/*2*/); +foo.explicitClass(/*3*/); +implicitAny(/*4*/12); +explicitVoid(/*5*/13); +let o = { n: 14, m: explicitLiteral }; +o.m(/*6*/);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "n"}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "n"}) + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "n"}) + f.GoToMarker(t, "4") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "x"}) + f.GoToMarker(t, "5") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "x"}) + f.GoToMarker(t, "6") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{ParameterName: "x"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpTrailingRestTuple_test.go b/internal/fourslash/tests/gen/signatureHelpTrailingRestTuple_test.go new file mode 100644 index 0000000000..7124d5d492 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpTrailingRestTuple_test.go @@ -0,0 +1,27 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpTrailingRestTuple(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `export function leading(allCaps: boolean, ...names: string[]): void { +} + +leading(/*1*/); +leading(false, /*2*/); +leading(false, "ok", /*3*/);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "leading(allCaps: boolean, ...names: string[]): void", ParameterCount: 2, ParameterName: "allCaps", ParameterSpan: "allCaps: boolean", OverloadsCount: 1, IsVariadic: true, IsVariadicSet: true}) + f.GoToMarker(t, "2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "leading(allCaps: boolean, ...names: string[]): void", ParameterCount: 2, ParameterName: "names", ParameterSpan: "...names: string[]", OverloadsCount: 1, IsVariadic: true, IsVariadicSet: true}) + f.GoToMarker(t, "3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "leading(allCaps: boolean, ...names: string[]): void", ParameterCount: 2, ParameterName: "names", ParameterSpan: "...names: string[]", OverloadsCount: 1, IsVariadic: true, IsVariadicSet: true}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpTypeArguments_test.go b/internal/fourslash/tests/gen/signatureHelpTypeArguments_test.go new file mode 100644 index 0000000000..3893104f3c --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpTypeArguments_test.go @@ -0,0 +1,43 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpTypeArguments(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `declare function f(a: number, b: string, c: boolean): void; // ignored, not generic +declare function f(): void; +declare function f(): void; +declare function f(): void; +f(): void; + new(): void; + new(): void; +}; +new C(): void", ParameterName: "T", ParameterSpan: "T extends number", OverloadsCount: 3}) + f.GoToMarker(t, "f1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f(): void", ParameterName: "U", ParameterSpan: "U", OverloadsCount: 2}) + f.GoToMarker(t, "f2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f(): void", ParameterName: "V", ParameterSpan: "V extends string"}) + f.GoToMarker(t, "C0") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "C(): void", ParameterName: "T", ParameterSpan: "T extends number", OverloadsCount: 3}) + f.GoToMarker(t, "C1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "C(): void", ParameterName: "U", ParameterSpan: "U", OverloadsCount: 2}) + f.GoToMarker(t, "C2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "C(): void", ParameterName: "V", ParameterSpan: "V extends string"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpTypeParametersNotVariadic_test.go b/internal/fourslash/tests/gen/signatureHelpTypeParametersNotVariadic_test.go new file mode 100644 index 0000000000..d002b84a09 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpTypeParametersNotVariadic_test.go @@ -0,0 +1,19 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpTypeParametersNotVariadic(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `declare function f(a: any, ...b: any[]): any; +f(1, 2);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{IsVariadic: false, IsVariadicSet: true}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpWithInterfaceAsIdentifier_test.go b/internal/fourslash/tests/gen/signatureHelpWithInterfaceAsIdentifier_test.go new file mode 100644 index 0000000000..37760d36b2 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpWithInterfaceAsIdentifier_test.go @@ -0,0 +1,20 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpWithInterfaceAsIdentifier(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `interface C { + (): void; +} +C(/*1*/);` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyNoSignatureHelpForMarkers(t, "1") +} diff --git a/internal/fourslash/tests/gen/signatureHelpWithInvalidArgumentList1_test.go b/internal/fourslash/tests/gen/signatureHelpWithInvalidArgumentList1_test.go new file mode 100644 index 0000000000..f682f30445 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpWithInvalidArgumentList1_test.go @@ -0,0 +1,19 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpWithInvalidArgumentList1(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function foo(a) { } +foo(hello my name /**/is` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo(a: any): void"}) +} diff --git a/internal/fourslash/tests/gen/signatureHelpWithTriggers02_test.go b/internal/fourslash/tests/gen/signatureHelpWithTriggers02_test.go new file mode 100644 index 0000000000..69565a3bee --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelpWithTriggers02_test.go @@ -0,0 +1,29 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelpWithTriggers02(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `declare function foo(x: T, y: T): T; +declare function bar(x: U, y: U): U; + +foo(bar/*1*/)` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "1") + f.Insert(t, "(") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "bar(x: unknown, y: unknown): unknown"}) + f.Backspace(t, 1) + f.Insert(t, "<") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "bar(x: U, y: U): U"}) + f.Backspace(t, 1) + f.Insert(t, ",") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "foo(x: (x: U, y: U) => U, y: (x: U, y: U) => U): (x: U, y: U) => U"}) + f.Backspace(t, 1) +} diff --git a/internal/fourslash/tests/gen/signatureHelp_contextual_test.go b/internal/fourslash/tests/gen/signatureHelp_contextual_test.go new file mode 100644 index 0000000000..a78b638979 --- /dev/null +++ b/internal/fourslash/tests/gen/signatureHelp_contextual_test.go @@ -0,0 +1,61 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSignatureHelp_contextual(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `interface I { + m(n: number, s: string): void; + m2: () => void; +} +declare function takesObj(i: I): void; +takesObj({ m: (/*takesObj0*/) }); +takesObj({ m(/*takesObj1*/) }); +takesObj({ m: function(/*takesObj2*/) }); +takesObj({ m2: (/*takesObj3*/) }); + +declare function takesCb(cb: (n: number, s: string, b: boolean) => void): void; +takesCb((/*contextualParameter1*/)); +takesCb((/*contextualParameter1b*/) => {}); +takesCb((n, /*contextualParameter2*/)); +takesCb((n, s, /*contextualParameter3*/)); +takesCb((n,/*contextualParameter3_2*/ s, b)); +takesCb((n, s, b, /*contextualParameter4*/)); + +type Cb = () => void; +const cb: Cb = (/*contextualTypeAlias*/) + +const cb2: () => void = (/*contextualFunctionType*/)` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "takesObj0") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "m(n: number, s: string): void", ParameterCount: 2, ParameterName: "n", ParameterSpan: "n: number"}) + f.GoToMarker(t, "takesObj1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "m(n: number, s: string): void", ParameterCount: 2, ParameterName: "n", ParameterSpan: "n: number"}) + f.GoToMarker(t, "takesObj2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "m(n: number, s: string): void", ParameterCount: 2, ParameterName: "n", ParameterSpan: "n: number"}) + f.GoToMarker(t, "takesObj3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "m2(): void", ParameterCount: 0}) + f.GoToMarker(t, "contextualParameter1") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "cb(n: number, s: string, b: boolean): void", ParameterCount: 3, ParameterName: "n", ParameterSpan: "n: number"}) + f.GoToMarker(t, "contextualParameter1b") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "cb(n: number, s: string, b: boolean): void", ParameterCount: 3, ParameterName: "n", ParameterSpan: "n: number"}) + f.GoToMarker(t, "contextualParameter2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "cb(n: number, s: string, b: boolean): void", ParameterCount: 3, ParameterName: "s", ParameterSpan: "s: string"}) + f.GoToMarker(t, "contextualParameter3") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "cb(n: number, s: string, b: boolean): void", ParameterCount: 3, ParameterName: "b", ParameterSpan: "b: boolean"}) + f.GoToMarker(t, "contextualParameter3_2") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "cb(n: number, s: string, b: boolean): void", ParameterCount: 3, ParameterName: "s", ParameterSpan: "s: string"}) + f.GoToMarker(t, "contextualParameter4") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "cb(n: number, s: string, b: boolean): void", ParameterCount: 3}) + f.GoToMarker(t, "contextualTypeAlias") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "Cb(): void", ParameterCount: 0}) + f.GoToMarker(t, "contextualFunctionType") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "cb2(): void", ParameterCount: 0}) +} diff --git a/internal/fourslash/tests/gen/staticGenericOverloads1_test.go b/internal/fourslash/tests/gen/staticGenericOverloads1_test.go new file mode 100644 index 0000000000..bf136c1db0 --- /dev/null +++ b/internal/fourslash/tests/gen/staticGenericOverloads1_test.go @@ -0,0 +1,32 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestStaticGenericOverloads1(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class A { + static B(v: A): A; + static B(v: S): A; + static B(v: any): A { + return null; + } +} +var a = new A(); +A.B(/**/` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{OverloadsCount: 2}) + f.Insert(t, "a") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "B(v: A): A", OverloadsCount: 2}) + f.Insert(t, "); A.B(") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "B(v: A): A", OverloadsCount: 2}) + f.Insert(t, "a") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "B(v: A): A", OverloadsCount: 2}) +} diff --git a/internal/fourslash/tests/gen/superInsideInnerClass_test.go b/internal/fourslash/tests/gen/superInsideInnerClass_test.go new file mode 100644 index 0000000000..f34ead9aa0 --- /dev/null +++ b/internal/fourslash/tests/gen/superInsideInnerClass_test.go @@ -0,0 +1,27 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestSuperInsideInnerClass(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class Base { + constructor(n: number) { + } +} +class Derived extends Base { + constructor() { + class Nested { + [super(/*1*/)] = 11111 + } + } +}` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyNoSignatureHelpForMarkers(t, "1") +} diff --git a/internal/fourslash/tests/gen/tsxSignatureHelp1_test.go b/internal/fourslash/tests/gen/tsxSignatureHelp1_test.go new file mode 100644 index 0000000000..17c978f887 --- /dev/null +++ b/internal/fourslash/tests/gen/tsxSignatureHelp1_test.go @@ -0,0 +1,38 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestTsxSignatureHelp1(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `//@Filename: file.tsx +// @jsx: preserve +// @noLib: true +// @libFiles: react.d.ts,lib.d.ts +import React = require('react'); +export interface ClickableProps { + children?: string; + className?: string; +} +export interface ButtonProps extends ClickableProps { + onClick(event?: React.MouseEvent): void; +} +function _buildMainButton({ onClick, children, className }: ButtonProps): JSX.Element { + return(); +} +export function MainButton(props: ButtonProps): JSX.Element { + return this._buildMainButton(props); +} +let e1 = ): void; +} +export interface LinkProps extends ClickableProps { + goTo(where: "home" | "contact"): void; +} +function _buildMainButton({ onClick, children, className }: ButtonProps): JSX.Element { + return(); +} +export function MainButton(buttonProps: ButtonProps): JSX.Element; +export function MainButton(linkProps: LinkProps): JSX.Element; +export function MainButton(props: ButtonProps | LinkProps): JSX.Element { + return this._buildMainButton(props); +} +let e1 = any * }} o */ function f1(o) { @@ -32,5 +28,5 @@ function f1(o) { }` f := fourslash.NewFourslash(t, nil /*capabilities*/, content) f.GoToMarker(t, "") - f.VerifyQuickInfoIs(t, "(parameter) o: {\n stringProp: string;\n numProp: number;\n boolProp: boolean;\n anyProp: any;\n anotherAnyProp: any;\n functionProp: (arg0: string, arg1: any) => any;\n}", "") + f.VerifyQuickInfoIs(t, "(parameter) o: { stringProp: string; numProp: number; boolProp: boolean; anyProp: any; anotherAnyProp: any; functionProp: (arg0: string, arg1: any) => any; }", "") } diff --git a/internal/fourslash/tests/manual/jsDocFunctionSignatures2_test.go b/internal/fourslash/tests/manual/jsDocFunctionSignatures2_test.go new file mode 100644 index 0000000000..85ccb25a81 --- /dev/null +++ b/internal/fourslash/tests/manual/jsDocFunctionSignatures2_test.go @@ -0,0 +1,23 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestJsDocFunctionSignatures2(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @allowNonTsExtensions: true +// @Filename: Foo.js +/** @type {(arg0: string, arg1?: boolean) => number} */ +var f6; + +f6('', /**/false)` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "") + f.VerifySignatureHelp(t, fourslash.VerifySignatureHelpOptions{Text: "f6(arg0: string, arg1?: boolean): number"}) +} diff --git a/internal/fourslash/tests/signatureHelpCrash_test.go b/internal/fourslash/tests/signatureHelpCrash_test.go index 00c516c29e..b6228daed6 100644 --- a/internal/fourslash/tests/signatureHelpCrash_test.go +++ b/internal/fourslash/tests/signatureHelpCrash_test.go @@ -20,7 +20,7 @@ function foo(x: string, y: T, z: U) { foo/*1*/("hello", 123,456) ` f := fourslash.NewFourslash(t, nil /*capabilities*/, content) - f.VerifySignatureHelp(t, &fourslash.SignatureHelpCase{ + f.VerifySignatureHelpWithCases(t, &fourslash.SignatureHelpCase{ MarkerInput: "1", Expected: nil, Context: &lsproto.SignatureHelpContext{ diff --git a/internal/fourslash/tests/signatureHelpTokenCrash_test.go b/internal/fourslash/tests/signatureHelpTokenCrash_test.go index 84d1d98772..014118fc39 100644 --- a/internal/fourslash/tests/signatureHelpTokenCrash_test.go +++ b/internal/fourslash/tests/signatureHelpTokenCrash_test.go @@ -23,7 +23,7 @@ foo((/*1*/ foo/** More comments*/((/*2*/ ` f := fourslash.NewFourslash(t, nil /*capabilities*/, content) - f.VerifySignatureHelp(t, &fourslash.SignatureHelpCase{ + f.VerifySignatureHelpWithCases(t, &fourslash.SignatureHelpCase{ MarkerInput: "1", Expected: nil, Context: &lsproto.SignatureHelpContext{ @@ -32,7 +32,7 @@ foo/** More comments*/((/*2*/ TriggerKind: lsproto.SignatureHelpTriggerKindTriggerCharacter, }, }) - f.VerifySignatureHelp(t, &fourslash.SignatureHelpCase{ + f.VerifySignatureHelpWithCases(t, &fourslash.SignatureHelpCase{ MarkerInput: "2", Expected: nil, Context: &lsproto.SignatureHelpContext{ diff --git a/internal/ls/signaturehelp.go b/internal/ls/signaturehelp.go index 4369ef0bc8..c404a764bd 100644 --- a/internal/ls/signaturehelp.go +++ b/internal/ls/signaturehelp.go @@ -111,7 +111,7 @@ func (l *LanguageService) GetSignatureHelpItems( onlyUseSyntacticOwners := triggerReasonKind == signatureHelpTriggerReasonKindCharacterTyped // 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) needs formatting implemented + if onlyUseSyntacticOwners && (IsInString(sourceFile, position, startingToken) || isInComment(sourceFile, position, startingToken) != nil) { return nil } @@ -121,17 +121,23 @@ func (l *LanguageService) GetSignatureHelpItems( return nil } - // cancellationToken.throwIfCancellationRequested(); + if ctx.Err() != nil { + return nil + } // Extra syntactic and semantic filtering of signature help candidateInfo := getCandidateOrTypeInfo(argumentInfo, typeChecker, sourceFile, startingToken, onlyUseSyntacticOwners) - // cancellationToken.throwIfCancellationRequested(); + + if ctx.Err() != nil { + return nil + } if candidateInfo == nil { - // !!! - // // We didn't have any sig help items produced by the TS compiler. If this is a JS - // // file, then see if we can figure out anything better. - // return isSourceFileJS(sourceFile) ? createJSSignatureHelpItems(argumentInfo, program, cancellationToken) : undefined; + // For JS files, try a fallback that searches all source files for declarations + // with matching names that have call signatures. This is a heuristic for untyped JS code. + if ast.IsSourceFileJS(sourceFile) { + return l.createJSSignatureHelpItems(ctx, argumentInfo, program, typeChecker) + } return nil } @@ -139,34 +145,49 @@ func (l *LanguageService) GetSignatureHelpItems( if candidateInfo.candidateInfo != nil { return l.createSignatureHelpItems(ctx, candidateInfo.candidateInfo.candidates, candidateInfo.candidateInfo.resolvedSignature, argumentInfo, sourceFile, typeChecker, onlyUseSyntacticOwners) } - return createTypeHelpItems(candidateInfo.typeInfo, argumentInfo, sourceFile, typeChecker) + return createTypeHelpItems(ctx, candidateInfo.typeInfo, argumentInfo, sourceFile, typeChecker) } -func createTypeHelpItems(symbol *ast.Symbol, argumentInfo *argumentListInfo, sourceFile *ast.SourceFile, c *checker.Checker) *lsproto.SignatureHelp { +func createTypeHelpItems(ctx context.Context, symbol *ast.Symbol, argumentInfo *argumentListInfo, sourceFile *ast.SourceFile, c *checker.Checker) *lsproto.SignatureHelp { typeParameters := c.GetLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) if typeParameters == nil { return nil } item := getTypeHelpItem(symbol, typeParameters, getEnclosingDeclarationFromInvocation(argumentInfo.invocation), sourceFile, c) + // Check client capabilities for activeParameter handling + caps := lsproto.GetClientCapabilities(ctx) + sigInfoCaps := caps.TextDocument.SignatureHelp.SignatureInformation + supportsPerSignatureActiveParam := sigInfoCaps.ActiveParameterSupport + // Converting signatureHelpParameter to *lsproto.ParameterInformation parameters := make([]*lsproto.ParameterInformation, len(item.Parameters)) for i, param := range item.Parameters { parameters[i] = param.parameterInfo } - signatureInformation := []*lsproto.SignatureInformation{ - { - Label: item.Label, - Documentation: nil, - Parameters: ¶meters, - }, + + sigInfo := &lsproto.SignatureInformation{ + Label: item.Label, + Documentation: nil, + Parameters: ¶meters, } - return &lsproto.SignatureHelp{ - Signatures: signatureInformation, + // If client supports per-signature activeParameter, set it on SignatureInformation + if supportsPerSignatureActiveParam && len(item.Parameters) > 0 { + sigInfo.ActiveParameter = &lsproto.UintegerOrNull{Uinteger: ptrTo(uint32(argumentInfo.argumentIndex))} + } + + help := &lsproto.SignatureHelp{ + Signatures: []*lsproto.SignatureInformation{sigInfo}, ActiveSignature: ptrTo(uint32(0)), - ActiveParameter: &lsproto.UintegerOrNull{Uinteger: ptrTo(uint32(argumentInfo.argumentIndex))}, } + + // If client doesn't support per-signature activeParameter, set it on the top-level SignatureHelp + if !supportsPerSignatureActiveParam && len(item.Parameters) > 0 { + help.ActiveParameter = &lsproto.UintegerOrNull{Uinteger: ptrTo(uint32(argumentInfo.argumentIndex))} + } + + return help } func getTypeHelpItem(symbol *ast.Symbol, typeParameter []*checker.Type, enclosingDeclaration *ast.Node, sourceFile *ast.SourceFile, c *checker.Checker) signatureInformation { @@ -199,6 +220,60 @@ func getTypeHelpItem(symbol *ast.Symbol, typeParameter []*checker.Type, enclosin } } +// createJSSignatureHelpItems is a fallback for JavaScript files when normal signature help +// doesn't produce results. It searches all source files for declarations with matching names +// that have call signatures. +func (l *LanguageService) createJSSignatureHelpItems(ctx context.Context, argumentInfo *argumentListInfo, program *compiler.Program, c *checker.Checker) *lsproto.SignatureHelp { + if argumentInfo.invocation.contextualInvocation != nil { + return nil + } + // See if we can find some symbol with the call expression name that has call signatures. + expression := getExpressionFromInvocation(argumentInfo) + if !ast.IsPropertyAccessExpression(expression) { + return nil + } + name := expression.AsPropertyAccessExpression().Name().Text() + if name == "" { + return nil + } + + for _, sf := range program.GetSourceFiles() { + result := l.findSignatureHelpFromNamedDeclarations(ctx, sf, name, argumentInfo, c) + if result != nil { + return result + } + } + return nil +} + +func (l *LanguageService) findSignatureHelpFromNamedDeclarations(ctx context.Context, sourceFile *ast.SourceFile, name string, argumentInfo *argumentListInfo, c *checker.Checker) *lsproto.SignatureHelp { + var result *lsproto.SignatureHelp + var visit func(node *ast.Node) bool + visit = func(node *ast.Node) bool { + if result != nil { + return true + } + if ast.GetDeclarationName(node) == name { + if symbol := node.Symbol(); symbol != nil { + if t := c.GetTypeOfSymbolAtLocation(symbol, node); t != nil { + if callSignatures := c.GetCallSignatures(t); len(callSignatures) > 0 { + result = l.createSignatureHelpItems(ctx, callSignatures, callSignatures[0], argumentInfo, sourceFile, c, true /*useFullPrefix*/) + if result != nil { + return true + } + } + } + } + } + node.ForEachChild(func(child *ast.Node) bool { + return visit(child) + }) + return result != nil + } + visit(sourceFile.AsNode()) + return result +} + func (l *LanguageService) createSignatureHelpItems(ctx context.Context, candidates []*checker.Signature, resolvedSignature *checker.Signature, argumentInfo *argumentListInfo, sourceFile *ast.SourceFile, c *checker.Checker, useFullPrefix bool) *lsproto.SignatureHelp { caps := lsproto.GetClientCapabilities(ctx) docFormat := lsproto.PreferredMarkupKind(caps.TextDocument.SignatureHelp.SignatureInformation.DocumentationFormat) @@ -219,7 +294,11 @@ func (l *LanguageService) createSignatureHelpItems(ctx context.Context, candidat var callTargetDisplayParts strings.Builder if callTargetSymbol != nil { - callTargetDisplayParts.WriteString(c.SymbolToString(callTargetSymbol)) + if useFullPrefix { + callTargetDisplayParts.WriteString(c.SymbolToStringEx(callTargetSymbol, sourceFile.AsNode(), ast.SymbolFlagsNone, checker.SymbolFormatFlagsUseAliasDefinedOutsideCurrentScope)) + } else { + callTargetDisplayParts.WriteString(c.SymbolToString(callTargetSymbol)) + } } items := make([][]signatureInformation, len(candidates)) for i, candidateSignature := range candidates { @@ -255,6 +334,11 @@ func (l *LanguageService) createSignatureHelpItems(ctx context.Context, candidat return nil } + // Check client capabilities for activeParameter handling + sigInfoCaps := caps.TextDocument.SignatureHelp.SignatureInformation + supportsPerSignatureActiveParam := sigInfoCaps.ActiveParameterSupport + supportsNullActiveParam := sigInfoCaps.NoActiveParameterSupport + // Converting []signatureInformation to []*lsproto.SignatureInformation signatureInformation := make([]*lsproto.SignatureInformation, len(flattenedSignatures)) for i, item := range flattenedSignatures { @@ -271,33 +355,64 @@ func (l *LanguageService) createSignatureHelpItems(ctx context.Context, candidat }, } } - signatureInformation[i] = &lsproto.SignatureInformation{ + sigInfo := &lsproto.SignatureInformation{ Label: item.Label, Documentation: documentation, Parameters: ¶meters, } + + // If client supports per-signature activeParameter, set it on each SignatureInformation + if supportsPerSignatureActiveParam { + sigInfo.ActiveParameter = l.computeActiveParameter(item, argumentInfo.argumentIndex, supportsNullActiveParam) + } + + signatureInformation[i] = sigInfo } help := &lsproto.SignatureHelp{ Signatures: signatureInformation, ActiveSignature: ptrTo(uint32(selectedItemIndex)), - ActiveParameter: &lsproto.UintegerOrNull{Uinteger: ptrTo(uint32(argumentInfo.argumentIndex))}, } - activeSignature := flattenedSignatures[selectedItemIndex] - if activeSignature.IsVariadic { - firstRest := core.FindIndex(activeSignature.Parameters, func(p signatureHelpParameter) bool { + // If client doesn't support per-signature activeParameter, set it on the top-level SignatureHelp + if !supportsPerSignatureActiveParam { + activeSignature := flattenedSignatures[selectedItemIndex] + help.ActiveParameter = l.computeActiveParameter(activeSignature, argumentInfo.argumentIndex, supportsNullActiveParam) + } + + return help +} + +// computeActiveParameter calculates the active parameter index for a signature, +// handling variadic signatures and null support appropriately. +func (l *LanguageService) computeActiveParameter(sig signatureInformation, argumentIndex int, supportsNull bool) *lsproto.UintegerOrNull { + paramCount := len(sig.Parameters) + if paramCount == 0 { + // No parameters, return nil (omit the field) + return nil + } + + activeParam := uint32(argumentIndex) + + if sig.IsVariadic { + firstRest := core.FindIndex(sig.Parameters, func(p signatureHelpParameter) bool { return p.isRest }) - if -1 < firstRest && firstRest < len(activeSignature.Parameters)-1 { - // We don't have any code to get this correct; instead, don't highlight a current parameter AT ALL - help.ActiveParameter = &lsproto.UintegerOrNull{Uinteger: ptrTo(uint32(len(activeSignature.Parameters)))} + if -1 < firstRest && firstRest < paramCount-1 { + // Middle rest parameter - we can't accurately highlight, so indicate "no active parameter" + if supportsNull { + return &lsproto.UintegerOrNull{} // null means "no parameter is active" + } + // Client doesn't support null, use out-of-range index (defaults to 0 per LSP spec) + return &lsproto.UintegerOrNull{Uinteger: ptrTo(uint32(paramCount))} } - if help.ActiveParameter != nil && help.ActiveParameter.Uinteger != nil && *help.ActiveParameter.Uinteger > uint32(len(activeSignature.Parameters)-1) { - help.ActiveParameter = &lsproto.UintegerOrNull{Uinteger: ptrTo(uint32(len(activeSignature.Parameters) - 1))} + // Clamp to last parameter for trailing rest parameters + if activeParam > uint32(paramCount-1) { + activeParam = uint32(paramCount - 1) } } - return help + + return &lsproto.UintegerOrNull{Uinteger: ptrTo(activeParam)} } func (l *LanguageService) getSignatureHelpItem(candidate *checker.Signature, isTypeParameterList bool, callTargetSymbol string, enclosingDeclaration *ast.Node, sourceFile *ast.SourceFile, c *checker.Checker, docFormat lsproto.MarkupKind) []signatureInformation { @@ -556,6 +671,9 @@ func getCandidateOrTypeInfo(info *argumentListInfo, c *checker.Checker, sourceFi return nil } resolvedSignature, candidates := checker.GetResolvedSignatureForSignatureHelp(info.invocation.callInvocation.node, info.argumentCount, c) + if len(candidates) == 0 { + return nil + } return &CandidateOrTypeInfo{ candidateInfo: &candidateInfo{ candidates: candidates, @@ -598,7 +716,7 @@ func getCandidateOrTypeInfo(info *argumentListInfo, c *checker.Checker, sourceFi return nil } -func isSyntacticOwner(startingToken *ast.Node, node *ast.CallLikeExpression, sourceFile *ast.SourceFile) bool { // !!! not tested +func isSyntacticOwner(startingToken *ast.Node, node *ast.CallLikeExpression, sourceFile *ast.SourceFile) bool { if !ast.IsCallOrNewExpression(node) { return false } @@ -622,13 +740,12 @@ func containsPrecedingToken(startingToken *ast.Node, sourceFile *ast.SourceFile, // multiple nested levels. currentParent := startingToken.Parent for currentParent != nil { - precedingToken := astnav.FindPrecedingToken(sourceFile, pos) + precedingToken := astnav.FindPrecedingTokenEx(sourceFile, pos, currentParent, true /*excludeJSDoc*/) if precedingToken != nil { return RangeContainsRange(container.Loc, precedingToken.Loc) } currentParent = currentParent.Parent } - // return Debug.fail("Could not find preceding token"); return false } @@ -966,7 +1083,7 @@ func getArgumentOrParameterListAndIndex(node *ast.Node, sourceFile *ast.SourceFi } } -func getChildListThatStartsWithOpenerToken(parent *ast.Node, openerToken *ast.Node) *ast.NodeList { //!!! +func getChildListThatStartsWithOpenerToken(parent *ast.Node, openerToken *ast.Node) *ast.NodeList { if ast.IsCallExpression(parent) { parentCallExpression := parent.AsCallExpression() if openerToken.Kind == ast.KindLessThanToken { diff --git a/testdata/baselines/reference/fourslash/signatureHelp/jsDocDontBreakWithNamespaces.baseline b/testdata/baselines/reference/fourslash/signatureHelp/jsDocDontBreakWithNamespaces.baseline index 8ccdf99070..09879cb552 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/jsDocDontBreakWithNamespaces.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/jsDocDontBreakWithNamespaces.baseline @@ -53,8 +53,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -74,8 +73,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -95,8 +93,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures5.baseline b/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures5.baseline index 57f7193a17..f79cc4afea 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures5.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures5.baseline @@ -64,11 +64,11 @@ { "label": "options: Object" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures6.baseline b/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures6.baseline index 490770f2a3..742ccccb85 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures6.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures6.baseline @@ -108,11 +108,11 @@ { "label": "p4?: string" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -146,11 +146,11 @@ { "label": "p4?: string" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -184,11 +184,11 @@ { "label": "p4?: string" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } }, { @@ -222,11 +222,11 @@ { "label": "p4?: string" } - ] + ], + "activeParameter": 3 } ], - "activeSignature": 0, - "activeParameter": 3 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/jsdocReturnsTag.baseline b/testdata/baselines/reference/fourslash/signatureHelp/jsdocReturnsTag.baseline index 09b671b368..4551f8a9c3 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/jsdocReturnsTag.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/jsdocReturnsTag.baseline @@ -50,11 +50,11 @@ { "label": "x: unknown" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTags13.baseline b/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTags13.baseline index 18ca3b5576..e67cb9cd3e 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTags13.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTags13.baseline @@ -49,7 +49,8 @@ { "label": "a: number" } - ] + ], + "activeParameter": 0 }, { "label": "f(a: string): void", @@ -57,11 +58,11 @@ { "label": "a: string" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -82,7 +83,8 @@ { "label": "a: number" } - ] + ], + "activeParameter": 0 }, { "label": "f(a: string): void", @@ -90,11 +92,11 @@ { "label": "a: string" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 1, - "activeParameter": 0 + "activeSignature": 1 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTextFormatting1.baseline b/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTextFormatting1.baseline index aa84850695..73e4be6afc 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTextFormatting1.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTextFormatting1.baseline @@ -122,11 +122,11 @@ { "label": "var2: any" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -154,11 +154,11 @@ { "label": "var2: any" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -186,11 +186,11 @@ { "label": "var2: any" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -218,11 +218,11 @@ { "label": "var2: any" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -250,11 +250,11 @@ { "label": "var2: any" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAfterParameter.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAfterParameter.baseline index 8049e26f53..1af28b1468 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAfterParameter.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAfterParameter.baseline @@ -77,11 +77,11 @@ { "label": "c: any" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -108,11 +108,11 @@ { "label": "c: any" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -139,11 +139,11 @@ { "label": "c: any" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -170,11 +170,11 @@ { "label": "c: any" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -201,11 +201,11 @@ { "label": "c: any" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -232,11 +232,11 @@ { "label": "c: any" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -263,11 +263,11 @@ { "label": "c: any" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -294,11 +294,11 @@ { "label": "c: any" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -325,11 +325,11 @@ { "label": "c: any" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -356,11 +356,11 @@ { "label": "c: any" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -387,11 +387,11 @@ { "label": "c: any" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } }, { @@ -418,11 +418,11 @@ { "label": "c: any" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClass.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClass.baseline index eee615b3a5..5ffa2a7a6a 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClass.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClass.baseline @@ -106,8 +106,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -131,8 +130,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -156,8 +154,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -177,8 +174,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -202,8 +198,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -228,11 +223,11 @@ { "label": "a: string" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassMembers.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassMembers.baseline index d6c43e6b24..e460d9a510 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassMembers.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassMembers.baseline @@ -231,11 +231,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -260,11 +260,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -289,11 +289,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -318,11 +318,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -347,11 +347,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -376,11 +376,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -401,11 +401,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -426,11 +426,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -451,11 +451,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -476,11 +476,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -501,11 +501,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -526,11 +526,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -554,8 +554,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -580,11 +579,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -605,11 +604,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -634,11 +633,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -659,11 +658,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsCommentParsing.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsCommentParsing.baseline index f9f951a722..f00c5fc84b 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsCommentParsing.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsCommentParsing.baseline @@ -750,8 +750,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -771,8 +770,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -796,8 +794,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -821,8 +818,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -846,8 +842,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -871,8 +866,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -896,8 +890,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -921,8 +914,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -946,8 +938,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -971,8 +962,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -996,8 +986,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -1017,8 +1006,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -1038,8 +1026,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -1059,8 +1046,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -1088,11 +1074,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -1120,11 +1106,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -1161,11 +1147,11 @@ { "label": "e?: any" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -1202,11 +1188,11 @@ { "label": "e?: any" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -1243,11 +1229,11 @@ { "label": "e?: any" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } }, { @@ -1284,11 +1270,11 @@ { "label": "e?: any" } - ] + ], + "activeParameter": 3 } ], - "activeSignature": 0, - "activeParameter": 3 + "activeSignature": 0 } }, { @@ -1325,11 +1311,11 @@ { "label": "e?: any" } - ] + ], + "activeParameter": 4 } ], - "activeSignature": 0, - "activeParameter": 4 + "activeSignature": 0 } }, { @@ -1354,7 +1340,8 @@ { "label": "a: number" } - ] + ], + "activeParameter": 0 }, { "label": "f1(b: string): any", @@ -1362,11 +1349,11 @@ { "label": "b: string" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -1391,7 +1378,8 @@ { "label": "a: number" } - ] + ], + "activeParameter": 0 }, { "label": "f1(b: string): any", @@ -1399,11 +1387,11 @@ { "label": "b: string" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 1, - "activeParameter": 0 + "activeSignature": 1 } }, { @@ -1443,11 +1431,11 @@ { "label": "f?: () => string" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -1487,11 +1475,11 @@ { "label": "f?: () => string" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -1531,11 +1519,11 @@ { "label": "f?: () => string" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } }, { @@ -1575,11 +1563,11 @@ { "label": "f?: () => string" } - ] + ], + "activeParameter": 3 } ], - "activeSignature": 0, - "activeParameter": 3 + "activeSignature": 0 } }, { @@ -1619,11 +1607,11 @@ { "label": "f?: () => string" } - ] + ], + "activeParameter": 4 } ], - "activeSignature": 0, - "activeParameter": 4 + "activeSignature": 0 } }, { @@ -1663,11 +1651,11 @@ { "label": "f?: () => string" } - ] + ], + "activeParameter": 5 } ], - "activeSignature": 0, - "activeParameter": 5 + "activeSignature": 0 } }, { @@ -1692,11 +1680,11 @@ { "label": "a: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -1724,11 +1712,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -1756,11 +1744,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -1788,11 +1776,11 @@ { "label": "bar: string" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -1820,11 +1808,11 @@ { "label": "bar: string" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -1870,11 +1858,11 @@ { "label": "d: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -1908,11 +1896,11 @@ { "label": "d: number" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -1946,11 +1934,11 @@ { "label": "d: number" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } }, { @@ -1984,11 +1972,11 @@ { "label": "d: number" } - ] + ], + "activeParameter": 3 } ], - "activeSignature": 0, - "activeParameter": 3 + "activeSignature": 0 } }, { @@ -2012,8 +2000,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -2037,8 +2024,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -2069,11 +2055,11 @@ { "label": "c: any" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -2104,11 +2090,11 @@ { "label": "c: any" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -2139,11 +2125,11 @@ { "label": "c: any" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } }, { diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionDeclaration.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionDeclaration.baseline index 9379624b79..66ecad0c6f 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionDeclaration.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionDeclaration.baseline @@ -62,8 +62,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -91,11 +90,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -123,11 +122,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -152,11 +151,11 @@ { "label": "a: string" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionExpression.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionExpression.baseline index 909f65f09e..9d140cdd06 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionExpression.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionExpression.baseline @@ -73,11 +73,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -105,11 +105,11 @@ { "label": "b: number" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -134,11 +134,11 @@ { "label": "s: string" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpConstructorCallParamProperties.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpConstructorCallParamProperties.baseline index 1250243a32..09d5ad8e9a 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpConstructorCallParamProperties.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpConstructorCallParamProperties.baseline @@ -40,11 +40,11 @@ { "label": "radius: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpExpandedRestTuplesLocalLabels1.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpExpandedRestTuplesLocalLabels1.baseline index 5ed475ad94..c0c73da4e3 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpExpandedRestTuplesLocalLabels1.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpExpandedRestTuplesLocalLabels1.baseline @@ -197,7 +197,8 @@ { "label": "info: AppleInfo" } - ] + ], + "activeParameter": 0 }, { "label": "logFruitTuple1(fruit: \"banana\", info: BananaInfo): void", @@ -208,11 +209,11 @@ { "label": "info: BananaInfo" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -236,7 +237,8 @@ { "label": "info: AppleInfo" } - ] + ], + "activeParameter": 0 }, { "label": "logFruitTuple2(arg_0: \"banana\", info: BananaInfo): void", @@ -247,11 +249,11 @@ { "label": "info: BananaInfo" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -275,7 +277,8 @@ { "label": "info: AppleInfo" } - ] + ], + "activeParameter": 1 }, { "label": "logFruitTuple2(arg_0: \"banana\", info: BananaInfo): void", @@ -286,11 +289,11 @@ { "label": "info: BananaInfo" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -314,7 +317,8 @@ { "label": "rest_0: AppleInfo" } - ] + ], + "activeParameter": 0 }, { "label": "logFruitTuple3(fruit: \"banana\", rest_0: BananaInfo): void", @@ -325,11 +329,11 @@ { "label": "rest_0: BananaInfo" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -353,7 +357,8 @@ { "label": "rest_0: AppleInfo" } - ] + ], + "activeParameter": 1 }, { "label": "logFruitTuple3(fruit: \"banana\", rest_0: BananaInfo): void", @@ -364,11 +369,11 @@ { "label": "rest_0: BananaInfo" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -392,7 +397,8 @@ { "label": "info: AppleInfo" } - ] + ], + "activeParameter": 0 }, { "label": "logFruitTuple4(fruit: \"banana\", info: BananaInfo): void", @@ -403,11 +409,11 @@ { "label": "info: BananaInfo" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -431,7 +437,8 @@ { "label": "info: AppleInfo" } - ] + ], + "activeParameter": 1 }, { "label": "logFruitTuple4(fruit: \"banana\", info: BananaInfo): void", @@ -442,11 +449,11 @@ { "label": "info: BananaInfo" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -470,7 +477,8 @@ { "label": "...firstInfo_n: AppleInfo[]" } - ] + ], + "activeParameter": 0 }, { "label": "logFruitTuple5(fruit: \"banana\", ...firstInfo_n: BananaInfo[]): void", @@ -481,11 +489,11 @@ { "label": "...firstInfo_n: BananaInfo[]" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -509,7 +517,8 @@ { "label": "...firstInfo_n: AppleInfo[]" } - ] + ], + "activeParameter": 1 }, { "label": "logFruitTuple5(fruit: \"banana\", ...firstInfo_n: BananaInfo[]): void", @@ -520,11 +529,11 @@ { "label": "...firstInfo_n: BananaInfo[]" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -548,7 +557,8 @@ { "label": "...fruitInfo: AppleInfo[]" } - ] + ], + "activeParameter": 0 }, { "label": "logFruitTuple6(fruit: \"banana\", ...fruitInfo: BananaInfo[]): void", @@ -559,11 +569,11 @@ { "label": "...fruitInfo: BananaInfo[]" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -587,7 +597,8 @@ { "label": "...fruitInfo: AppleInfo[]" } - ] + ], + "activeParameter": 1 }, { "label": "logFruitTuple6(fruit: \"banana\", ...fruitInfo: BananaInfo[]): void", @@ -598,11 +609,11 @@ { "label": "...fruitInfo: BananaInfo[]" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -629,7 +640,8 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 0 }, { "label": "logFruitTuple7(fruit: \"banana\", ...fruitInfoOrNumber_n: BananaInfo[], secondFruitInfoOrNumber: number): void", @@ -643,11 +655,11 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -674,7 +686,8 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 1 }, { "label": "logFruitTuple7(fruit: \"banana\", ...fruitInfoOrNumber_n: BananaInfo[], secondFruitInfoOrNumber: number): void", @@ -688,11 +701,11 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -719,7 +732,8 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 2 }, { "label": "logFruitTuple7(fruit: \"banana\", ...fruitInfoOrNumber_n: BananaInfo[], secondFruitInfoOrNumber: number): void", @@ -733,11 +747,11 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } }, { @@ -764,7 +778,8 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 0 }, { "label": "logFruitTuple8(fruit: \"banana\", ...arg_1: BananaInfo[], secondFruitInfoOrNumber: number): void", @@ -778,11 +793,11 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -809,7 +824,8 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 1 }, { "label": "logFruitTuple8(fruit: \"banana\", ...arg_1: BananaInfo[], secondFruitInfoOrNumber: number): void", @@ -823,11 +839,11 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -854,7 +870,8 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 2 }, { "label": "logFruitTuple8(fruit: \"banana\", ...arg_1: BananaInfo[], secondFruitInfoOrNumber: number): void", @@ -868,11 +885,11 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } }, { @@ -899,7 +916,8 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 0 }, { "label": "logFruitTuple9(fruit: \"banana\", ...fruitInfoOrNumber_n: BananaInfo[], secondFruitInfoOrNumber: number): void", @@ -913,11 +931,11 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -944,7 +962,8 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 1 }, { "label": "logFruitTuple9(fruit: \"banana\", ...fruitInfoOrNumber_n: BananaInfo[], secondFruitInfoOrNumber: number): void", @@ -958,11 +977,11 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -989,7 +1008,8 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 2 }, { "label": "logFruitTuple9(fruit: \"banana\", ...fruitInfoOrNumber_n: BananaInfo[], secondFruitInfoOrNumber: number): void", @@ -1003,11 +1023,11 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } }, { @@ -1034,7 +1054,8 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 0 }, { "label": "logFruitTuple10(fruit: \"banana\", ...arg_1: BananaInfo[], secondFruitInfoOrNumber: number): void", @@ -1048,11 +1069,11 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -1079,7 +1100,8 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 1 }, { "label": "logFruitTuple10(fruit: \"banana\", ...arg_1: BananaInfo[], secondFruitInfoOrNumber: number): void", @@ -1093,11 +1115,11 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -1124,7 +1146,8 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 2 }, { "label": "logFruitTuple10(fruit: \"banana\", ...arg_1: BananaInfo[], secondFruitInfoOrNumber: number): void", @@ -1138,11 +1161,11 @@ { "label": "secondFruitInfoOrNumber: number" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } }, { @@ -1169,7 +1192,8 @@ { "label": "arg_2: number" } - ] + ], + "activeParameter": 0 }, { "label": "logFruitTuple11(arg_0: \"banana\", ...arg_1: BananaInfo[], arg_2: number): void", @@ -1183,11 +1207,11 @@ { "label": "arg_2: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -1214,7 +1238,8 @@ { "label": "arg_2: number" } - ] + ], + "activeParameter": 1 }, { "label": "logFruitTuple11(arg_0: \"banana\", ...arg_1: BananaInfo[], arg_2: number): void", @@ -1228,11 +1253,11 @@ { "label": "arg_2: number" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -1259,7 +1284,8 @@ { "label": "arg_2: number" } - ] + ], + "activeParameter": 2 }, { "label": "logFruitTuple11(arg_0: \"banana\", ...arg_1: BananaInfo[], arg_2: number): void", @@ -1273,11 +1299,11 @@ { "label": "arg_2: number" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } }, { @@ -1301,11 +1327,11 @@ { "label": "named: string" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -1329,11 +1355,11 @@ { "label": "named: string" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpInferenceJsDocImportTag.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpInferenceJsDocImportTag.baseline new file mode 100644 index 0000000000..a3c8672f13 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpInferenceJsDocImportTag.baseline @@ -0,0 +1,51 @@ +// === SignatureHelp === +=== /b.js === +// /** +// * @import { +// * Foo +// * } from './a' +// */ +// +// /** +// * @param {Foo} a +// */ +// function foo(a) {} +// foo() +// ^ +// | ---------------------------------------------------------------------- +// | foo(**a: Foo**): void +// | +// | +// | *@param* `a` +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 98, + "LSPosition": { + "line": 10, + "character": 4 + }, + "Name": "", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "foo(a: Foo): void", + "documentation": { + "kind": "markdown", + "value": "\n\n*@param* `a`" + }, + "parameters": [ + { + "label": "a: Foo" + } + ], + "activeParameter": 0 + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpIteratorNext.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpIteratorNext.baseline index e20d663b33..519fc4bfaa 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpIteratorNext.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpIteratorNext.baseline @@ -74,11 +74,11 @@ { "label": "value: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -103,11 +103,11 @@ { "label": "value: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 1, - "activeParameter": 0 + "activeSignature": 1 } }, { @@ -132,11 +132,11 @@ { "label": "value: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -161,11 +161,11 @@ { "label": "value: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 1, - "activeParameter": 0 + "activeSignature": 1 } }, { @@ -190,11 +190,11 @@ { "label": "value: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -219,11 +219,11 @@ { "label": "value: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 1, - "activeParameter": 0 + "activeSignature": 1 } }, { @@ -248,11 +248,11 @@ { "label": "value: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -277,11 +277,11 @@ { "label": "value: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 1, - "activeParameter": 0 + "activeSignature": 1 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocCallbackTag.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocCallbackTag.baseline index d9d476bfcb..4b8bdc8fec 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocCallbackTag.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocCallbackTag.baseline @@ -59,11 +59,11 @@ { "label": "eventName3: any" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -90,11 +90,11 @@ { "label": "eventName3: any" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -121,11 +121,11 @@ { "label": "eventName3: any" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocTags.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocTags.baseline index 58c8b36f34..c8f35b8fdb 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocTags.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocTags.baseline @@ -112,11 +112,11 @@ { "label": "value: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -140,8 +140,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -165,8 +164,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -190,8 +188,7 @@ "parameters": [] } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSMissingPropertyAccess.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSMissingPropertyAccess.baseline index 3ef7b0bf7a..ba9dac6dbd 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSMissingPropertyAccess.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSMissingPropertyAccess.baseline @@ -3,7 +3,14 @@ // foo.filter() // ^ // | ---------------------------------------------------------------------- -// | No signaturehelp at /**/. +// | ReadonlyArray.filter(**predicate: (value: T, index: number, array: readonly T[]) => value is S**, thisArg?: any): S[] +// | Returns the elements of an array that meet the condition specified in a callback function. +// | +// | *@param* `predicate` — A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array. +// | +// | +// | *@param* `thisArg` — An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value. +// | // | ---------------------------------------------------------------------- [ { @@ -16,6 +23,42 @@ "Name": "", "Data": {} }, - "item": null + "item": { + "signatures": [ + { + "label": "ReadonlyArray.filter(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S[]", + "documentation": { + "kind": "markdown", + "value": "Returns the elements of an array that meet the condition specified in a callback function.\n\n*@param* `predicate` — A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.\n\n\n*@param* `thisArg` — An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.\n" + }, + "parameters": [ + { + "label": "predicate: (value: T, index: number, array: readonly T[]) => value is S" + }, + { + "label": "thisArg?: any" + } + ], + "activeParameter": 0 + }, + { + "label": "ReadonlyArray.filter(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T[]", + "documentation": { + "kind": "markdown", + "value": "Returns the elements of an array that meet the condition specified in a callback function.\n\n*@param* `predicate` — A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.\n\n\n*@param* `thisArg` — An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.\n" + }, + "parameters": [ + { + "label": "predicate: (value: T, index: number, array: readonly T[]) => unknown" + }, + { + "label": "thisArg?: any" + } + ], + "activeParameter": 0 + } + ], + "activeSignature": 0 + } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs1.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs1.baseline index 4dd6dc8b41..0051b268f5 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs1.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs1.baseline @@ -54,11 +54,11 @@ { "label": "c: number" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } }, { @@ -85,11 +85,11 @@ { "label": "c: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -116,11 +116,11 @@ { "label": "c: number" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -147,11 +147,11 @@ { "label": "c: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -178,11 +178,11 @@ { "label": "c: number" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs2.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs2.baseline index 42f95f62b8..78c6b7c1f1 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs2.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs2.baseline @@ -7,7 +7,14 @@ // fn.call(thisArg, ...arguments, ); // ^ // | ---------------------------------------------------------------------- -// | No signaturehelp at /*1*/. +// | Function.call(thisArg: any, **...argArray: any[]**): any +// | Calls a method of an object, substituting another object for the current object. +// | +// | *@param* `thisArg` — The object to be used as the current object. +// | +// | +// | *@param* `argArray` — A list of arguments to be passed to the method. +// | // | ---------------------------------------------------------------------- // }); // }; @@ -23,6 +30,26 @@ "Name": "1", "Data": {} }, - "item": null + "item": { + "signatures": [ + { + "label": "Function.call(thisArg: any, ...argArray: any[]): any", + "documentation": { + "kind": "markdown", + "value": "Calls a method of an object, substituting another object for the current object.\n\n*@param* `thisArg` — The object to be used as the current object.\n\n\n*@param* `argArray` — A list of arguments to be passed to the method.\n" + }, + "parameters": [ + { + "label": "thisArg: any" + }, + { + "label": "...argArray: any[]" + } + ], + "activeParameter": 1 + } + ], + "activeSignature": 0 + } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs3.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs3.baseline index 0bfd6e0bd5..07690179ef 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs3.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs3.baseline @@ -39,7 +39,8 @@ { "label": "source: U" } - ] + ], + "activeParameter": 1 }, { "label": "assign(target: T, source1: U, source2: V): T & U & V", @@ -57,7 +58,8 @@ { "label": "source2: V" } - ] + ], + "activeParameter": 1 }, { "label": "assign(target: T, source1: U, source2: V, source3: W): T & U & V & W", @@ -78,7 +80,8 @@ { "label": "source3: W" } - ] + ], + "activeParameter": 1 }, { "label": "assign(target: object, ...sources: any[]): any", @@ -93,11 +96,11 @@ { "label": "...sources: any[]" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 3, - "activeParameter": 1 + "activeSignature": 3 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpSkippedArgs1.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpSkippedArgs1.baseline index 72b1c36645..e100bb616e 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpSkippedArgs1.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpSkippedArgs1.baseline @@ -47,11 +47,11 @@ { "label": "c: number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -78,11 +78,11 @@ { "label": "c: number" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -109,11 +109,11 @@ { "label": "c: number" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } }, { @@ -140,11 +140,11 @@ { "label": "c: number" } - ] + ], + "activeParameter": 3 } ], - "activeSignature": 0, - "activeParameter": 3 + "activeSignature": 0 } }, { @@ -171,11 +171,11 @@ { "label": "c: number" } - ] + ], + "activeParameter": 4 } ], - "activeSignature": 0, - "activeParameter": 4 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpTypeArguments2.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpTypeArguments2.baseline index 04519d87b3..8fded6dda1 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpTypeArguments2.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpTypeArguments2.baseline @@ -120,11 +120,11 @@ { "label": "W" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -158,11 +158,11 @@ { "label": "W" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } }, { @@ -196,11 +196,11 @@ { "label": "W" } - ] + ], + "activeParameter": 2 } ], - "activeSignature": 0, - "activeParameter": 2 + "activeSignature": 0 } }, { @@ -234,11 +234,11 @@ { "label": "W" } - ] + ], + "activeParameter": 3 } ], - "activeSignature": 0, - "activeParameter": 3 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpWithUnknown.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpWithUnknown.baseline index 3bc1d52dab..fb0b57ecb9 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpWithUnknown.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpWithUnknown.baseline @@ -32,11 +32,11 @@ { "label": "x: string" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelp_unionType.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelp_unionType.baseline index dfd2d40524..de46967af3 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelp_unionType.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelp_unionType.baseline @@ -47,11 +47,11 @@ { "label": "fn?: ((x: string) => string) | ((y: number) => number)" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -72,11 +72,11 @@ { "label": "x: string | number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } }, { @@ -97,11 +97,11 @@ { "label": "x: string | number" } - ] + ], + "activeParameter": 0 } ], - "activeSignature": 0, - "activeParameter": 0 + "activeSignature": 0 } } ] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/trailingCommaSignatureHelp.baseline b/testdata/baselines/reference/fourslash/signatureHelp/trailingCommaSignatureHelp.baseline index a605b34030..543be1ccc4 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/trailingCommaSignatureHelp.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/trailingCommaSignatureHelp.baseline @@ -43,7 +43,8 @@ { "label": "n: number" } - ] + ], + "activeParameter": 1 }, { "label": "str(n: number, radix: number): string", @@ -58,11 +59,11 @@ { "label": "radix: number" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 1, - "activeParameter": 1 + "activeSignature": 1 } }, { @@ -83,11 +84,11 @@ { "label": "a: 2" } - ] + ], + "activeParameter": 1 } ], - "activeSignature": 0, - "activeParameter": 1 + "activeSignature": 0 } } ] \ No newline at end of file