diff --git a/internal/fourslash/_scripts/convertFourslash.mts b/internal/fourslash/_scripts/convertFourslash.mts index 0b461efff6..534b7d69c7 100644 --- a/internal/fourslash/_scripts/convertFourslash.mts +++ b/internal/fourslash/_scripts/convertFourslash.mts @@ -186,11 +186,14 @@ function parseFourslashStatement(statement: ts.Statement): Cmd[] | undefined { return [parseBaselineSignatureHelp(callExpression.arguments)]; case "baselineGoToDefinition": case "baselineGetDefinitionAtPosition": - // Both of these take the same arguments, but differ in that... + case "baselineGoToType": + // Both `baselineGoToDefinition` and `baselineGetDefinitionAtPosition` take the same + // arguments, but differ in that... // - `verify.baselineGoToDefinition(...)` called getDefinitionAndBoundSpan // - `verify.baselineGetDefinitionAtPosition(...)` called getDefinitionAtPosition - // LSP doesn't have two separate commands though. It's unclear how we would model bound spans though. - return parseBaselineGoToDefinitionArgs(callExpression.arguments); + // LSP doesn't have two separate commands though. + // It's unclear how we would model bound spans though. + return parseBaselineGoToDefinitionArgs(func.text, callExpression.arguments); case "baselineRename": case "baselineRenameAtRangesWithText": // `verify.baselineRename...(...)` @@ -817,7 +820,20 @@ function parseBaselineDocumentHighlightsArgs(args: readonly ts.Expression[]): [V }]; } -function parseBaselineGoToDefinitionArgs(args: readonly ts.Expression[]): [VerifyBaselineGoToDefinitionCmd] | undefined { +function parseBaselineGoToDefinitionArgs( + funcName: "baselineGoToDefinition" | "baselineGoToType" | "baselineGetDefinitionAtPosition", + args: readonly ts.Expression[], +): [VerifyBaselineGoToDefinitionCmd] | undefined { + let kind: "verifyBaselineGoToDefinition" | "verifyBaselineGoToType"; + switch (funcName) { + case "baselineGoToDefinition": + case "baselineGetDefinitionAtPosition": + kind = "verifyBaselineGoToDefinition"; + break; + case "baselineGoToType": + kind = "verifyBaselineGoToType"; + break; + } const newArgs = []; for (const arg of args) { let strArg; @@ -829,19 +845,19 @@ function parseBaselineGoToDefinitionArgs(args: readonly ts.Expression[]): [Verif } else if (arg.getText() === "...test.ranges()") { return [{ - kind: "verifyBaselineGoToDefinition", + kind, markers: [], ranges: true, }]; } else { - console.error(`Unrecognized argument in verify.baselineGoToDefinition: ${arg.getText()}`); + console.error(`Unrecognized argument in verify.${funcName}: ${arg.getText()}`); return undefined; } } return [{ - kind: "verifyBaselineGoToDefinition", + kind, markers: newArgs, }]; } @@ -1293,7 +1309,7 @@ interface VerifyBaselineFindAllReferencesCmd { } interface VerifyBaselineGoToDefinitionCmd { - kind: "verifyBaselineGoToDefinition"; + kind: "verifyBaselineGoToDefinition" | "verifyBaselineGoToType"; markers: string[]; ranges?: boolean; } @@ -1393,11 +1409,20 @@ function generateBaselineDocumentHighlights({ args, preferences }: VerifyBaselin return `f.VerifyBaselineDocumentHighlights(t, ${preferences}, ${args.join(", ")})`; } -function generateBaselineGoToDefinition({ markers, ranges }: VerifyBaselineGoToDefinitionCmd): string { +function generateBaselineGoToDefinition({ markers, ranges, kind }: VerifyBaselineGoToDefinitionCmd): string { + let goFunc; + switch (kind) { + case "verifyBaselineGoToDefinition": + goFunc = "VerifyBaselineGoToDefinition"; + break; + case "verifyBaselineGoToType": + goFunc = "VerifyBaselineGoToTypeDefinition"; + break; + } if (ranges || markers.length === 0) { - return `f.VerifyBaselineGoToDefinition(t)`; + return `f.${goFunc}(t)`; } - return `f.VerifyBaselineGoToDefinition(t, ${markers.join(", ")})`; + return `f.${goFunc}(t, ${markers.join(", ")})`; } function generateGoToCommand({ funcName, args }: GoToCmd): string { @@ -1436,6 +1461,7 @@ function generateCmd(cmd: Cmd): string { case "verifyBaselineDocumentHighlights": return generateBaselineDocumentHighlights(cmd); case "verifyBaselineGoToDefinition": + case "verifyBaselineGoToType": return generateBaselineGoToDefinition(cmd); case "verifyBaselineQuickInfo": // Quick Info -> Hover diff --git a/internal/fourslash/_scripts/failingTests.txt b/internal/fourslash/_scripts/failingTests.txt index a3851e759e..3aef9a7a9f 100644 --- a/internal/fourslash/_scripts/failingTests.txt +++ b/internal/fourslash/_scripts/failingTests.txt @@ -245,6 +245,7 @@ TestJsDocPropertyDescription6 TestJsDocPropertyDescription7 TestJsDocPropertyDescription8 TestJsDocPropertyDescription9 +TestJsDocServices TestJsDocTagsWithHyphen TestJsQuickInfoGenerallyAcceptableSize TestJsRequireQuickInfo diff --git a/internal/fourslash/fourslash.go b/internal/fourslash/fourslash.go index a488f7d2c5..8c64ea2f90 100644 --- a/internal/fourslash/fourslash.go +++ b/internal/fourslash/fourslash.go @@ -852,6 +852,55 @@ func (f *FourslashTest) VerifyBaselineGoToDefinition( } } +func (f *FourslashTest) VerifyBaselineGoToTypeDefinition( + t *testing.T, + markers ...string, +) { + referenceLocations := f.lookupMarkersOrGetRanges(t, markers) + + for _, markerOrRange := range referenceLocations { + // worker in `baselineEachMarkerOrRange` + f.GoToMarkerOrRange(t, markerOrRange) + + params := &lsproto.TypeDefinitionParams{ + TextDocument: lsproto.TextDocumentIdentifier{ + Uri: ls.FileNameToDocumentURI(f.activeFilename), + }, + Position: f.currentCaretPosition, + } + + resMsg, result, resultOk := sendRequest(t, f, lsproto.TextDocumentTypeDefinitionInfo, params) + if resMsg == nil { + if f.lastKnownMarkerName == nil { + t.Fatalf("Nil response received for type definition request at pos %v", f.currentCaretPosition) + } else { + t.Fatalf("Nil response received for type definition request at marker '%s'", *f.lastKnownMarkerName) + } + } + if !resultOk { + if f.lastKnownMarkerName == nil { + t.Fatalf("Unexpected type definition response type at pos %v: %T", f.currentCaretPosition, resMsg.AsResponse().Result) + } else { + t.Fatalf("Unexpected type definition response type at marker '%s': %T", *f.lastKnownMarkerName, resMsg.AsResponse().Result) + } + } + + var resultAsLocations []lsproto.Location + if result.Locations != nil { + resultAsLocations = *result.Locations + } else if result.Location != nil { + resultAsLocations = []lsproto.Location{*result.Location} + } else if result.DefinitionLinks != nil { + t.Fatalf("Unexpected type definition response type at marker '%s': %T", *f.lastKnownMarkerName, result.DefinitionLinks) + } + + f.addResultToBaseline(t, "goToType", f.getBaselineForLocationsWithFileContents(resultAsLocations, baselineFourslashLocationsOptions{ + marker: markerOrRange, + markerName: "/*GOTO TYPE*/", + })) + } +} + func (f *FourslashTest) VerifyBaselineHover(t *testing.T) { markersAndItems := core.MapFiltered(f.Markers(), func(marker *Marker) (markerAndItem[*lsproto.Hover], bool) { if marker.Name == nil { diff --git a/internal/fourslash/tests/gen/goToTypeDefinition2_test.go b/internal/fourslash/tests/gen/goToTypeDefinition2_test.go new file mode 100644 index 0000000000..ebcbd8ab16 --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinition2_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 TestGoToTypeDefinition2(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: goToTypeDefinition2_Definition.ts +interface /*definition*/I1 { + p; +} +type propertyType = I1; +interface I2 { + property: propertyType; +} +// @Filename: goToTypeDefinition2_Consumption.ts +var i2: I2; +i2.prop/*reference*/erty;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "reference") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinition3_test.go b/internal/fourslash/tests/gen/goToTypeDefinition3_test.go new file mode 100644 index 0000000000..959731d36c --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinition3_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 TestGoToTypeDefinition3(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `type /*definition*/T = string; +const x: /*reference*/T;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "reference") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinition4_test.go b/internal/fourslash/tests/gen/goToTypeDefinition4_test.go new file mode 100644 index 0000000000..b37d04f884 --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinition4_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 TestGoToTypeDefinition4(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: foo.ts +export type /*def0*/T = string; +export const /*def1*/T = ""; +// @Filename: bar.ts +import { T } from "./foo"; +let x: [|/*reference*/T|];` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "reference") + f.VerifyBaselineGoToDefinition(t, "reference") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinition5_test.go b/internal/fourslash/tests/gen/goToTypeDefinition5_test.go new file mode 100644 index 0000000000..a6e495eddd --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinition5_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 TestGoToTypeDefinition5(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: foo.ts +let Foo: /*definition*/unresolved; +type Foo = { x: string }; +/*reference*/Foo;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "reference") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinitionAliases_test.go b/internal/fourslash/tests/gen/goToTypeDefinitionAliases_test.go new file mode 100644 index 0000000000..cf70f8b7e6 --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinitionAliases_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 TestGoToTypeDefinitionAliases(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: goToTypeDefinitioAliases_module1.ts +interface /*definition*/I { + p; +} +export {I as I2}; +// @Filename: goToTypeDefinitioAliases_module2.ts +import {I2 as I3} from "./goToTypeDefinitioAliases_module1"; +var v1: I3; +export {v1 as v2}; +// @Filename: goToTypeDefinitioAliases_module3.ts +import {/*reference1*/v2 as v3} from "./goToTypeDefinitioAliases_module2"; +/*reference2*/v3;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "reference1", "reference2") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinitionEnumMembers_test.go b/internal/fourslash/tests/gen/goToTypeDefinitionEnumMembers_test.go new file mode 100644 index 0000000000..6a248e3e46 --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinitionEnumMembers_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 TestGoToTypeDefinitionEnumMembers(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `enum E { + value1, + /*definition*/value2 +} +var x = E.value2; + +/*reference*/x;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "reference") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinitionImportMeta_test.go b/internal/fourslash/tests/gen/goToTypeDefinitionImportMeta_test.go new file mode 100644 index 0000000000..9cda20577e --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinitionImportMeta_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 TestGoToTypeDefinitionImportMeta(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @module: esnext +// @Filename: foo.ts +/// +/// +import.me/*reference*/ta; +//@Filename: bar.d.ts +interface /*definition*/ImportMeta { +}` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "reference") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinitionModifiers_test.go b/internal/fourslash/tests/gen/goToTypeDefinitionModifiers_test.go new file mode 100644 index 0000000000..957d3ff39e --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinitionModifiers_test.go @@ -0,0 +1,33 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestGoToTypeDefinitionModifiers(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: /a.ts +/*export*/export class A/*A*/ { + + /*private*/private z/*z*/: string; + + /*private2*/private y/*y*/: A; + + /*readonly*/readonly x/*x*/: string; + + /*async*/async a/*a*/() { } + + /*override*/override b/*b*/() {} + + /*public1*/public/*public2*/ as/*multipleModifiers*/ync c/*c*/() { } +} + +exp/*exportFunction*/ort function foo/*foo*/() { }` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "export", "A", "private", "z", "private2", "y", "readonly", "x", "async", "a", "override", "b", "public1", "public2", "multipleModifiers", "c", "exportFunction", "foo") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinitionModule_test.go b/internal/fourslash/tests/gen/goToTypeDefinitionModule_test.go new file mode 100644 index 0000000000..988f92ddd2 --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinitionModule_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 TestGoToTypeDefinitionModule(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: module1.ts +module /*definition*/M { + export var p; +} +var m: typeof M; +// @Filename: module3.ts +/*reference1*/M; +/*reference2*/m;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "reference1", "reference2") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinitionPrimitives_test.go b/internal/fourslash/tests/gen/goToTypeDefinitionPrimitives_test.go new file mode 100644 index 0000000000..18e9fe06ef --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinitionPrimitives_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 TestGoToTypeDefinitionPrimitives(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: module1.ts +var w: {a: number}; +var x = "string"; +var y: number | string; +var z; // any +// @Filename: module2.ts +w./*reference1*/a; +/*reference2*/x; +/*reference3*/y; +/*reference4*/y;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "reference1", "reference2", "reference3", "reference4") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinitionUnionType_test.go b/internal/fourslash/tests/gen/goToTypeDefinitionUnionType_test.go new file mode 100644 index 0000000000..76e52a123e --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinitionUnionType_test.go @@ -0,0 +1,33 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestGoToTypeDefinitionUnionType(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class /*definition0*/C { + p; +} + +interface /*definition1*/I { + x; +} + +module M { + export interface /*definition2*/I { + y; + } +} + +var x: C | I | M.I; + +/*reference*/x;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "reference") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinition_Pick_test.go b/internal/fourslash/tests/gen/goToTypeDefinition_Pick_test.go new file mode 100644 index 0000000000..ed7dae6496 --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinition_Pick_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 TestGoToTypeDefinition_Pick(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `type User = { id: number; name: string; }; +declare const user: Pick +/*reference*/user + +type PickedUser = Pick +declare const user2: PickedUser +/*reference2*/user2` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "reference", "reference2") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinition_arrayType_test.go b/internal/fourslash/tests/gen/goToTypeDefinition_arrayType_test.go new file mode 100644 index 0000000000..8d3803c3bb --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinition_arrayType_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 TestGoToTypeDefinition_arrayType(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `type User = { name: string }; +declare const users: User[] +/*reference*/users + +type UsersArr = Array +declare const users2: UsersArr +/*reference2*/users2 + +class CustomArray extends Array { immutableReverse() { return [...this].reverse() } } +declare const users3: CustomArray +/*reference3*/users3` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "reference", "reference2", "reference3") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinition_promiseType_test.go b/internal/fourslash/tests/gen/goToTypeDefinition_promiseType_test.go new file mode 100644 index 0000000000..c13cbf198d --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinition_promiseType_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 TestGoToTypeDefinition_promiseType(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `type User = { name: string }; +async function /*reference*/getUser() { return { name: "Bob" } satisfies User as User } + +const /*reference2*/promisedBob = getUser() + +export {}` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "reference", "reference2") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinition_returnType_test.go b/internal/fourslash/tests/gen/goToTypeDefinition_returnType_test.go new file mode 100644 index 0000000000..930b658c60 --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinition_returnType_test.go @@ -0,0 +1,49 @@ +package fourslash_test + +import ( + "testing" + + "github.com/microsoft/typescript-go/internal/fourslash" + "github.com/microsoft/typescript-go/internal/testutil" +) + +func TestGoToTypeDefinition_returnType(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `interface /*I*/I { x: number; } +interface /*J*/J { y: number; } + +function f0(): I { return { x: 0 }; } + +type T = /*T*/(i: I) => I; +const f1: T = i => ({ x: i.x + 1 }); + +const f2 = (i: I): I => ({ x: i.x + 1 }); + +const f3 = (i: I) => (/*f3Def*/{ x: i.x + 1 }); + +const f4 = (i: I) => i; + +const f5 = /*f5Def*/(i: I): I | J => ({ x: i.x + 1 }); + +const f6 = (i: I, j: J, b: boolean) => b ? i : j; + +const /*f7Def*/f7 = (i: I) => {}; + +function f8(i: I): I; +function f8(j: J): J; +function /*f8Def*/f8(ij: any): any { return ij; } + +/*f0*/f0(); +/*f1*/f1(); +/*f2*/f2(); +/*f3*/f3(); +/*f4*/f4(); +/*f5*/f5(); +/*f6*/f6(); +/*f7*/f7(); +/*f8*/f8();` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinition_test.go b/internal/fourslash/tests/gen/goToTypeDefinition_test.go new file mode 100644 index 0000000000..2b9a7ca2a1 --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinition_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 TestGoToTypeDefinition(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: goToTypeDefinition_Definition.ts +class /*definition*/C { + p; +} +var c: C; +// @Filename: goToTypeDefinition_Consumption.ts +/*reference*/c = undefined;` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "reference") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinition_typeReference_test.go b/internal/fourslash/tests/gen/goToTypeDefinition_typeReference_test.go new file mode 100644 index 0000000000..e7e8ae6ee9 --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinition_typeReference_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 TestGoToTypeDefinition_typeReference(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `type User = { name: string }; +type Box = { value: T }; +declare const boxedUser: Box +/*reference*/boxedUser` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "reference") +} diff --git a/internal/fourslash/tests/gen/goToTypeDefinition_typedef_test.go b/internal/fourslash/tests/gen/goToTypeDefinition_typedef_test.go new file mode 100644 index 0000000000..8f8c1868cb --- /dev/null +++ b/internal/fourslash/tests/gen/goToTypeDefinition_typedef_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 TestGoToTypeDefinition_typedef(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @allowJs: true +// @Filename: /a.js +/** + * /*def*/@typedef {object} I + * @property {number} x + */ + +/** @type {I} */ +const /*ref*/i = { x: 0 };` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "ref") +} diff --git a/internal/fourslash/tests/gen/jsDocServices_test.go b/internal/fourslash/tests/gen/jsDocServices_test.go new file mode 100644 index 0000000000..e25cdc74ce --- /dev/null +++ b/internal/fourslash/tests/gen/jsDocServices_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 TestJsDocServices(t *testing.T) { + t.Parallel() + t.Skip() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `interface /*I*/I {} + +/** + * @param /*use*/[|foo|] I pity the foo + */ +function f([|[|/*def*/{| "contextRangeIndex": 1 |}foo|]: I|]) { + return /*use2*/[|foo|]; +}` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.GoToMarker(t, "use") + f.VerifyQuickInfoIs(t, "(parameter) foo: I", "I pity the foo") + f.VerifyBaselineFindAllReferences(t, "use", "def", "use2") + f.VerifyBaselineRename(t, nil /*preferences*/, f.Ranges()[0], f.Ranges()[2], f.Ranges()[3]) + f.VerifyBaselineDocumentHighlights(t, nil /*preferences*/, f.Ranges()[0], f.Ranges()[2], f.Ranges()[3]) + f.VerifyBaselineGoToTypeDefinition(t, "use") + f.VerifyBaselineGoToDefinition(t, "use") +} diff --git a/internal/fourslash/tests/gen/typedefinition01_test.go b/internal/fourslash/tests/gen/typedefinition01_test.go new file mode 100644 index 0000000000..dc025b79ad --- /dev/null +++ b/internal/fourslash/tests/gen/typedefinition01_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 TestTypedefinition01(t *testing.T) { + t.Parallel() + + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: b.ts +import n = require('./a'); +var x/*1*/ = new n.Foo(); +// @Filename: a.ts +export class /*2*/Foo {}` + f := fourslash.NewFourslash(t, nil /*capabilities*/, content) + f.VerifyBaselineGoToTypeDefinition(t, "1") +} diff --git a/testdata/baselines/reference/fourslash/goToDefinition/goToTypeDefinition4.baseline.jsonc b/testdata/baselines/reference/fourslash/goToDefinition/goToTypeDefinition4.baseline.jsonc new file mode 100644 index 0000000000..a639362681 --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToDefinition/goToTypeDefinition4.baseline.jsonc @@ -0,0 +1,8 @@ +// === goToDefinition === +// === /foo.ts === +// export type [|T|] = string; +// export const [|T|] = ""; + +// === /bar.ts === +// import { T } from "./foo"; +// let x: /*GOTO DEF*/T; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition.baseline.jsonc new file mode 100644 index 0000000000..1ff73db085 --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition.baseline.jsonc @@ -0,0 +1,9 @@ +// === goToType === +// === /goToTypeDefinition_Definition.ts === +// class [|C|] { +// p; +// } +// var c: C; + +// === /goToTypeDefinition_Consumption.ts === +// /*GOTO TYPE*/c = undefined; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition2.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition2.baseline.jsonc new file mode 100644 index 0000000000..beaf380dc5 --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition2.baseline.jsonc @@ -0,0 +1,11 @@ +// === goToType === +// === /goToTypeDefinition2_Definition.ts === +// interface [|I1|] { +// p; +// } +// type propertyType = I1; +// // --- (line: 5) skipped --- + +// === /goToTypeDefinition2_Consumption.ts === +// var i2: I2; +// i2.prop/*GOTO TYPE*/erty; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition3.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition3.baseline.jsonc new file mode 100644 index 0000000000..6067823559 --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition3.baseline.jsonc @@ -0,0 +1,4 @@ +// === goToType === +// === /goToTypeDefinition3.ts === +// type [|T|] = string; +// const x: /*GOTO TYPE*/T; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition4.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition4.baseline.jsonc new file mode 100644 index 0000000000..61504f639c --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition4.baseline.jsonc @@ -0,0 +1,4 @@ +// === goToType === +// === /bar.ts === +// import { T } from "./foo"; +// let x: /*GOTO TYPE*/T; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition5.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition5.baseline.jsonc new file mode 100644 index 0000000000..4f3d334efb --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition5.baseline.jsonc @@ -0,0 +1,5 @@ +// === goToType === +// === /foo.ts === +// let Foo: unresolved; +// type Foo = { x: string }; +// /*GOTO TYPE*/Foo; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionAliases.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionAliases.baseline.jsonc new file mode 100644 index 0000000000..dd9f252f4b --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionAliases.baseline.jsonc @@ -0,0 +1,23 @@ +// === goToType === +// === /goToTypeDefinitioAliases_module1.ts === +// interface [|I|] { +// p; +// } +// export {I as I2}; + +// === /goToTypeDefinitioAliases_module3.ts === +// import {/*GOTO TYPE*/v2 as v3} from "./goToTypeDefinitioAliases_module2"; +// v3; + + + +// === goToType === +// === /goToTypeDefinitioAliases_module1.ts === +// interface [|I|] { +// p; +// } +// export {I as I2}; + +// === /goToTypeDefinitioAliases_module3.ts === +// import {v2 as v3} from "./goToTypeDefinitioAliases_module2"; +// /*GOTO TYPE*/v3; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionEnumMembers.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionEnumMembers.baseline.jsonc new file mode 100644 index 0000000000..7e09546c95 --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionEnumMembers.baseline.jsonc @@ -0,0 +1,9 @@ +// === goToType === +// === /goToTypeDefinitionEnumMembers.ts === +// enum E { +// value1, +// [|value2|] +// } +// var x = E.value2; +// +// /*GOTO TYPE*/x; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionImportMeta.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionImportMeta.baseline.jsonc new file mode 100644 index 0000000000..11fd9f4d3d --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionImportMeta.baseline.jsonc @@ -0,0 +1,9 @@ +// === goToType === +// === /bar.d.ts === +// interface [|ImportMeta|] { +// } + +// === /foo.ts === +// /// +// /// +// import.me/*GOTO TYPE*/ta; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionModifiers.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionModifiers.baseline.jsonc new file mode 100644 index 0000000000..c6416aa695 --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionModifiers.baseline.jsonc @@ -0,0 +1,227 @@ +// === goToType === +// === /a.ts === +// /*GOTO TYPE*/export class [|A|] { +// +// private z: string; +// +// // --- (line: 5) skipped --- + + + +// === goToType === +// === /a.ts === +// export class [|A|]/*GOTO TYPE*/ { +// +// private z: string; +// +// // --- (line: 5) skipped --- + + + +// === goToType === +// === /a.ts === +// export class A { +// +// /*GOTO TYPE*/private z: string; +// +// private y: A; +// +// // --- (line: 7) skipped --- + + + +// === goToType === +// === /a.ts === +// export class A { +// +// private z/*GOTO TYPE*/: string; +// +// private y: A; +// +// // --- (line: 7) skipped --- + + + +// === goToType === +// === /a.ts === +// export class [|A|] { +// +// private z: string; +// +// /*GOTO TYPE*/private y: A; +// +// readonly x: string; +// +// // --- (line: 9) skipped --- + + + +// === goToType === +// === /a.ts === +// export class [|A|] { +// +// private z: string; +// +// private y/*GOTO TYPE*/: A; +// +// readonly x: string; +// +// // --- (line: 9) skipped --- + + + +// === goToType === +// === /a.ts === +// --- (line: 3) skipped --- +// +// private y: A; +// +// /*GOTO TYPE*/readonly x: string; +// +// async a() { } +// +// // --- (line: 11) skipped --- + + + +// === goToType === +// === /a.ts === +// --- (line: 3) skipped --- +// +// private y: A; +// +// readonly x/*GOTO TYPE*/: string; +// +// async a() { } +// +// // --- (line: 11) skipped --- + + + +// === goToType === +// === /a.ts === +// --- (line: 5) skipped --- +// +// readonly x: string; +// +// /*GOTO TYPE*/async a() { } +// +// override b() {} +// +// // --- (line: 13) skipped --- + + + +// === goToType === +// === /a.ts === +// --- (line: 5) skipped --- +// +// readonly x: string; +// +// async a/*GOTO TYPE*/() { } +// +// override b() {} +// +// // --- (line: 13) skipped --- + + + +// === goToType === +// === /a.ts === +// --- (line: 7) skipped --- +// +// async a() { } +// +// /*GOTO TYPE*/override b() {} +// +// public async c() { } +// } +// +// export function foo() { } + + + +// === goToType === +// === /a.ts === +// --- (line: 7) skipped --- +// +// async a() { } +// +// override b/*GOTO TYPE*/() {} +// +// public async c() { } +// } +// +// export function foo() { } + + + +// === goToType === +// === /a.ts === +// --- (line: 9) skipped --- +// +// override b() {} +// +// /*GOTO TYPE*/public async c() { } +// } +// +// export function foo() { } + + + +// === goToType === +// === /a.ts === +// --- (line: 9) skipped --- +// +// override b() {} +// +// public/*GOTO TYPE*/ async c() { } +// } +// +// export function foo() { } + + + +// === goToType === +// === /a.ts === +// --- (line: 9) skipped --- +// +// override b() {} +// +// public as/*GOTO TYPE*/ync c() { } +// } +// +// export function foo() { } + + + +// === goToType === +// === /a.ts === +// --- (line: 9) skipped --- +// +// override b() {} +// +// public async c/*GOTO TYPE*/() { } +// } +// +// export function foo() { } + + + +// === goToType === +// === /a.ts === +// --- (line: 12) skipped --- +// public async c() { } +// } +// +// exp/*GOTO TYPE*/ort function foo() { } + + + +// === goToType === +// === /a.ts === +// --- (line: 12) skipped --- +// public async c() { } +// } +// +// export function foo/*GOTO TYPE*/() { } \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionModule.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionModule.baseline.jsonc new file mode 100644 index 0000000000..e4615be10b --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionModule.baseline.jsonc @@ -0,0 +1,23 @@ +// === goToType === +// === /module1.ts === +// module [|M|] { +// export var p; +// } +// var m: typeof M; + +// === /module3.ts === +// /*GOTO TYPE*/M; +// m; + + + +// === goToType === +// === /module1.ts === +// module [|M|] { +// export var p; +// } +// var m: typeof M; + +// === /module3.ts === +// M; +// /*GOTO TYPE*/m; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionPrimitives.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionPrimitives.baseline.jsonc new file mode 100644 index 0000000000..04785ee8ff --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionPrimitives.baseline.jsonc @@ -0,0 +1,33 @@ +// === goToType === +// === /module2.ts === +// w./*GOTO TYPE*/a; +// x; +// y; +// y; + + + +// === goToType === +// === /module2.ts === +// w.a; +// /*GOTO TYPE*/x; +// y; +// y; + + + +// === goToType === +// === /module2.ts === +// w.a; +// x; +// /*GOTO TYPE*/y; +// y; + + + +// === goToType === +// === /module2.ts === +// w.a; +// x; +// y; +// /*GOTO TYPE*/y; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionUnionType.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionUnionType.baseline.jsonc new file mode 100644 index 0000000000..b29b559356 --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinitionUnionType.baseline.jsonc @@ -0,0 +1,19 @@ +// === goToType === +// === /goToTypeDefinitionUnionType.ts === +// class [|C|] { +// p; +// } +// +// interface [|I|] { +// x; +// } +// +// module M { +// export interface [|I|] { +// y; +// } +// } +// +// var x: C | I | M.I; +// +// /*GOTO TYPE*/x; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_Pick.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_Pick.baseline.jsonc new file mode 100644 index 0000000000..e15dcddec0 --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_Pick.baseline.jsonc @@ -0,0 +1,19 @@ +// === goToType === +// === /goToTypeDefinition_Pick.ts === +// type User = [|{ id: number; name: string; }|]; +// declare const user: Pick +// /*GOTO TYPE*/user +// +// type PickedUser = Pick +// declare const user2: PickedUser +// user2 + + + +// === goToType === +// === /goToTypeDefinition_Pick.ts === +// --- (line: 3) skipped --- +// +// type PickedUser = Pick +// declare const user2: PickedUser +// /*GOTO TYPE*/user2 \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_arrayType.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_arrayType.baseline.jsonc new file mode 100644 index 0000000000..e984cc5804 --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_arrayType.baseline.jsonc @@ -0,0 +1,37 @@ +// === goToType === +// === /goToTypeDefinition_arrayType.ts === +// type User = [|{ name: string }|]; +// declare const users: User[] +// /*GOTO TYPE*/users +// +// type UsersArr = Array +// declare const users2: UsersArr +// // --- (line: 7) skipped --- + + + +// === goToType === +// === /goToTypeDefinition_arrayType.ts === +// type User = [|{ name: string }|]; +// declare const users: User[] +// users +// +// type UsersArr = Array +// declare const users2: UsersArr +// /*GOTO TYPE*/users2 +// +// class CustomArray extends Array { immutableReverse() { return [...this].reverse() } } +// declare const users3: CustomArray +// users3 + + + +// === goToType === +// === /goToTypeDefinition_arrayType.ts === +// --- (line: 5) skipped --- +// declare const users2: UsersArr +// users2 +// +// class [|CustomArray|] extends Array { immutableReverse() { return [...this].reverse() } } +// declare const users3: CustomArray +// /*GOTO TYPE*/users3 \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_promiseType.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_promiseType.baseline.jsonc new file mode 100644 index 0000000000..18eae436c2 --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_promiseType.baseline.jsonc @@ -0,0 +1,19 @@ +// === goToType === +// === /goToTypeDefinition_promiseType.ts === +// type User = [|{ name: string }|]; +// async function /*GOTO TYPE*/getUser() { return { name: "Bob" } satisfies User as User } +// +// const promisedBob = getUser() +// +// export {} + + + +// === goToType === +// === /goToTypeDefinition_promiseType.ts === +// type User = [|{ name: string }|]; +// async function getUser() { return { name: "Bob" } satisfies User as User } +// +// const /*GOTO TYPE*/promisedBob = getUser() +// +// export {} \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_returnType.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_returnType.baseline.jsonc new file mode 100644 index 0000000000..33d20e328a --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_returnType.baseline.jsonc @@ -0,0 +1,179 @@ +// === goToType === +// === /goToTypeDefinition_returnType.ts === +// interface [|I|] { x: number; } +// interface J { y: number; } +// +// function f0(): I { return { x: 0 }; } +// // --- (line: 5) skipped --- + +// --- (line: 21) skipped --- +// function f8(j: J): J; +// function f8(ij: any): any { return ij; } +// +// /*GOTO TYPE*/f0(); +// f1(); +// f2(); +// f3(); +// // --- (line: 29) skipped --- + + + +// === goToType === +// === /goToTypeDefinition_returnType.ts === +// interface I { x: number; } +// interface J { y: number; } +// +// function f0(): I { return { x: 0 }; } +// +// type T = [|(i: I) => I|]; +// const f1: T = i => ({ x: i.x + 1 }); +// +// const f2 = (i: I): I => ({ x: i.x + 1 }); +// // --- (line: 10) skipped --- + +// --- (line: 22) skipped --- +// function f8(ij: any): any { return ij; } +// +// f0(); +// /*GOTO TYPE*/f1(); +// f2(); +// f3(); +// f4(); +// // --- (line: 30) skipped --- + + + +// === goToType === +// === /goToTypeDefinition_returnType.ts === +// interface [|I|] { x: number; } +// interface J { y: number; } +// +// function f0(): I { return { x: 0 }; } +// // --- (line: 5) skipped --- + +// --- (line: 23) skipped --- +// +// f0(); +// f1(); +// /*GOTO TYPE*/f2(); +// f3(); +// f4(); +// f5(); +// // --- (line: 31) skipped --- + + + +// === goToType === +// === /goToTypeDefinition_returnType.ts === +// --- (line: 7) skipped --- +// +// const f2 = (i: I): I => ({ x: i.x + 1 }); +// +// const f3 = (i: I) => ([|{ x: i.x + 1 }|]); +// +// const f4 = (i: I) => i; +// +// // --- (line: 15) skipped --- + +// --- (line: 24) skipped --- +// f0(); +// f1(); +// f2(); +// /*GOTO TYPE*/f3(); +// f4(); +// f5(); +// f6(); +// f7(); +// f8(); + + + +// === goToType === +// === /goToTypeDefinition_returnType.ts === +// interface [|I|] { x: number; } +// interface J { y: number; } +// +// function f0(): I { return { x: 0 }; } +// // --- (line: 5) skipped --- + +// --- (line: 25) skipped --- +// f1(); +// f2(); +// f3(); +// /*GOTO TYPE*/f4(); +// f5(); +// f6(); +// f7(); +// f8(); + + + +// === goToType === +// === /goToTypeDefinition_returnType.ts === +// interface [|I|] { x: number; } +// interface [|J|] { y: number; } +// +// function f0(): I { return { x: 0 }; } +// +// // --- (line: 6) skipped --- + +// --- (line: 26) skipped --- +// f2(); +// f3(); +// f4(); +// /*GOTO TYPE*/f5(); +// f6(); +// f7(); +// f8(); + + + +// === goToType === +// === /goToTypeDefinition_returnType.ts === +// interface [|I|] { x: number; } +// interface [|J|] { y: number; } +// +// function f0(): I { return { x: 0 }; } +// +// // --- (line: 6) skipped --- + +// --- (line: 27) skipped --- +// f3(); +// f4(); +// f5(); +// /*GOTO TYPE*/f6(); +// f7(); +// f8(); + + + +// === goToType === +// === /goToTypeDefinition_returnType.ts === +// --- (line: 28) skipped --- +// f4(); +// f5(); +// f6(); +// /*GOTO TYPE*/f7(); +// f8(); + + + +// === goToType === +// === /goToTypeDefinition_returnType.ts === +// --- (line: 17) skipped --- +// +// const f7 = (i: I) => {}; +// +// function [|f8|](i: I): I; +// function [|f8|](j: J): J; +// function [|f8|](ij: any): any { return ij; } +// +// f0(); +// f1(); +// f2(); +// f3(); +// f4(); +// f5(); +// f6(); +// f7(); +// /*GOTO TYPE*/f8(); \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_typeReference.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_typeReference.baseline.jsonc new file mode 100644 index 0000000000..b5a668654f --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_typeReference.baseline.jsonc @@ -0,0 +1,6 @@ +// === goToType === +// === /goToTypeDefinition_typeReference.ts === +// type User = { name: string }; +// type Box = [|{ value: T }|]; +// declare const boxedUser: Box +// /*GOTO TYPE*/boxedUser \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_typedef.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_typedef.baseline.jsonc new file mode 100644 index 0000000000..beeae33cc7 --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/goToTypeDefinition_typedef.baseline.jsonc @@ -0,0 +1,9 @@ +// === goToType === +// === /a.js === +// /** +// * @typedef {object} I +// * [|@property {number} x +// |]*/ +// +// /** @type {I} */ +// const /*GOTO TYPE*/i = { x: 0 }; \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/goToType/typedefinition01.baseline.jsonc b/testdata/baselines/reference/fourslash/goToType/typedefinition01.baseline.jsonc new file mode 100644 index 0000000000..5803b2d492 --- /dev/null +++ b/testdata/baselines/reference/fourslash/goToType/typedefinition01.baseline.jsonc @@ -0,0 +1,7 @@ +// === goToType === +// === /a.ts === +// export class [|Foo|] {} + +// === /b.ts === +// import n = require('./a'); +// var x/*GOTO TYPE*/ = new n.Foo(); \ No newline at end of file