diff --git a/internal/fourslash/_scripts/failingTests.txt b/internal/fourslash/_scripts/failingTests.txt index d1295ad6f84..b9bb35865a1 100644 --- a/internal/fourslash/_scripts/failingTests.txt +++ b/internal/fourslash/_scripts/failingTests.txt @@ -33,7 +33,6 @@ TestAutoImportSortCaseSensitivity1 TestAutoImportTypeImport4 TestAutoImportTypeOnlyPreferred3 TestAutoImportVerbatimTypeOnly1 -TestCalledUnionsOfDissimilarTyeshaveGoodDisplay TestCloduleTypeOf1 TestCodeCompletionEscaping TestCodeFixAddParameterNames1 @@ -338,7 +337,6 @@ TestNoQuickInfoForLabel TestNoQuickInfoInWhitespace TestOverloadQuickInfo TestProtoVarVisibleWithOuterScopeUnderscoreProto -TestQualifyModuleTypeNames TestQuickfixImplementInterfaceUnreachableTypeUsesRelativeImport TestQuickInfo_notInsideComment TestQuickinfo01 diff --git a/internal/fourslash/tests/manual/jsDocDontBreakWithNamespacesVS_test.go b/internal/fourslash/tests/manual/jsDocDontBreakWithNamespacesVS_test.go new file mode 100644 index 00000000000..22b8d781c22 --- /dev/null +++ b/internal/fourslash/tests/manual/jsDocDontBreakWithNamespacesVS_test.go @@ -0,0 +1,34 @@ +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 TestJsDocDontBreakWithNamespacesVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @allowJs: true +// @Filename: jsDocDontBreakWithNamespaces.js +/** + * @returns {module:@nodefuel/web~Webserver~wsServer#hello} Websocket server object + */ +function foo() { } +foo(''/*foo*/); + +/** + * @type {module:xxxxx} */ + */ +function bar() { } +bar(''/*bar*/); + +/** @type {function(module:xxxx, module:xxxx): module:xxxxx} */ +function zee() { } +zee(''/*zee*/);` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/jsDocFunctionSignatures5VS_test.go b/internal/fourslash/tests/manual/jsDocFunctionSignatures5VS_test.go new file mode 100644 index 00000000000..c850276d185 --- /dev/null +++ b/internal/fourslash/tests/manual/jsDocFunctionSignatures5VS_test.go @@ -0,0 +1,32 @@ +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 TestJsDocFunctionSignatures5VS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @strict: true +// @allowJs: true +// @Filename: Foo.js +/** + * Filters a path based on a regexp or glob pattern. + * @param {String} basePath The base path where the search will be performed. + * @param {String} pattern A string defining a regexp of a glob pattern. + * @param {String} type The search pattern type, can be a regexp or a glob. + * @param {Object} options A object containing options to the search. + * @return {Array} A list containing the filtered paths. + */ +function pathFilter(basePath, pattern, type, options){ +//... +} +pathFilter(/**/'foo', 'bar', 'baz', {});` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/jsDocFunctionSignatures6VS_test.go b/internal/fourslash/tests/manual/jsDocFunctionSignatures6VS_test.go new file mode 100644 index 00000000000..05e00f0a75d --- /dev/null +++ b/internal/fourslash/tests/manual/jsDocFunctionSignatures6VS_test.go @@ -0,0 +1,27 @@ +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 TestJsDocFunctionSignatures6VS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @allowJs: true +// @Filename: Foo.js +/** + * @param {string} p1 - A string param + * @param {string?} p2 - An optional param + * @param {string} [p3] - Another optional param + * @param {string} [p4="test"] - An optional param with a default value + */ +function f1(p1, p2, p3, p4){} +f1(/*1*/'foo', /*2*/'bar', /*3*/'baz', /*4*/'qux');` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/jsdocReturnsTagVS_test.go b/internal/fourslash/tests/manual/jsdocReturnsTagVS_test.go new file mode 100644 index 00000000000..0e064568f1d --- /dev/null +++ b/internal/fourslash/tests/manual/jsdocReturnsTagVS_test.go @@ -0,0 +1,29 @@ +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 TestJsdocReturnsTagVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @allowJs: true +// @Filename: dummy.js +/** + * Find an item + * @template T + * @param {T[]} l + * @param {T} x + * @returns {?T} The names of the found item(s). + */ +function find(l, x) { +} +find(''/**/);` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/quickInfoJsDocTags13VS_test.go b/internal/fourslash/tests/manual/quickInfoJsDocTags13VS_test.go new file mode 100644 index 00000000000..581a90695ce --- /dev/null +++ b/internal/fourslash/tests/manual/quickInfoJsDocTags13VS_test.go @@ -0,0 +1,42 @@ +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 TestQuickInfoJsDocTags13VS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @allowJs: true +// @checkJs: true +// @filename: ./a.js +/** + * First overload + * @overload + * @param {number} a + * @returns {void} + */ + +/** + * Second overload + * @overload + * @param {string} a + * @returns {void} + */ + +/** + * @param {string | number} a + * @returns {void} + */ +function f(a) {} + +f(/*a*/1); +f(/*b*/"");` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/quickInfoJsDocTextFormatting1VS_test.go b/internal/fourslash/tests/manual/quickInfoJsDocTextFormatting1VS_test.go new file mode 100644 index 00000000000..472bc5ccc52 --- /dev/null +++ b/internal/fourslash/tests/manual/quickInfoJsDocTextFormatting1VS_test.go @@ -0,0 +1,58 @@ +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 TestQuickInfoJsDocTextFormatting1VS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `/** + * @param {number} var1 **Highlighted text** + * @param {string} var2 Another **Highlighted text** +*/ +function f1(var1, var2) { } + +/** + * @param {number} var1 *Regular text with an asterisk + * @param {string} var2 Another *Regular text with an asterisk +*/ +function f2(var1, var2) { } + +/** + * @param {number} var1 + * *Regular text with an asterisk + * @param {string} var2 + * Another *Regular text with an asterisk +*/ +function f3(var1, var2) { } + +/** + * @param {number} var1 + * **Highlighted text** + * @param {string} var2 + * Another **Highlighted text** +*/ +function f4(var1, var2) { } + +/** + * @param {number} var1 + **Highlighted text** + * @param {string} var2 + Another **Highlighted text** +*/ +function f5(var1, var2) { } + +f1(/*1*/); +f2(/*2*/); +f3(/*3*/); +f4(/*4*/); +f5(/*5*/);` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpAfterParameterVS_test.go b/internal/fourslash/tests/manual/signatureHelpAfterParameterVS_test.go new file mode 100644 index 00000000000..05cbfc2d47f --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpAfterParameterVS_test.go @@ -0,0 +1,21 @@ +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 TestSignatureHelpAfterParameterVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `type Type = (a, b, c) => void +const a: Type = (a/*1*/, b/*2*/) => {} +const b: Type = function (a/*3*/, b/*4*/) {} +const c: Type = ({ /*5*/a: { b/*6*/ }}/*7*/ = { }/*8*/, [b/*9*/]/*10*/, .../*11*/c/*12*/) => {}` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpAnonymousTypeVS_test.go b/internal/fourslash/tests/manual/signatureHelpAnonymousTypeVS_test.go new file mode 100644 index 00000000000..50d544262d3 --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpAnonymousTypeVS_test.go @@ -0,0 +1,20 @@ +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 TestSignatureHelpAnonymousTypeVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `const comparers: Array<(a: any, b: any) => boolean> = []; + +comparers.push((a,/**/ b) => true);` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpBindingPatternVS_test.go b/internal/fourslash/tests/manual/signatureHelpBindingPatternVS_test.go new file mode 100644 index 00000000000..96ec59cceaa --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpBindingPatternVS_test.go @@ -0,0 +1,67 @@ +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 TestSignatureHelpBindingPatternVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = ` +/** + * @param options An empty object binding pattern. + */ +function emptyObj({}) {} +emptyObj(/*emptyObj*/) + +/** + * @param items An empty array binding pattern. + */ +function emptyArr([]) {} +emptyArr(/*emptyArr*/) + +/** + * @param param An object with a and b properties. + */ +function nonEmptyObj({a, b}: {a: number, b: string}) {} +nonEmptyObj(/*nonEmptyObj*/) + +/** + * @param tuple A tuple with two elements. + */ +function nonEmptyArr([x, y]: [number, string]) {} +nonEmptyArr(/*nonEmptyArr*/) + +/** + * @param first The first number parameter. + * @param second An object with a and b properties. + */ +function idLeading(first: number, {a, b}: {a: number, b: string}) {} +idLeading(123/*idLeading*/, { a: 1, b: 2 }/*bindingTrailing*/) + +/** + * @param first An object with a and b properties. + * @param last The last number parameter. + */ +function bindingLeading({a, b}: {a: number, b: string}, last: number) {} +bindingLeading(/*bindingLeading*/{ a: 1, b: 2 }, 123 /*idTrailing*/) + +/** + * @param param1 {Object} The first parameter + * @param param1.a {number} Comment a + * @param param1.b {string} Comment b + * @param param2 {Object} The second parameter + * @param param2.c {boolean} Comment c + * @param param2.d {unknown} Comment d + */ +function multipleBindings({ a, b }, { c, d }) {} +multipleBindings({ a: 0, b: "" }/*firstObjParam*/, { c: true, d: "" }/*secondObjParam*/) +` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpCommentsClassMembersVS_test.go b/internal/fourslash/tests/manual/signatureHelpCommentsClassMembersVS_test.go new file mode 100644 index 00000000000..21089fa6513 --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpCommentsClassMembersVS_test.go @@ -0,0 +1,148 @@ +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 TestSignatureHelpCommentsClassMembersVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `/** This is comment for c1*/ +class c1 { + /** p1 is property of c1*/ + public p1: number; + /** sum with property*/ + public p2(/** number to add*/b: number) { + return this.p1 + b; + } + /** getter property 1*/ + public get p3() { + return this.p2(/*8*/this.p1); + } + /** setter property 1*/ + public set p3(/** this is value*/value: number) { + this.p1 = this.p2(/*13*/value); + } + /** pp1 is property of c1*/ + private pp1: number; + /** sum with property*/ + private pp2(/** number to add*/b: number) { + return this.p1 + b; + } + /** getter property 2*/ + private get pp3() { + return this.pp2(/*20*/this.pp1); + } + /** setter property 2*/ + private set pp3( /** this is value*/value: number) { + this.pp1 = this.pp2(/*25*/value); + } + /** Constructor method*/ + constructor() { + } + /** s1 is static property of c1*/ + static s1: number; + /** static sum with property*/ + static s2(/** number to add*/b: number) { + return c1.s1 + b; + } + /** static getter property*/ + static get s3() { + return c1.s2(/*35*/c1.s1); + } + /** setter property 3*/ + static set s3( /** this is value*/value: number) { + c1.s1 = c1.s2(/*42*/value); + } + public nc_p1: number; + public nc_p2(b: number) { + return this.nc_p1 + b; + } + public get nc_p3() { + return this.nc_p2(/*47*/this.nc_p1); + } + public set nc_p3(value: number) { + this.nc_p1 = this.nc_p2(/*49*/value); + } + private nc_pp1: number; + private nc_pp2(b: number) { + return this.nc_pp1 + b; + } + private get nc_pp3() { + return this.nc_pp2(/*54*/this.nc_pp1); + } + private set nc_pp3(value: number) { + this.nc_pp1 = this.nc_pp2(/*56*/value); + } + static nc_s1: number; + static nc_s2(b: number) { + return c1.nc_s1 + b; + } + static get nc_s3() { + return c1.nc_s2(/*61*/c1.nc_s1); + } + static set nc_s3(value: number) { + c1.nc_s1 = c1.nc_s2(/*63*/value); + } +} +var i1 = new c1(/*65*/); +var i1_p = i1.p1; +var i1_f = i1.p2; +var i1_r = i1.p2(/*71*/20); +var i1_prop = i1.p3; +i1.p3 = i1_prop; +var i1_nc_p = i1.nc_p1; +var i1_ncf = i1.nc_p2; +var i1_ncr = i1.nc_p2(/*81*/20); +var i1_ncprop = i1.nc_p3; +i1.nc_p3 = i1_ncprop; +var i1_s_p = c1.s1; +var i1_s_f = c1.s2; +var i1_s_r = c1.s2(/*92*/20); +var i1_s_prop = c1.s3; +c1.s3 = i1_s_prop; +var i1_s_nc_p = c1.nc_s1; +var i1_s_ncf = c1.nc_s2; +var i1_s_ncr = c1.nc_s2(/*102*/20); +var i1_s_ncprop = c1.nc_s3; +c1.nc_s3 = i1_s_ncprop; +var i1_c = c1; + +class cProperties { + private val: number; + /** getter only property*/ + public get p1() { + return this.val; + } + public get nc_p1() { + return this.val; + } + /**setter only property*/ + public set p2(value: number) { + this.val = value; + } + public set nc_p2(value: number) { + this.val = value; + } +} +var cProperties_i = new cProperties(); +cProperties_i.p2 = cProperties_i.p1; +cProperties_i.nc_p2 = cProperties_i.nc_p1; +class cWithConstructorProperty { + /** + * this is class cWithConstructorProperty's constructor + * @param a this is first parameter a + */ + constructor(/**more info about a*/public a: number) { + var bbbb = 10; + this.a = a + 2 + bbbb; + } +}` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpCommentsClassVS_test.go b/internal/fourslash/tests/manual/signatureHelpCommentsClassVS_test.go new file mode 100644 index 00000000000..72e56a7ad99 --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpCommentsClassVS_test.go @@ -0,0 +1,74 @@ +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 TestSignatureHelpCommentsClassVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `/** This is class c2 without constructor*/ +class c2 { +} +var i2 = new c2(/*3*/); +var i2_c = c2; +class c3 { + /** Constructor comment*/ + constructor() { + } +} +var i3 = new c3(/*8*/); +var i3_c = c3; +/** Class comment*/ +class c4 { + /** Constructor comment*/ + constructor() { + } +} +var i4 = new c4(/*13*/); +var i4_c = c4; +/** Class with statics*/ +class c5 { + static s1: number; +} +var i5 = new c5(/*18*/); +var i5_c = c5; +/** class with statics and constructor*/ +class c6 { + /** s1 comment*/ + static s1: number; + /** constructor comment*/ + constructor() { + } +} +var i6 = new c6(/*23*/); +var i6_c = c6; + +class a { + /** + constructor for a + @param a this is my a + */ + constructor(a: string) { + } +} +new a(/*27*/"Hello"); +namespace m { + export namespace m2 { + /** class comment */ + export class c1 { + /** constructor comment*/ + constructor() { + } + } + } +} +var myVar = new m.m2.c1();` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpCommentsCommentParsingVS_test.go b/internal/fourslash/tests/manual/signatureHelpCommentsCommentParsingVS_test.go new file mode 100644 index 00000000000..df20277186a --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpCommentsCommentParsingVS_test.go @@ -0,0 +1,218 @@ +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 TestSignatureHelpCommentsCommentParsingVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `/// This is simple /// comments +function simple() { +} + +simple( /*1*/); + +/// multiLine /// Comments +/// This is example of multiline /// comments +/// Another multiLine +function multiLine() { +} +multiLine( /*2*/); + +/** this is eg of single line jsdoc style comment */ +function jsDocSingleLine() { +} +jsDocSingleLine(/*3*/); + + +/** this is multiple line jsdoc stule comment +*New line1 +*New Line2*/ +function jsDocMultiLine() { +} +jsDocMultiLine(/*4*/); + +/** multiple line jsdoc comments no longer merge +*New line1 +*New Line2*/ +/** Shoul mege this line as well +* and this too*/ /** Another this one too*/ +function jsDocMultiLineMerge() { +} +jsDocMultiLineMerge(/*5*/); + + +/// Triple slash comment +/** jsdoc comment */ +function jsDocMixedComments1() { +} +jsDocMixedComments1(/*6*/); + +/// Triple slash comment +/** jsdoc comment */ /** another jsDocComment*/ +function jsDocMixedComments2() { +} +jsDocMixedComments2(/*7*/); + +/** jsdoc comment */ /*** triplestar jsDocComment*/ +/// Triple slash comment +function jsDocMixedComments3() { +} +jsDocMixedComments3(/*8*/); + +/** jsdoc comment */ /** another jsDocComment*/ +/// Triple slash comment +/// Triple slash comment 2 +function jsDocMixedComments4() { +} +jsDocMixedComments4(/*9*/); + +/// Triple slash comment 1 +/** jsdoc comment */ /** another jsDocComment*/ +/// Triple slash comment +/// Triple slash comment 2 +function jsDocMixedComments5() { +} +jsDocMixedComments5(/*10*/); + +/** another jsDocComment*/ +/// Triple slash comment 1 +/// Triple slash comment +/// Triple slash comment 2 +/** jsdoc comment */ +function jsDocMixedComments6() { +} +jsDocMixedComments6(/*11*/); + +// This shoulnot be help comment +function noHelpComment1() { +} +noHelpComment1(/*12*/); + +/* This shoulnot be help comment */ +function noHelpComment2() { +} +noHelpComment2(/*13*/); + +function noHelpComment3() { +} +noHelpComment3(/*14*/); +/** Adds two integers and returns the result + * @param {number} a first number + * @param b second number + */ +function sum(a: number, b: number) { + return a + b; +} +sum(/*16*/10, /*17*/20); +/** This is multiplication function + * @param + * @param a first number + * @param b + * @param c { + @param d @anotherTag + * @param e LastParam @anotherTag*/ +function multiply(a: number, b: number, c?: number, d?, e?) { +} +multiply(/*19*/10,/*20*/ 20,/*21*/ 30, /*22*/40, /*23*/50); +/** fn f1 with number +* @param { string} b about b +*/ +function f1(a: number); +function f1(b: string); +/**@param opt optional parameter*/ +function f1(aOrb, opt?) { + return aOrb; +} +f1(/*25*/10); +f1(/*26*/"hello"); + +/** This is subtract function +@param { a +*@param { number | } b this is about b +@param { { () => string; } } c this is optional param c +@param { { () => string; } d this is optional param d +@param { { () => string; } } e this is optional param e +@param { { { () => string; } } f this is optional param f +*/ +function subtract(a: number, b: number, c?: () => string, d?: () => string, e?: () => string, f?: () => string) { +} +subtract(/*28*/10, /*29*/ 20, /*30*/ null, /*31*/ null, /*32*/ null, /*33*/null); +/** this is square function +@paramTag { number } a this is input number of paramTag +@param { number } a this is input number +@returnType { number } it is return type +*/ +function square(a: number) { + return a * a; +} +square(/*34*/10); +/** this is divide function +@param { number} a this is a +@paramTag { number } g this is optional param g +@param { number} b this is b +*/ +function divide(a: number, b: number) { +} +divide(/*35*/10, /*36*/20); +/** +Function returns string concat of foo and bar +@param {string} foo is string +@param {string} bar is second string +*/ +function fooBar(foo: string, bar: string) { + return foo + bar; +} +fooBar(/*37*/"foo",/*38*/"bar"); +/** This is a comment */ +var x; +/** + * This is a comment + */ +var y; +/** this is jsdoc style function with param tag as well as inline parameter help +*@param a it is first parameter +*@param c it is third parameter +*/ +function jsDocParamTest(/** this is inline comment for a */a: number, /** this is inline comment for b*/ b: number, c: number, d: number) { + return /*39*/a + b + c + d; +} +jsDocParamTest(/*40*/30, /*41*/40, /*42*/50, /*43*/60); +/** This is function comment + * And properly aligned comment + */ +function jsDocCommentAlignmentTest1() { +} +jsDocCommentAlignmentTest1(/*45*/); +/** This is function comment + * And aligned with 4 space char margin + */ +function jsDocCommentAlignmentTest2() { +} +jsDocCommentAlignmentTest2(/*46*/); +/** This is function comment + * And aligned with 4 space char margin + * @param {string} a this is info about a + * spanning on two lines and aligned perfectly + * @param b this is info about b + * spanning on two lines and aligned perfectly + * spanning one more line alined perfectly + * spanning another line with more margin + * @param c this is info about b + * not aligned text about parameter will eat only one space + */ +function jsDocCommentAlignmentTest3(a: string, b, c) { +} +jsDocCommentAlignmentTest3(/*47*/"hello",/*48*/1, /*49*/2); +/**/ +class NoQuickInfoClass { +}` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpCommentsFunctionDeclarationVS_test.go b/internal/fourslash/tests/manual/signatureHelpCommentsFunctionDeclarationVS_test.go new file mode 100644 index 00000000000..adef6faac5d --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpCommentsFunctionDeclarationVS_test.go @@ -0,0 +1,34 @@ +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 TestSignatureHelpCommentsFunctionDeclarationVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `/** This comment should appear for foo*/ +function foo() { +} +foo(/*4*/); +/** This is comment for function signature*/ +function fooWithParameters(/** this is comment about a*/a: string, + /** this is comment for b*/ + b: number) { + var d = a; +} +fooWithParameters(/*10*/"a",/*11*/10); +/** +* Does something +* @param a a string +*/ +declare function fn(a: string); +fn(/*12*/"hello");` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpCommentsFunctionExpressionVS_test.go b/internal/fourslash/tests/manual/signatureHelpCommentsFunctionExpressionVS_test.go new file mode 100644 index 00000000000..f7a42bf8b41 --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpCommentsFunctionExpressionVS_test.go @@ -0,0 +1,43 @@ +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 TestSignatureHelpCommentsFunctionExpressionVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `/** lambdaFoo var comment*/ +var lambdaFoo = /** this is lambda comment*/ (/**param a*/a: number, /**param b*/b: number) => a + b; +var lambddaNoVarComment = /** this is lambda multiplication*/ (/**param a*/a: number, /**param b*/b: number) => a * b; +lambdaFoo(/*5*/10, /*6*/20); +function anotherFunc(a: number) { + /** documentation + @param b {string} inner parameter */ + var lambdaVar = /** inner docs */(b: string) => { + var localVar = "Hello "; + return localVar + b; + } + return lambdaVar("World") + a; +} +/** + * On variable + * @param s the first parameter! + * @returns the parameter's length + */ +var assigned = /** + * Summary on expression + * @param s param on expression + * @returns return on expression + */function(/** On parameter */s: string) { + return s.length; +} +assigned(/*18*/"hey");` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpConstructorCallParamPropertiesVS_test.go b/internal/fourslash/tests/manual/signatureHelpConstructorCallParamPropertiesVS_test.go new file mode 100644 index 00000000000..593a7a7a9e9 --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpConstructorCallParamPropertiesVS_test.go @@ -0,0 +1,26 @@ +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 TestSignatureHelpConstructorCallParamPropertiesVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class Circle { + /** + * Initialize a circle. + * @param radius The radius of the circle. + */ + constructor(private radius: number) { + } +} +var a = new Circle(/**/` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpExpandedRestTuplesLocalLabels1VS_test.go b/internal/fourslash/tests/manual/signatureHelpExpandedRestTuplesLocalLabels1VS_test.go new file mode 100644 index 00000000000..5b19a106d3f --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpExpandedRestTuplesLocalLabels1VS_test.go @@ -0,0 +1,80 @@ +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 TestSignatureHelpExpandedRestTuplesLocalLabels1VS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `interface AppleInfo { + color: "green" | "red"; +} + +interface BananaInfo { + curvature: number; +} + +type FruitAndInfo1 = ["apple", AppleInfo] | ["banana", BananaInfo]; + +function logFruitTuple1(...[fruit, info]: FruitAndInfo1) {} +logFruitTuple1(/*1*/); + +function logFruitTuple2(...[, info]: FruitAndInfo1) {} +logFruitTuple2(/*2*/); +logFruitTuple2("apple", /*3*/); + +function logFruitTuple3(...[fruit, ...rest]: FruitAndInfo1) {} +logFruitTuple3(/*4*/); +logFruitTuple3("apple", /*5*/); +function logFruitTuple4(...[fruit, ...[info]]: FruitAndInfo1) {} +logFruitTuple4(/*6*/); +logFruitTuple4("apple", /*7*/); + +type FruitAndInfo2 = ["apple", ...AppleInfo[]] | ["banana", ...BananaInfo[]]; + +function logFruitTuple5(...[fruit, firstInfo]: FruitAndInfo2) {} +logFruitTuple5(/*8*/); +logFruitTuple5("apple", /*9*/); + +function logFruitTuple6(...[fruit, ...fruitInfo]: FruitAndInfo2) {} +logFruitTuple6(/*10*/); +logFruitTuple6("apple", /*11*/); + +type FruitAndInfo3 = ["apple", ...AppleInfo[], number] | ["banana", ...BananaInfo[], number]; + +function logFruitTuple7(...[fruit, fruitInfoOrNumber, secondFruitInfoOrNumber]: FruitAndInfo3) {} +logFruitTuple7(/*12*/); +logFruitTuple7("apple", /*13*/); +logFruitTuple7("apple", { color: "red" }, /*14*/); + +function logFruitTuple8(...[fruit, , secondFruitInfoOrNumber]: FruitAndInfo3) {} +logFruitTuple8(/*15*/); +logFruitTuple8("apple", /*16*/); +logFruitTuple8("apple", { color: "red" }, /*17*/); + +function logFruitTuple9(...[...[fruit, fruitInfoOrNumber, secondFruitInfoOrNumber]]: FruitAndInfo3) {} +logFruitTuple9(/*18*/); +logFruitTuple9("apple", /*19*/); +logFruitTuple9("apple", { color: "red" }, /*20*/); + +function logFruitTuple10(...[fruit, {}, secondFruitInfoOrNumber]: FruitAndInfo3) {} +logFruitTuple10(/*21*/); +logFruitTuple10("apple", /*22*/); +logFruitTuple10("apple", { color: "red" }, /*23*/); + +function logFruitTuple11(...{}: FruitAndInfo3) {} +logFruitTuple11(/*24*/); +logFruitTuple11("apple", /*25*/); +logFruitTuple11("apple", { color: "red" }, /*26*/); +function withPair(...[first, second]: [number, named: string]) {} +withPair(/*27*/); +withPair(101, /*28*/);` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpInferenceJsDocImportTagVS_test.go b/internal/fourslash/tests/manual/signatureHelpInferenceJsDocImportTagVS_test.go new file mode 100644 index 00000000000..9d1aea7c7f1 --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpInferenceJsDocImportTagVS_test.go @@ -0,0 +1,34 @@ +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 TestSignatureHelpInferenceJsDocImportTagVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @allowJS: true +// @checkJs: true +// @module: esnext +// @filename: a.ts +export interface Foo {} +// @filename: b.js +/** + * @import { + * Foo + * } from './a' + */ + +/** + * @param {Foo} a + */ +function foo(a) {} +foo(/**/)` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpIteratorNextVS_test.go b/internal/fourslash/tests/manual/signatureHelpIteratorNextVS_test.go new file mode 100644 index 00000000000..6c8b470c082 --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpIteratorNextVS_test.go @@ -0,0 +1,37 @@ +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 TestSignatureHelpIteratorNextVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @lib: esnext +declare const iterator: Iterator; + +iterator.next(/*1*/); +iterator.next(/*2*/ 0); + +declare const generator: Generator; + +generator.next(/*3*/); +generator.next(/*4*/ 0); + +declare const asyncIterator: AsyncIterator; + +asyncIterator.next(/*5*/); +asyncIterator.next(/*6*/ 0); + +declare const asyncGenerator: AsyncGenerator; + +asyncGenerator.next(/*7*/); +asyncGenerator.next(/*8*/ 0);` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpJSDocCallbackTagVS_test.go b/internal/fourslash/tests/manual/signatureHelpJSDocCallbackTagVS_test.go new file mode 100644 index 00000000000..0d1490189e6 --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpJSDocCallbackTagVS_test.go @@ -0,0 +1,42 @@ +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 TestSignatureHelpJSDocCallbackTagVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @lib: es5 +// @allowNonTsExtensions: true +// @Filename: jsdocCallbackTag.js +/** + * @callback FooHandler - A kind of magic + * @param {string} eventName - So many words + * @param eventName2 {number | string} - Silence is golden + * @param eventName3 - Osterreich mos def + * @return {number} - DIVEKICK + */ +/** + * @type {FooHandler} callback + */ +var t; + +/** + * @callback FooHandler2 - What, another one? + * @param {string=} eventName - it keeps happening + * @param {string} [eventName2] - i WARNED you dog + */ +/** + * @type {FooHandler2} callback + */ +var t2; +t(/*4*/"!", /*5*/12, /*6*/false);` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpJSDocTagsVS_test.go b/internal/fourslash/tests/manual/signatureHelpJSDocTagsVS_test.go new file mode 100644 index 00000000000..a8a31c6f43a --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpJSDocTagsVS_test.go @@ -0,0 +1,75 @@ +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 TestSignatureHelpJSDocTagsVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `/** + * This is class Foo. + * @mytag comment1 comment2 + */ +class Foo { + /** + * This is the constructor. + * @myjsdoctag this is a comment + */ + constructor(value: number) {} + /** + * method1 documentation + * @mytag comment1 comment2 + */ + static method1() {} + /** + * @mytag + */ + method2() {} + /** + * @mytag comment1 comment2 + */ + property1: string; + /** + * @mytag1 some comments + * some more comments about mytag1 + * @mytag2 + * here all the comments are on a new line + * @mytag3 + * @mytag + */ + property2: number; + /** + * @returns {number} a value + */ + method3(): number { return 3; } + /** + * @param {string} foo A value. + * @returns {number} Another value + * @mytag + */ + method4(foo: string): number { return 3; } + /** @mytag */ + method5() {} + /** method documentation + * @mytag a JSDoc tag + */ + newMethod() {} +} +var foo = new Foo(/*10*/4); +Foo.method1(/*11*/); +foo.method2(/*12*/); +foo.method3(/*13*/); +foo.method4(); +foo.property1; +foo.property2; +foo.method5(); +foo.newMet` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpJSMissingPropertyAccessVS_test.go b/internal/fourslash/tests/manual/signatureHelpJSMissingPropertyAccessVS_test.go new file mode 100644 index 00000000000..7664367bccd --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpJSMissingPropertyAccessVS_test.go @@ -0,0 +1,21 @@ +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 TestSignatureHelpJSMissingPropertyAccessVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @allowJs: true +// @checkJs: true +// @Filename: test.js +foo.filter(/**/)` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpRestArgs1VS_test.go b/internal/fourslash/tests/manual/signatureHelpRestArgs1VS_test.go new file mode 100644 index 00000000000..d6348432945 --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpRestArgs1VS_test.go @@ -0,0 +1,26 @@ +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 TestSignatureHelpRestArgs1VS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function fn(a: number, b: number, c: number) {} +const a = [1, 2] as const; +const b = [1] as const; + +fn(...a, /*1*/); +fn(/*2*/, ...a); + +fn(...b, /*3*/); +fn(/*4*/, ...b, /*5*/);` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpRestArgs2VS_test.go b/internal/fourslash/tests/manual/signatureHelpRestArgs2VS_test.go new file mode 100644 index 00000000000..6559c6b7793 --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpRestArgs2VS_test.go @@ -0,0 +1,29 @@ +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 TestSignatureHelpRestArgs2VS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @strict: true +// @allowJs: true +// @checkJs: true +// @filename: index.js +const promisify = function (thisArg, fnName) { + const fn = thisArg[fnName]; + return function () { + return new Promise((resolve) => { + fn.call(thisArg, ...arguments, /*1*/); + }); + }; +};` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpRestArgs3VS_test.go b/internal/fourslash/tests/manual/signatureHelpRestArgs3VS_test.go new file mode 100644 index 00000000000..8d12a7b9193 --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpRestArgs3VS_test.go @@ -0,0 +1,20 @@ +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 TestSignatureHelpRestArgs3VS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @target: esnext +// @lib: esnext +const layers = Object.assign({}, /*1*/...[]);` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpSkippedArgs1VS_test.go b/internal/fourslash/tests/manual/signatureHelpSkippedArgs1VS_test.go new file mode 100644 index 00000000000..9a78c63002d --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpSkippedArgs1VS_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 TestSignatureHelpSkippedArgs1VS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function fn(a: number, b: number, c: number) {} +fn(/*1*/, /*2*/, /*3*/, /*4*/, /*5*/);` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/signatureHelpTypeArguments2VS_test.go b/internal/fourslash/tests/manual/signatureHelpTypeArguments2VS_test.go new file mode 100644 index 00000000000..2c1e95d1b0e --- /dev/null +++ b/internal/fourslash/tests/manual/signatureHelpTypeArguments2VS_test.go @@ -0,0 +1,29 @@ +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 TestSignatureHelpTypeArguments2VS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `/** some documentation + * @template T some documentation 2 + * @template W + * @template U,V others + * @param a ok + * @param b not ok + */ +function f(a: number, b: string, c: boolean): void { } +f string) | ((y: number) => number)) => void; +declare const b: (x: string | number) => void; + +interface Callback { + (x: string): string; + (x: number): number; + (x: string | number): string | number; +} +declare function c(callback: Callback): void; +a((/*1*/) => { + return undefined; +}); + +b(/*2*/); + +c((/*3*/) => {});` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/fourslash/tests/manual/trailingCommaSignatureHelpVS_test.go b/internal/fourslash/tests/manual/trailingCommaSignatureHelpVS_test.go new file mode 100644 index 00000000000..b3faac9ffe4 --- /dev/null +++ b/internal/fourslash/tests/manual/trailingCommaSignatureHelpVS_test.go @@ -0,0 +1,29 @@ +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 TestTrailingCommaSignatureHelpVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `function str(n: number): string; +/** + * Stringifies a number with radix + * @param radix The radix + */ +function str(n: number, radix: number): string; +function str(n: number, radix?: number): string { return ""; } + +str(1, /*a*/) + +declare function f(a: T): T; +f(2, /*b*/);` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineSignatureHelp(t) +} diff --git a/internal/ls/displaypartswriter.go b/internal/ls/displaypartswriter.go new file mode 100644 index 00000000000..80b88f9bc95 --- /dev/null +++ b/internal/ls/displaypartswriter.go @@ -0,0 +1,217 @@ +package ls + +import ( + "strings" + "unicode/utf8" + + "github.com/microsoft/typescript-go/internal/ast" + "github.com/microsoft/typescript-go/internal/core" + "github.com/microsoft/typescript-go/internal/lsp/lsproto" + "github.com/microsoft/typescript-go/internal/printer" + "github.com/microsoft/typescript-go/internal/stringutil" +) + +var _ printer.EmitTextWriter = &displayPartsWriter{} + +// displayPartsWriter implements EmitTextWriter and captures classified text runs +// for VS colorized labels, while also building a plain string. +// When vsCapability is false, only the plain string is built; runs are skipped. +type displayPartsWriter struct { + builder strings.Builder + runs []*lsproto.ClassifiedTextRun + vsCapability bool + lastWritten string +} + +func newDisplayPartsWriter(vsCapability bool) *displayPartsWriter { + return &displayPartsWriter{vsCapability: vsCapability} +} + +func (w *displayPartsWriter) addRun(classification lsproto.ClassificationTypeName, text string) { + if text == "" { + return + } + if w.vsCapability { + w.runs = append(w.runs, &lsproto.ClassifiedTextRun{ + ClassificationTypeName: string(classification), + Text: text, + }) + } + w.lastWritten = text + w.builder.WriteString(text) +} + +// WriteClassified writes text with an explicit classification type. +func (w *displayPartsWriter) WriteClassified(text string, classification lsproto.ClassificationTypeName) { + w.addRun(classification, text) +} + +// WriteFrom copies the accumulated content from another displayPartsWriter. +func (w *displayPartsWriter) WriteFrom(other *displayPartsWriter) { + w.builder.WriteString(other.String()) + if w.vsCapability { + w.runs = append(w.runs, other.GetRuns()...) + } + if other.lastWritten != "" { + w.lastWritten = other.lastWritten + } +} + +func (w *displayPartsWriter) GetRuns() []*lsproto.ClassifiedTextRun { + return w.runs +} + +func (w *displayPartsWriter) String() string { + return w.builder.String() +} + +func (w *displayPartsWriter) Clear() { + w.lastWritten = "" + w.builder.Reset() + w.runs = nil +} + +func (w displayPartsWriter) DecreaseIndent() {} + +func (w displayPartsWriter) GetColumn() core.UTF16Offset { return 0 } + +func (w displayPartsWriter) GetIndent() int { return 0 } + +func (w displayPartsWriter) GetLine() int { return 0 } + +func (w displayPartsWriter) GetTextPos() int { + return w.builder.Len() +} + +func (w displayPartsWriter) HasTrailingComment() bool { return false } + +func (w displayPartsWriter) HasTrailingWhitespace() bool { + if w.builder.Len() == 0 { + return false + } + ch, _ := utf8.DecodeLastRuneInString(w.lastWritten) + if ch == utf8.RuneError { + return false + } + return stringutil.IsWhiteSpaceLike(ch) +} + +func (w displayPartsWriter) IncreaseIndent() {} + +func (w displayPartsWriter) IsAtStartOfLine() bool { return false } + +func (w *displayPartsWriter) RawWrite(s string) { + w.addRun(lsproto.ClassificationTypeNameText, s) +} + +func (w *displayPartsWriter) Write(s string) { + w.addRun(lsproto.ClassificationTypeNameText, s) +} + +func (w *displayPartsWriter) WriteComment(text string) { + // Strada's writeComment uses unknownWrite → SymbolDisplayPartKind.text → "text" + w.addRun(lsproto.ClassificationTypeNameText, text) +} + +func (w *displayPartsWriter) WriteKeyword(text string) { + w.addRun(lsproto.ClassificationTypeNameKeyword, text) +} + +func (w *displayPartsWriter) WriteLine() { + w.addRun(lsproto.ClassificationTypeNameWhiteSpace, " ") +} + +func (w *displayPartsWriter) WriteLineForce(force bool) { + w.addRun(lsproto.ClassificationTypeNameWhiteSpace, " ") +} + +func (w *displayPartsWriter) WriteLiteral(s string) { + // Strada's writeLiteral → SymbolDisplayPartKind.stringLiteral → "string" + w.addRun(lsproto.ClassificationTypeNameString, s) +} + +func (w *displayPartsWriter) WriteOperator(text string) { + w.addRun(lsproto.ClassificationTypeNameOperator, text) +} + +func (w *displayPartsWriter) WriteParameter(text string) { + w.addRun(lsproto.ClassificationTypeNameParameterName, text) +} + +func (w *displayPartsWriter) WriteProperty(text string) { + w.addRun(lsproto.ClassificationTypeNamePropertyName, text) +} + +func (w *displayPartsWriter) WritePunctuation(text string) { + w.addRun(lsproto.ClassificationTypeNamePunctuation, text) +} + +func (w *displayPartsWriter) WriteSpace(text string) { + w.addRun(lsproto.ClassificationTypeNameWhiteSpace, text) +} + +func (w *displayPartsWriter) WriteStringLiteral(text string) { + w.addRun(lsproto.ClassificationTypeNameString, text) +} + +func (w *displayPartsWriter) WriteSymbol(text string, symbol *ast.Symbol) { + classification := classificationForSymbol(symbol) + w.addRun(classification, text) +} + +func (w *displayPartsWriter) WriteTrailingSemicolon(text string) { + w.addRun(lsproto.ClassificationTypeNamePunctuation, text) +} + +// classificationForSymbol determines the Roslyn classification type name based on a symbol's flags. +// Matches the Strada translation chain: displayPartKind() → GetClassificationName(). +func classificationForSymbol(symbol *ast.Symbol) lsproto.ClassificationTypeName { + if symbol == nil { + return lsproto.ClassificationTypeNameText + } + flags := symbol.Flags + switch { + case flags&ast.SymbolFlagsVariable != 0: + if isFirstDeclarationOfSymbolParameter(symbol) { + return lsproto.ClassificationTypeNameParameterName + } + return lsproto.ClassificationTypeNameLocalName + case flags&ast.SymbolFlagsProperty != 0: + return lsproto.ClassificationTypeNamePropertyName + case flags&ast.SymbolFlagsGetAccessor != 0: + return lsproto.ClassificationTypeNamePropertyName + case flags&ast.SymbolFlagsSetAccessor != 0: + return lsproto.ClassificationTypeNamePropertyName + case flags&ast.SymbolFlagsEnumMember != 0: + return lsproto.ClassificationTypeNameFieldName + case flags&ast.SymbolFlagsFunction != 0: + return lsproto.ClassificationTypeNameMethodName + case flags&ast.SymbolFlagsClass != 0: + return lsproto.ClassificationTypeNameClassName + case flags&ast.SymbolFlagsInterface != 0: + return lsproto.ClassificationTypeNameInterfaceName + case flags&ast.SymbolFlagsEnum != 0: + return lsproto.ClassificationTypeNameEnumName + case flags&ast.SymbolFlagsModule != 0: + return lsproto.ClassificationTypeNameModuleName + case flags&ast.SymbolFlagsMethod != 0: + return lsproto.ClassificationTypeNameMethodName + case flags&ast.SymbolFlagsTypeParameter != 0: + return lsproto.ClassificationTypeNameTypeParameterName + case flags&ast.SymbolFlagsTypeAlias != 0: + return lsproto.ClassificationTypeNameIdentifier + case flags&ast.SymbolFlagsAlias != 0: + return lsproto.ClassificationTypeNameIdentifier + default: + return lsproto.ClassificationTypeNameText + } +} + +// isFirstDeclarationOfSymbolParameter checks if the symbol's first declaration is a parameter. +func isFirstDeclarationOfSymbolParameter(symbol *ast.Symbol) bool { + declarations := symbol.Declarations + if len(declarations) == 0 { + return false + } + return declarations[0].Kind == ast.KindParameter +} diff --git a/internal/ls/signaturehelp.go b/internal/ls/signaturehelp.go index 64062e4a79c..34a8116eab9 100644 --- a/internal/ls/signaturehelp.go +++ b/internal/ls/signaturehelp.go @@ -276,6 +276,7 @@ func (l *LanguageService) findSignatureHelpFromNamedDeclarations(ctx context.Con 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) + vsCapability := caps.VSSupportsVisualStudioExtensions enclosingDeclaration := getEnclosingDeclarationFromInvocation(argumentInfo.invocation) if enclosingDeclaration == nil { @@ -301,7 +302,7 @@ func (l *LanguageService) createSignatureHelpItems(ctx context.Context, candidat } items := make([][]signatureInformation, len(candidates)) for i, candidateSignature := range candidates { - items[i] = l.getSignatureHelpItem(candidateSignature, argumentInfo.isTypeParameterList, callTargetDisplayParts.String(), enclosingDeclaration, sourceFile, c, docFormat) + items[i] = l.getSignatureHelpItem(candidateSignature, argumentInfo.isTypeParameterList, callTargetDisplayParts.String(), callTargetSymbol, enclosingDeclaration, sourceFile, c, docFormat, vsCapability) } selectedItemIndex := 0 @@ -360,6 +361,13 @@ func (l *LanguageService) createSignatureHelpItems(ctx context.Context, candidat Parameters: ¶meters, } + // Set VS-specific colorized label if we have classified runs + if len(item.ColorizedRuns) > 0 { + sigInfo.VSColorizedLabel = &lsproto.ClassifiedTextElement{ + Runs: item.ColorizedRuns, + } + } + // If client supports per-signature activeParameter, set it on each SignatureInformation if supportsPerSignatureActiveParam { sigInfo.ActiveParameter = l.computeActiveParameter(item, argumentInfo.argumentIndex, supportsNullActiveParam) @@ -414,15 +422,15 @@ func (l *LanguageService) computeActiveParameter(sig signatureInformation, argum return &lsproto.UintegerOrNull{Uinteger: new(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 { +func (l *LanguageService) getSignatureHelpItem(candidate *checker.Signature, isTypeParameterList bool, callTargetSymbol string, callTargetSym *ast.Symbol, enclosingDeclaration *ast.Node, sourceFile *ast.SourceFile, c *checker.Checker, docFormat lsproto.MarkupKind, vsCapability bool) []signatureInformation { var infos []*signatureHelpItemInfo if isTypeParameterList { - infos = l.itemInfoForTypeParameters(candidate, c, enclosingDeclaration, sourceFile, docFormat) + infos = l.itemInfoForTypeParameters(candidate, c, enclosingDeclaration, sourceFile, docFormat, vsCapability) } else { - infos = l.itemInfoForParameters(candidate, c, enclosingDeclaration, sourceFile, docFormat) + infos = l.itemInfoForParameters(candidate, c, enclosingDeclaration, sourceFile, docFormat, vsCapability) } - suffixDisplayParts := returnTypeToDisplayParts(candidate, c) + suffixDpw := returnTypeToDisplayParts(candidate, c, enclosingDeclaration, sourceFile, vsCapability) // Generate documentation from the signature's declaration var documentation *string @@ -435,34 +443,53 @@ func (l *LanguageService) getSignatureHelpItem(candidate *checker.Signature, isT result := make([]signatureInformation, len(infos)) for i, info := range infos { - var display strings.Builder - display.WriteString(callTargetSymbol) - display.WriteString(info.displayParts) - display.WriteString(suffixDisplayParts) + labelDpw := newDisplayPartsWriter(vsCapability) + if callTargetSymbol != "" { + labelDpw.WriteSymbol(callTargetSymbol, callTargetSym) + } + labelDpw.WriteFrom(info.writer) + labelDpw.WriteFrom(suffixDpw) + result[i] = signatureInformation{ - Label: display.String(), + Label: labelDpw.String(), Documentation: documentation, Parameters: info.parameters, IsVariadic: info.isVariadic, + ColorizedRuns: labelDpw.GetRuns(), } } return result } -func returnTypeToDisplayParts(candidateSignature *checker.Signature, c *checker.Checker) string { - var returnType strings.Builder - returnType.WriteString(": ") +func returnTypeToDisplayParts(candidateSignature *checker.Signature, c *checker.Checker, enclosingDeclaration *ast.Node, sourceFile *ast.SourceFile, vsCapability bool) *displayPartsWriter { + dpw := newDisplayPartsWriter(vsCapability) + + // Add ": " prefix + dpw.WritePunctuation(":") + dpw.WriteSpace(" ") + predicate := c.GetTypePredicateOfSignature(candidateSignature) if predicate != nil { - returnType.WriteString(c.TypePredicateToString(predicate)) + dpw.Write(c.TypePredicateToString(predicate)) } else { - returnType.WriteString(c.TypeToString(c.GetReturnTypeOfSignature(candidateSignature))) + returnType := c.GetReturnTypeOfSignature(candidateSignature) + typeNode := c.TypeToTypeNode(returnType, enclosingDeclaration, signatureHelpNodeBuilderFlags, nil) + if typeNode != nil { + p := printer.NewPrinter(printer.PrinterOptions{NewLine: core.NewLineKindLF}, printer.PrintHandlers{}, printer.NewEmitContext()) + // Use a temporary writer for p.Write since the printer calls Clear() on its writer + tempDpw := newDisplayPartsWriter(vsCapability) + p.Write(typeNode, sourceFile, tempDpw, nil) + dpw.WriteFrom(tempDpw) + } else { + dpw.Write(c.TypeToString(returnType)) + } } - return returnType.String() + return dpw } -func (l *LanguageService) itemInfoForTypeParameters(candidateSignature *checker.Signature, c *checker.Checker, enclosingDeclaration *ast.Node, sourceFile *ast.SourceFile, docFormat lsproto.MarkupKind) []*signatureHelpItemInfo { - printer := printer.NewPrinter(printer.PrinterOptions{NewLine: core.NewLineKindLF}, printer.PrintHandlers{}, nil) +func (l *LanguageService) itemInfoForTypeParameters(candidateSignature *checker.Signature, c *checker.Checker, enclosingDeclaration *ast.Node, sourceFile *ast.SourceFile, docFormat lsproto.MarkupKind, vsCapability bool) []*signatureHelpItemInfo { + emitContext := printer.NewEmitContext() + p := printer.NewPrinter(printer.PrinterOptions{NewLine: core.NewLineKindLF}, printer.PrintHandlers{}, emitContext) var typeParameters []*checker.Type if candidateSignature.Target() != nil { @@ -472,82 +499,105 @@ func (l *LanguageService) itemInfoForTypeParameters(candidateSignature *checker. } signatureHelpTypeParameters := make([]signatureHelpParameter, len(typeParameters)) for i, typeParameter := range typeParameters { - signatureHelpTypeParameters[i] = createSignatureHelpParameterForTypeParameter(typeParameter, sourceFile, enclosingDeclaration, c, printer) + signatureHelpTypeParameters[i] = createSignatureHelpParameterForTypeParameter(typeParameter, sourceFile, enclosingDeclaration, c, p) } thisParameter := []signatureHelpParameter{} if candidateSignature.ThisParameter() != nil { - thisParameter = []signatureHelpParameter{l.createSignatureHelpParameterForParameter(candidateSignature.ThisParameter(), enclosingDeclaration, printer, sourceFile, c, docFormat)} + thisParameter = []signatureHelpParameter{l.createSignatureHelpParameterForParameter(candidateSignature.ThisParameter(), enclosingDeclaration, p, sourceFile, c, docFormat)} } // Creating type parameter display label - var displayParts strings.Builder - displayParts.WriteString(scanner.TokenToString(ast.KindLessThanToken)) + dpw := newDisplayPartsWriter(vsCapability) + + lessThanToken := scanner.TokenToString(ast.KindLessThanToken) + dpw.WritePunctuation(lessThanToken) for i, typeParameter := range signatureHelpTypeParameters { if i > 0 { - displayParts.WriteString(", ") + dpw.WritePunctuation(",") + dpw.WriteSpace(" ") } - displayParts.WriteString(*typeParameter.parameterInfo.Label.String) + label := *typeParameter.parameterInfo.Label.String + dpw.WriteClassified(label, lsproto.ClassificationTypeNameTypeParameterName) } - displayParts.WriteString(scanner.TokenToString(ast.KindGreaterThanToken)) + greaterThanToken := scanner.TokenToString(ast.KindGreaterThanToken) + dpw.WritePunctuation(greaterThanToken) // Creating display label for parameters like, (a: string, b: number) lists := c.GetExpandedParameters(candidateSignature, false) if len(lists) != 0 { - displayParts.WriteString(scanner.TokenToString(ast.KindOpenParenToken)) + openParen := scanner.TokenToString(ast.KindOpenParenToken) + dpw.WritePunctuation(openParen) } result := make([]*signatureHelpItemInfo, len(lists)) for i, parameterList := range lists { - var displayParameters strings.Builder - displayParameters.WriteString(displayParts.String()) + paramDpw := newDisplayPartsWriter(vsCapability) + paramDpw.WriteFrom(dpw) + parameters := thisParameter for j, param := range parameterList { - parameter := l.createSignatureHelpParameterForParameter(param, enclosingDeclaration, printer, sourceFile, c, docFormat) - parameters = append(parameters, parameter) + paramNode := checker.NewNodeBuilder(c, emitContext).SymbolToParameterDeclaration(param, enclosingDeclaration, signatureHelpNodeBuilderFlags, nodebuilder.InternalFlagsNone, nil) + if j > 0 { - displayParameters.WriteString(", ") + paramDpw.WritePunctuation(",") + paramDpw.WriteSpace(" ") } - displayParameters.WriteString(*parameter.parameterInfo.Label.String) + // Use a temporary writer for p.Write since the printer calls Clear() on its writer + tempDpw := newDisplayPartsWriter(vsCapability) + p.Write(paramNode, sourceFile, tempDpw, nil) + paramLabel := tempDpw.String() + paramDpw.WriteFrom(tempDpw) + + parameter := l.createSignatureHelpParameterFromLabel(param, paramLabel, c, docFormat) + parameters = append(parameters, parameter) } - displayParameters.WriteString(scanner.TokenToString(ast.KindCloseParenToken)) + closeParen := scanner.TokenToString(ast.KindCloseParenToken) + paramDpw.WritePunctuation(closeParen) result[i] = &signatureHelpItemInfo{ - isVariadic: false, - parameters: signatureHelpTypeParameters, - displayParts: displayParameters.String(), + isVariadic: false, + parameters: signatureHelpTypeParameters, + writer: paramDpw, } } return result } -func (l *LanguageService) itemInfoForParameters(candidateSignature *checker.Signature, c *checker.Checker, enclosingDeclaratipn *ast.Node, sourceFile *ast.SourceFile, docFormat lsproto.MarkupKind) []*signatureHelpItemInfo { - printer := printer.NewPrinter(printer.PrinterOptions{NewLine: core.NewLineKindLF}, printer.PrintHandlers{}, nil) +func (l *LanguageService) itemInfoForParameters(candidateSignature *checker.Signature, c *checker.Checker, enclosingDeclaratipn *ast.Node, sourceFile *ast.SourceFile, docFormat lsproto.MarkupKind, vsCapability bool) []*signatureHelpItemInfo { + emitContext := printer.NewEmitContext() + p := printer.NewPrinter(printer.PrinterOptions{NewLine: core.NewLineKindLF}, printer.PrintHandlers{}, emitContext) signatureHelpTypeParameters := make([]signatureHelpParameter, len(candidateSignature.TypeParameters())) if len(candidateSignature.TypeParameters()) != 0 { for i, typeParameter := range candidateSignature.TypeParameters() { - signatureHelpTypeParameters[i] = createSignatureHelpParameterForTypeParameter(typeParameter, sourceFile, enclosingDeclaratipn, c, printer) + signatureHelpTypeParameters[i] = createSignatureHelpParameterForTypeParameter(typeParameter, sourceFile, enclosingDeclaratipn, c, p) } } // Creating display label for type parameters like, - var displayParts strings.Builder + dpw := newDisplayPartsWriter(vsCapability) + if len(signatureHelpTypeParameters) != 0 { - displayParts.WriteString(scanner.TokenToString(ast.KindLessThanToken)) + lessThanToken := scanner.TokenToString(ast.KindLessThanToken) + dpw.WritePunctuation(lessThanToken) for i, typeParameter := range signatureHelpTypeParameters { if i > 0 { - displayParts.WriteString(", ") + dpw.WritePunctuation(",") + dpw.WriteSpace(" ") } - displayParts.WriteString(*typeParameter.parameterInfo.Label.String) + label := *typeParameter.parameterInfo.Label.String + dpw.WriteClassified(label, lsproto.ClassificationTypeNameTypeParameterName) } - displayParts.WriteString(scanner.TokenToString(ast.KindGreaterThanToken)) + greaterThanToken := scanner.TokenToString(ast.KindGreaterThanToken) + dpw.WritePunctuation(greaterThanToken) } // Creating display parts for parameters. For example, (a: string, b: number) lists := c.GetExpandedParameters(candidateSignature, false) if len(lists) != 0 { - displayParts.WriteString(scanner.TokenToString(ast.KindOpenParenToken)) + openParen := scanner.TokenToString(ast.KindOpenParenToken) + dpw.WritePunctuation(openParen) } isVariadic := func(parameterList []*ast.Symbol) bool { @@ -563,32 +613,41 @@ func (l *LanguageService) itemInfoForParameters(candidateSignature *checker.Sign result := make([]*signatureHelpItemInfo, len(lists)) for i, parameterList := range lists { parameters := make([]signatureHelpParameter, len(parameterList)) - var displayParameters strings.Builder - displayParameters.WriteString(displayParts.String()) + paramDpw := newDisplayPartsWriter(vsCapability) + paramDpw.WriteFrom(dpw) + for j, param := range parameterList { - parameter := l.createSignatureHelpParameterForParameter(param, enclosingDeclaratipn, printer, sourceFile, c, docFormat) - parameters[j] = parameter + paramNode := checker.NewNodeBuilder(c, emitContext).SymbolToParameterDeclaration(param, enclosingDeclaratipn, signatureHelpNodeBuilderFlags, nodebuilder.InternalFlagsNone, nil) + if j > 0 { - displayParameters.WriteString(", ") + paramDpw.WritePunctuation(",") + paramDpw.WriteSpace(" ") } - displayParameters.WriteString(*parameter.parameterInfo.Label.String) + // Use a temporary writer for p.Write since the printer calls Clear() on its writer + tempDpw := newDisplayPartsWriter(vsCapability) + p.Write(paramNode, sourceFile, tempDpw, nil) + paramLabel := tempDpw.String() + paramDpw.WriteFrom(tempDpw) + + parameter := l.createSignatureHelpParameterFromLabel(param, paramLabel, c, docFormat) + parameters[j] = parameter } - displayParameters.WriteString(scanner.TokenToString(ast.KindCloseParenToken)) + closeParen := scanner.TokenToString(ast.KindCloseParenToken) + paramDpw.WritePunctuation(closeParen) result[i] = &signatureHelpItemInfo{ - isVariadic: isVariadic(parameterList), - parameters: parameters, - displayParts: displayParameters.String(), + isVariadic: isVariadic(parameterList), + parameters: parameters, + writer: paramDpw, } - } return result } const signatureHelpNodeBuilderFlags = nodebuilder.FlagsOmitParameterModifiers | nodebuilder.FlagsIgnoreErrors | nodebuilder.FlagsUseAliasDefinedOutsideCurrentScope -func (l *LanguageService) createSignatureHelpParameterForParameter(parameter *ast.Symbol, enclosingDeclaratipn *ast.Node, p *printer.Printer, sourceFile *ast.SourceFile, c *checker.Checker, docFormat lsproto.MarkupKind) signatureHelpParameter { - display := p.Emit(checker.NewNodeBuilder(c, printer.NewEmitContext()).SymbolToParameterDeclaration(parameter, enclosingDeclaratipn, signatureHelpNodeBuilderFlags, nodebuilder.InternalFlagsNone, nil), sourceFile) +// createSignatureHelpParameterFromLabel creates a signatureHelpParameter from a pre-computed label string. +func (l *LanguageService) createSignatureHelpParameterFromLabel(parameter *ast.Symbol, label string, c *checker.Checker, docFormat lsproto.MarkupKind) signatureHelpParameter { isOptional := parameter.CheckFlags&ast.CheckFlagsOptionalParameter != 0 isRest := parameter.CheckFlags&ast.CheckFlagsRestParameter != 0 var documentation *lsproto.StringOrMarkupContent @@ -605,7 +664,7 @@ func (l *LanguageService) createSignatureHelpParameterForParameter(parameter *as } return signatureHelpParameter{ parameterInfo: &lsproto.ParameterInformation{ - Label: lsproto.StringOrTuple{String: &display}, + Label: lsproto.StringOrTuple{String: &label}, Documentation: documentation, }, isRest: isRest, @@ -613,6 +672,11 @@ func (l *LanguageService) createSignatureHelpParameterForParameter(parameter *as } } +func (l *LanguageService) createSignatureHelpParameterForParameter(parameter *ast.Symbol, enclosingDeclaratipn *ast.Node, p *printer.Printer, sourceFile *ast.SourceFile, c *checker.Checker, docFormat lsproto.MarkupKind) signatureHelpParameter { + display := p.Emit(checker.NewNodeBuilder(c, printer.NewEmitContext()).SymbolToParameterDeclaration(parameter, enclosingDeclaratipn, signatureHelpNodeBuilderFlags, nodebuilder.InternalFlagsNone, nil), sourceFile) + return l.createSignatureHelpParameterFromLabel(parameter, display, c, docFormat) +} + func createSignatureHelpParameterForTypeParameter(t *checker.Type, sourceFile *ast.SourceFile, enclosingDeclaration *ast.Node, c *checker.Checker, p *printer.Printer) signatureHelpParameter { display := p.Emit(checker.NewNodeBuilder(c, printer.NewEmitContext()).TypeParameterToDeclaration(t, enclosingDeclaration, signatureHelpNodeBuilderFlags, nodebuilder.InternalFlagsNone, nil), sourceFile) return signatureHelpParameter{ @@ -638,12 +702,14 @@ type signatureInformation struct { Parameters []signatureHelpParameter // Needed only here, not in lsp IsVariadic bool + // Classified text runs for VS colorized label + ColorizedRuns []*lsproto.ClassifiedTextRun } type signatureHelpItemInfo struct { - isVariadic bool - parameters []signatureHelpParameter - displayParts string + isVariadic bool + parameters []signatureHelpParameter + writer *displayPartsWriter } type signatureHelpParameter struct { diff --git a/internal/lsp/lsproto/_generate/generate.mts b/internal/lsp/lsproto/_generate/generate.mts index f4e2e4a9497..33b6c7bf3fe 100755 --- a/internal/lsp/lsproto/_generate/generate.mts +++ b/internal/lsp/lsproto/_generate/generate.mts @@ -464,6 +464,45 @@ const customStructures: Structure[] = [ ], documentation: "Parameters for the custom/textDocument/multiDocumentHighlight request.", }, + { + name: "ClassifiedTextRun", + properties: [ + { + name: "ClassificationTypeName", + type: { kind: "base", name: "string" }, + documentation: "The classification type name (e.g. 'keyword', 'class name', 'parameter name').", + }, + { + name: "Text", + type: { kind: "base", name: "string" }, + documentation: "The text content of this run.", + }, + { + name: "MarkerTagType", + type: { kind: "base", name: "string" }, + optional: true, + documentation: "Optional marker tag type.", + }, + { + name: "Style", + type: { kind: "base", name: "integer" }, + omitzeroValue: true, + documentation: "The style of this text run.", + }, + ], + documentation: "A classified text run with text and classification type, used for colorized display in VS.", + }, + { + name: "ClassifiedTextElement", + properties: [ + { + name: "Runs", + type: { kind: "array", element: { kind: "reference", name: "ClassifiedTextRun" } }, + documentation: "The classified text runs that make up this element.", + }, + ], + documentation: "A classified text element containing an array of classified text runs, used for colorized labels in VS.", + }, ]; const customEnumerations: Enumeration[] = [ @@ -514,9 +553,33 @@ const customEnumerations: Enumeration[] = [ { name: "NotAllowed", value: 4, documentation: "Import cannot be marked type-only." }, ], }, + { + name: "ClassificationTypeName", + type: { kind: "base", name: "string" }, + values: [ + { name: "Keyword", value: "keyword", documentation: "Language keyword (e.g., function, const, class)." }, + { name: "Punctuation", value: "punctuation", documentation: "Punctuation characters (e.g., parentheses, commas, semicolons)." }, + { name: "Operator", value: "operator", documentation: "Operators (e.g., =, +, ?)." }, + { name: "WhiteSpace", value: "whitespace", documentation: "Whitespace including spaces and line breaks." }, + { name: "Text", value: "text", documentation: "Plain text with no special classification." }, + { name: "String", value: "string", documentation: "String and literal values." }, + { name: "Number", value: "number", documentation: "Numeric literal values." }, + { name: "Comment", value: "comment", documentation: "Comment text." }, + { name: "ClassName", value: "class name", documentation: "Class names." }, + { name: "InterfaceName", value: "interface name", documentation: "Interface names." }, + { name: "EnumName", value: "enum name", documentation: "Enum names." }, + { name: "ModuleName", value: "module name", documentation: "Module/namespace names." }, + { name: "MethodName", value: "method name", documentation: "Method and function names." }, + { name: "ParameterName", value: "parameter name", documentation: "Parameter names." }, + { name: "PropertyName", value: "property name", documentation: "Property and accessor names." }, + { name: "FieldName", value: "field name", documentation: "Field names (e.g., enum members)." }, + { name: "LocalName", value: "local name", documentation: "Local variable names." }, + { name: "TypeParameterName", value: "type parameter name", documentation: "Type parameter names." }, + { name: "Identifier", value: "identifier", documentation: "General identifiers (e.g., type aliases, imports)." }, + ], + documentation: "Roslyn classification type names used by VS for syntax coloring in tooltips and other UI elements.", + }, ]; - -// Custom requests to add to the model (tsgo-specific) const customRequests: Request[] = [ { method: "custom/runGC", @@ -788,6 +851,16 @@ function patchAndPreprocessModel() { }); } + // Patch SignatureInformation to add VS-specific colorized label + if (structure.name === "SignatureInformation") { + structure.properties.push({ + name: "_vs_colorizedLabel", + type: { kind: "reference", name: "ClassifiedTextElement" }, + optional: true, + documentation: "A colorized label for the signature, providing classified text runs for VS syntax coloring.", + }); + } + // Patch ServerCapabilities to add custom tsgo capability flags if (structure.name === "ServerCapabilities") { structure.properties.push({ diff --git a/internal/lsp/lsproto/lsp_generated.go b/internal/lsp/lsproto/lsp_generated.go index 21682314fd5..9acd888fa10 100644 --- a/internal/lsp/lsproto/lsp_generated.go +++ b/internal/lsp/lsproto/lsp_generated.go @@ -18625,6 +18625,9 @@ type SignatureInformation struct { // // Since: 3.16.0 ActiveParameter *UintegerOrNull `json:"activeParameter,omitzero"` + + // A colorized label for the signature, providing classified text runs for VS syntax coloring. + VSColorizedLabel *ClassifiedTextElement `json:"_vs_colorizedLabel,omitzero"` } var _ json.UnmarshalerFrom = (*SignatureInformation)(nil) @@ -18672,6 +18675,13 @@ func (s *SignatureInformation) UnmarshalJSONFrom(dec *json.Decoder) error { if err := json.UnmarshalDecode(dec, &s.ActiveParameter); err != nil { return err } + case `"_vs_colorizedLabel"`: + if dec.PeekKind() == 'n' { + return errNull("_vs_colorizedLabel") + } + if err := json.UnmarshalDecode(dec, &s.VSColorizedLabel); err != nil { + return err + } default: if err := dec.SkipValue(); err != nil { return err @@ -29573,6 +29583,148 @@ func (s *MultiDocumentHighlightParams) UnmarshalJSONFrom(dec *json.Decoder) erro return nil } +// A classified text run with text and classification type, used for colorized display in VS. +type ClassifiedTextRun struct { + // The classification type name (e.g. 'keyword', 'class name', 'parameter name'). + ClassificationTypeName string `json:"ClassificationTypeName"` + + // The text content of this run. + Text string `json:"Text"` + + // Optional marker tag type. + MarkerTagType *string `json:"MarkerTagType,omitzero"` + + // The style of this text run. + Style int32 `json:"Style,omitzero"` +} + +var _ json.UnmarshalerFrom = (*ClassifiedTextRun)(nil) + +func (s *ClassifiedTextRun) UnmarshalJSONFrom(dec *json.Decoder) error { + const ( + missingClassificationTypeName uint = 1 << iota + missingText + _missingLast + ) + missing := _missingLast - 1 + + if k := dec.PeekKind(); k != '{' { + return errNotObject(k) + } + if _, err := dec.ReadToken(); err != nil { + return err + } + + for dec.PeekKind() != '}' { + name, err := dec.ReadValue() + if err != nil { + return err + } + switch string(name) { + case `"ClassificationTypeName"`: + missing &^= missingClassificationTypeName + if err := json.UnmarshalDecode(dec, &s.ClassificationTypeName); err != nil { + return err + } + case `"Text"`: + missing &^= missingText + if err := json.UnmarshalDecode(dec, &s.Text); err != nil { + return err + } + case `"MarkerTagType"`: + if dec.PeekKind() == 'n' { + return errNull("MarkerTagType") + } + if err := json.UnmarshalDecode(dec, &s.MarkerTagType); err != nil { + return err + } + case `"Style"`: + if err := json.UnmarshalDecode(dec, &s.Style); err != nil { + return err + } + default: + if err := dec.SkipValue(); err != nil { + return err + } + } + } + + if _, err := dec.ReadToken(); err != nil { + return err + } + + if missing != 0 { + var missingProps []string + if missing&missingClassificationTypeName != 0 { + missingProps = append(missingProps, "ClassificationTypeName") + } + if missing&missingText != 0 { + missingProps = append(missingProps, "Text") + } + return errMissing(missingProps) + } + + return nil +} + +// A classified text element containing an array of classified text runs, used for colorized labels in VS. +type ClassifiedTextElement struct { + // The classified text runs that make up this element. + Runs []*ClassifiedTextRun `json:"Runs"` +} + +var _ json.UnmarshalerFrom = (*ClassifiedTextElement)(nil) + +func (s *ClassifiedTextElement) UnmarshalJSONFrom(dec *json.Decoder) error { + const ( + missingRuns uint = 1 << iota + _missingLast + ) + missing := _missingLast - 1 + + if k := dec.PeekKind(); k != '{' { + return errNotObject(k) + } + if _, err := dec.ReadToken(); err != nil { + return err + } + + for dec.PeekKind() != '}' { + name, err := dec.ReadValue() + if err != nil { + return err + } + switch string(name) { + case `"Runs"`: + missing &^= missingRuns + if dec.PeekKind() == 'n' { + return errNull("Runs") + } + if err := json.UnmarshalDecode(dec, &s.Runs); err != nil { + return err + } + default: + if err := dec.SkipValue(); err != nil { + return err + } + } + } + + if _, err := dec.ReadToken(); err != nil { + return err + } + + if missing != 0 { + var missingProps []string + if missing&missingRuns != 0 { + missingProps = append(missingProps, "Runs") + } + return errMissing(missingProps) + } + + return nil +} + // CallHierarchyItemData is a placeholder for custom data preserved on a CallHierarchyItem. type CallHierarchyItemData struct{} @@ -30801,6 +30953,50 @@ func (e AddAsTypeOnly) String() string { } } +// Roslyn classification type names used by VS for syntax coloring in tooltips and other UI elements. +type ClassificationTypeName string + +const ( + // Language keyword (e.g., function, const, class). + ClassificationTypeNameKeyword ClassificationTypeName = "keyword" + // Punctuation characters (e.g., parentheses, commas, semicolons). + ClassificationTypeNamePunctuation ClassificationTypeName = "punctuation" + // Operators (e.g., =, +, ?). + ClassificationTypeNameOperator ClassificationTypeName = "operator" + // Whitespace including spaces and line breaks. + ClassificationTypeNameWhiteSpace ClassificationTypeName = "whitespace" + // Plain text with no special classification. + ClassificationTypeNameText ClassificationTypeName = "text" + // String and literal values. + ClassificationTypeNameString ClassificationTypeName = "string" + // Numeric literal values. + ClassificationTypeNameNumber ClassificationTypeName = "number" + // Comment text. + ClassificationTypeNameComment ClassificationTypeName = "comment" + // Class names. + ClassificationTypeNameClassName ClassificationTypeName = "class name" + // Interface names. + ClassificationTypeNameInterfaceName ClassificationTypeName = "interface name" + // Enum names. + ClassificationTypeNameEnumName ClassificationTypeName = "enum name" + // Module/namespace names. + ClassificationTypeNameModuleName ClassificationTypeName = "module name" + // Method and function names. + ClassificationTypeNameMethodName ClassificationTypeName = "method name" + // Parameter names. + ClassificationTypeNameParameterName ClassificationTypeName = "parameter name" + // Property and accessor names. + ClassificationTypeNamePropertyName ClassificationTypeName = "property name" + // Field names (e.g., enum members). + ClassificationTypeNameFieldName ClassificationTypeName = "field name" + // Local variable names. + ClassificationTypeNameLocalName ClassificationTypeName = "local name" + // Type parameter names. + ClassificationTypeNameTypeParameterName ClassificationTypeName = "type parameter name" + // General identifiers (e.g., type aliases, imports). + ClassificationTypeNameIdentifier ClassificationTypeName = "identifier" +) + func unmarshalParams(method Method, data []byte) (any, error) { switch method { case MethodTextDocumentImplementation: diff --git a/testdata/baselines/reference/fourslash/signatureHelp/jsDocDontBreakWithNamespacesVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/jsDocDontBreakWithNamespacesVS.baseline new file mode 100644 index 00000000000..de0cb00816f --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/jsDocDontBreakWithNamespacesVS.baseline @@ -0,0 +1,175 @@ +// === SignatureHelp === +=== /jsDocDontBreakWithNamespaces.js === +// /** +// * @returns {module:@nodefuel/web~Webserver~wsServer#hello} Websocket server object +// */ +// function foo() { } +// foo(''); +// ^ +// | ---------------------------------------------------------------------- +// | foo(): module +// | ---------------------------------------------------------------------- +// +// /** +// * @type {module:xxxxx} */ +// */ +// function bar() { } +// bar(''); +// ^ +// | ---------------------------------------------------------------------- +// | bar(): void +// | ---------------------------------------------------------------------- +// +// /** @type {function(module:xxxx, module:xxxx): module:xxxxx} */ +// function zee() { } +// zee(''); +// ^ +// | ---------------------------------------------------------------------- +// | zee(): void +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 117, + "LSPosition": { + "line": 4, + "character": 6 + }, + "Name": "foo", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "foo(): module", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "foo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "module" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 181, + "LSPosition": { + "line": 10, + "character": 6 + }, + "Name": "bar", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "bar(): void", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "bar" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 274, + "LSPosition": { + "line": 14, + "character": 6 + }, + "Name": "zee", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "zee(): void", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "zee" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures5VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures5VS.baseline new file mode 100644 index 00000000000..b4559549927 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures5VS.baseline @@ -0,0 +1,201 @@ +// === SignatureHelp === +=== /Foo.js === +// /** +// * Filters a path based on a regexp or glob pattern. +// * @param {String} basePath The base path where the search will be performed. +// * @param {String} pattern A string defining a regexp of a glob pattern. +// * @param {String} type The search pattern type, can be a regexp or a glob. +// * @param {Object} options A object containing options to the search. +// * @return {Array} A list containing the filtered paths. +// */ +// function pathFilter(basePath, pattern, type, options){ +// //... +// } +// pathFilter('foo', 'bar', 'baz', {}); +// ^ +// | ---------------------------------------------------------------------- +// | pathFilter(**basePath: string**, pattern: string, type: string, options: Object): any[] +// | - `basePath: string`: The base path where the search will be performed. + +// | Filters a path based on a regexp or glob pattern. +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 489, + "LSPosition": { + "line": 11, + "character": 11 + }, + "Name": "", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "pathFilter(basePath: string, pattern: string, type: string, options: Object): any[]", + "documentation": { + "kind": "markdown", + "value": "Filters a path based on a regexp or glob pattern." + }, + "parameters": [ + { + "label": "basePath: string", + "documentation": { + "kind": "markdown", + "value": "The base path where the search will be performed.\n" + } + }, + { + "label": "pattern: string", + "documentation": { + "kind": "markdown", + "value": "A string defining a regexp of a glob pattern.\n" + } + }, + { + "label": "type: string", + "documentation": { + "kind": "markdown", + "value": "The search pattern type, can be a regexp or a glob.\n" + } + }, + { + "label": "options: Object", + "documentation": { + "kind": "markdown", + "value": "A object containing options to the search.\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "pathFilter" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "basePath" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "pattern" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "type" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "options" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "Object" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures6VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures6VS.baseline new file mode 100644 index 00000000000..8c0ca6efa42 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures6VS.baseline @@ -0,0 +1,796 @@ +// === SignatureHelp === +=== /Foo.js === +// /** +// * @param {string} p1 - A string param +// * @param {string?} p2 - An optional param +// * @param {string} [p3] - Another optional param +// * @param {string} [p4="test"] - An optional param with a default value +// */ +// function f1(p1, p2, p3, p4){} +// f1('foo', 'bar', 'baz', 'qux'); +// ^ +// | ---------------------------------------------------------------------- +// | f1(**p1: string**, p2: string | null, p3?: string, p4?: string): void +// | - `p1: string`: - A string param + +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | f1(p1: string, **p2: string | null**, p3?: string, p4?: string): void +// | - `p2: string | null`: - An optional param + +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | f1(p1: string, p2: string | null, **p3?: string**, p4?: string): void +// | - `p3?: string`: - Another optional param + +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | f1(p1: string, p2: string | null, p3?: string, **p4?: string**): void +// | - `p4?: string`: - An optional param with a default value + +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 244, + "LSPosition": { + "line": 7, + "character": 3 + }, + "Name": "1", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f1(p1: string, p2: string | null, p3?: string, p4?: string): void", + "parameters": [ + { + "label": "p1: string", + "documentation": { + "kind": "markdown", + "value": "- A string param\n" + } + }, + { + "label": "p2: string | null", + "documentation": { + "kind": "markdown", + "value": "- An optional param\n" + } + }, + { + "label": "p3?: string", + "documentation": { + "kind": "markdown", + "value": "- Another optional param\n" + } + }, + { + "label": "p4?: string", + "documentation": { + "kind": "markdown", + "value": "- An optional param with a default value\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "p1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "p2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "|" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "null" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "p3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "p4" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 251, + "LSPosition": { + "line": 7, + "character": 10 + }, + "Name": "2", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f1(p1: string, p2: string | null, p3?: string, p4?: string): void", + "parameters": [ + { + "label": "p1: string", + "documentation": { + "kind": "markdown", + "value": "- A string param\n" + } + }, + { + "label": "p2: string | null", + "documentation": { + "kind": "markdown", + "value": "- An optional param\n" + } + }, + { + "label": "p3?: string", + "documentation": { + "kind": "markdown", + "value": "- Another optional param\n" + } + }, + { + "label": "p4?: string", + "documentation": { + "kind": "markdown", + "value": "- An optional param with a default value\n" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "p1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "p2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "|" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "null" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "p3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "p4" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 258, + "LSPosition": { + "line": 7, + "character": 17 + }, + "Name": "3", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f1(p1: string, p2: string | null, p3?: string, p4?: string): void", + "parameters": [ + { + "label": "p1: string", + "documentation": { + "kind": "markdown", + "value": "- A string param\n" + } + }, + { + "label": "p2: string | null", + "documentation": { + "kind": "markdown", + "value": "- An optional param\n" + } + }, + { + "label": "p3?: string", + "documentation": { + "kind": "markdown", + "value": "- Another optional param\n" + } + }, + { + "label": "p4?: string", + "documentation": { + "kind": "markdown", + "value": "- An optional param with a default value\n" + } + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "p1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "p2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "|" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "null" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "p3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "p4" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 265, + "LSPosition": { + "line": 7, + "character": 24 + }, + "Name": "4", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f1(p1: string, p2: string | null, p3?: string, p4?: string): void", + "parameters": [ + { + "label": "p1: string", + "documentation": { + "kind": "markdown", + "value": "- A string param\n" + } + }, + { + "label": "p2: string | null", + "documentation": { + "kind": "markdown", + "value": "- An optional param\n" + } + }, + { + "label": "p3?: string", + "documentation": { + "kind": "markdown", + "value": "- Another optional param\n" + } + }, + { + "label": "p4?: string", + "documentation": { + "kind": "markdown", + "value": "- An optional param with a default value\n" + } + } + ], + "activeParameter": 3, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "p1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "p2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "|" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "null" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "p3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "p4" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/jsdocReturnsTagVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/jsdocReturnsTagVS.baseline new file mode 100644 index 00000000000..4ad15c9acf1 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/jsdocReturnsTagVS.baseline @@ -0,0 +1,127 @@ +// === SignatureHelp === +=== /dummy.js === +// /** +// * Find an item +// * @template T +// * @param {T[]} l +// * @param {T} x +// * @returns {?T} The names of the found item(s). +// */ +// function find(l, x) { +// } +// find(''); +// ^ +// | ---------------------------------------------------------------------- +// | find(**l: any[]**, x: any): any +// | Find an item +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 154, + "LSPosition": { + "line": 9, + "character": 7 + }, + "Name": "", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "find(l: any[], x: any): any", + "documentation": { + "kind": "markdown", + "value": "Find an item" + }, + "parameters": [ + { + "label": "l: any[]" + }, + { + "label": "x: any" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "find" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "l" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "x" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTags13VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTags13VS.baseline new file mode 100644 index 00000000000..2a8737abcab --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTags13VS.baseline @@ -0,0 +1,278 @@ +// === SignatureHelp === +=== /a.js === +// /** +// * First overload +// * @overload +// * @param {number} a +// * @returns {void} +// */ +// +// /** +// * Second overload +// * @overload +// * @param {string} a +// * @returns {void} +// */ +// +// /** +// * @param {string | number} a +// * @returns {void} +// */ +// function f(a) {} +// +// f(1); +// ^ +// | ---------------------------------------------------------------------- +// | f(**a: number**): void +// | ---------------------------------------------------------------------- +// f(""); +// ^ +// | ---------------------------------------------------------------------- +// | f(**a: string**): void +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 238, + "LSPosition": { + "line": 20, + "character": 2 + }, + "Name": "a", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f(a: number): void", + "parameters": [ + { + "label": "a: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "f(a: string): void", + "parameters": [ + { + "label": "a: string" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 244, + "LSPosition": { + "line": 21, + "character": 2 + }, + "Name": "b", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f(a: number): void", + "parameters": [ + { + "label": "a: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "f(a: string): void", + "parameters": [ + { + "label": "a: string" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 1 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTextFormatting1VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTextFormatting1VS.baseline new file mode 100644 index 00000000000..f750e66c7a2 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTextFormatting1VS.baseline @@ -0,0 +1,595 @@ +// === SignatureHelp === +=== /quickInfoJsDocTextFormatting1VS.ts === +// /** +// * @param {number} var1 **Highlighted text** +// * @param {string} var2 Another **Highlighted text** +// */ +// function f1(var1, var2) { } +// +// /** +// * @param {number} var1 *Regular text with an asterisk +// * @param {string} var2 Another *Regular text with an asterisk +// */ +// function f2(var1, var2) { } +// +// /** +// * @param {number} var1 +// * *Regular text with an asterisk +// * @param {string} var2 +// * Another *Regular text with an asterisk +// */ +// function f3(var1, var2) { } +// +// /** +// * @param {number} var1 +// * **Highlighted text** +// * @param {string} var2 +// * Another **Highlighted text** +// */ +// function f4(var1, var2) { } +// +// /** +// * @param {number} var1 +// **Highlighted text** +// * @param {string} var2 +// Another **Highlighted text** +// */ +// function f5(var1, var2) { } +// +// f1(); +// ^ +// | ---------------------------------------------------------------------- +// | f1(**var1: any**, var2: any): void +// | - `var1: any`: **Highlighted text** + +// | ---------------------------------------------------------------------- +// f2(); +// ^ +// | ---------------------------------------------------------------------- +// | f2(**var1: any**, var2: any): void +// | - `var1: any`: *Regular text with an asterisk + +// | ---------------------------------------------------------------------- +// f3(); +// ^ +// | ---------------------------------------------------------------------- +// | f3(**var1: any**, var2: any): void +// | - `var1: any`: *Regular text with an asterisk + +// | ---------------------------------------------------------------------- +// f4(); +// ^ +// | ---------------------------------------------------------------------- +// | f4(**var1: any**, var2: any): void +// | - `var1: any`: **Highlighted text** + +// | ---------------------------------------------------------------------- +// f5(); +// ^ +// | ---------------------------------------------------------------------- +// | f5(**var1: any**, var2: any): void +// | - `var1: any`: **Highlighted text** + +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 737, + "LSPosition": { + "line": 36, + "character": 3 + }, + "Name": "1", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f1(var1: any, var2: any): void", + "parameters": [ + { + "label": "var1: any", + "documentation": { + "kind": "markdown", + "value": "**Highlighted text**\n" + } + }, + { + "label": "var2: any", + "documentation": { + "kind": "markdown", + "value": "Another **Highlighted text**\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "var1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "var2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 743, + "LSPosition": { + "line": 37, + "character": 3 + }, + "Name": "2", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f2(var1: any, var2: any): void", + "parameters": [ + { + "label": "var1: any", + "documentation": { + "kind": "markdown", + "value": "*Regular text with an asterisk\n" + } + }, + { + "label": "var2: any", + "documentation": { + "kind": "markdown", + "value": "Another *Regular text with an asterisk\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "var1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "var2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 749, + "LSPosition": { + "line": 38, + "character": 3 + }, + "Name": "3", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f3(var1: any, var2: any): void", + "parameters": [ + { + "label": "var1: any", + "documentation": { + "kind": "markdown", + "value": "*Regular text with an asterisk\n" + } + }, + { + "label": "var2: any", + "documentation": { + "kind": "markdown", + "value": "Another *Regular text with an asterisk\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "var1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "var2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 755, + "LSPosition": { + "line": 39, + "character": 3 + }, + "Name": "4", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f4(var1: any, var2: any): void", + "parameters": [ + { + "label": "var1: any", + "documentation": { + "kind": "markdown", + "value": "**Highlighted text**\n" + } + }, + { + "label": "var2: any", + "documentation": { + "kind": "markdown", + "value": "Another **Highlighted text**\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f4" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "var1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "var2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 761, + "LSPosition": { + "line": 40, + "character": 3 + }, + "Name": "5", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f5(var1: any, var2: any): void", + "parameters": [ + { + "label": "var1: any", + "documentation": { + "kind": "markdown", + "value": "**Highlighted text**\n" + } + }, + { + "label": "var2: any", + "documentation": { + "kind": "markdown", + "value": "Another **Highlighted text**\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f5" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "var1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "var2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAfterParameterVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAfterParameterVS.baseline new file mode 100644 index 00000000000..02ebb0d85f3 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAfterParameterVS.baseline @@ -0,0 +1,1532 @@ +// === SignatureHelp === +=== /signatureHelpAfterParameterVS.ts === +// type Type = (a, b, c) => void +// const a: Type = (a, b) => {} +// ^ +// | ---------------------------------------------------------------------- +// | Type(**a: any**, b: any, c: any): void +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | Type(a: any, **b: any**, c: any): void +// | ---------------------------------------------------------------------- +// const b: Type = function (a, b) {} +// ^ +// | ---------------------------------------------------------------------- +// | Type(**a: any**, b: any, c: any): void +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | Type(a: any, **b: any**, c: any): void +// | ---------------------------------------------------------------------- +// const c: Type = ({ a: { b }} = { }, [b], ...c) => {} +// ^ +// | ---------------------------------------------------------------------- +// | Type(**a: any**, b: any, c: any): void +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | Type(**a: any**, b: any, c: any): void +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | Type(**a: any**, b: any, c: any): void +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | Type(**a: any**, b: any, c: any): void +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | Type(a: any, **b: any**, c: any): void +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | Type(a: any, **b: any**, c: any): void +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | Type(a: any, b: any, **c: any**): void +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | Type(a: any, b: any, **c: any**): void +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 48, + "LSPosition": { + "line": 1, + "character": 18 + }, + "Name": "1", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "Type(a: any, b: any, c: any): void", + "parameters": [ + { + "label": "a: any" + }, + { + "label": "b: any" + }, + { + "label": "c: any" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "identifier", + "Text": "Type" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 51, + "LSPosition": { + "line": 1, + "character": 21 + }, + "Name": "2", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "Type(a: any, b: any, c: any): void", + "parameters": [ + { + "label": "a: any" + }, + { + "label": "b: any" + }, + { + "label": "c: any" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "identifier", + "Text": "Type" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 86, + "LSPosition": { + "line": 2, + "character": 27 + }, + "Name": "3", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "Type(a: any, b: any, c: any): void", + "parameters": [ + { + "label": "a: any" + }, + { + "label": "b: any" + }, + { + "label": "c: any" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "identifier", + "Text": "Type" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 89, + "LSPosition": { + "line": 2, + "character": 30 + }, + "Name": "4", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "Type(a: any, b: any, c: any): void", + "parameters": [ + { + "label": "a: any" + }, + { + "label": "b: any" + }, + { + "label": "c: any" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "identifier", + "Text": "Type" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 113, + "LSPosition": { + "line": 3, + "character": 19 + }, + "Name": "5", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "Type(a: any, b: any, c: any): void", + "parameters": [ + { + "label": "a: any" + }, + { + "label": "b: any" + }, + { + "label": "c: any" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "identifier", + "Text": "Type" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 119, + "LSPosition": { + "line": 3, + "character": 25 + }, + "Name": "6", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "Type(a: any, b: any, c: any): void", + "parameters": [ + { + "label": "a: any" + }, + { + "label": "b: any" + }, + { + "label": "c: any" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "identifier", + "Text": "Type" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 122, + "LSPosition": { + "line": 3, + "character": 28 + }, + "Name": "7", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "Type(a: any, b: any, c: any): void", + "parameters": [ + { + "label": "a: any" + }, + { + "label": "b: any" + }, + { + "label": "c: any" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "identifier", + "Text": "Type" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 128, + "LSPosition": { + "line": 3, + "character": 34 + }, + "Name": "8", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "Type(a: any, b: any, c: any): void", + "parameters": [ + { + "label": "a: any" + }, + { + "label": "b: any" + }, + { + "label": "c: any" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "identifier", + "Text": "Type" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 132, + "LSPosition": { + "line": 3, + "character": 38 + }, + "Name": "9", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "Type(a: any, b: any, c: any): void", + "parameters": [ + { + "label": "a: any" + }, + { + "label": "b: any" + }, + { + "label": "c: any" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "identifier", + "Text": "Type" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 133, + "LSPosition": { + "line": 3, + "character": 39 + }, + "Name": "10", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "Type(a: any, b: any, c: any): void", + "parameters": [ + { + "label": "a: any" + }, + { + "label": "b: any" + }, + { + "label": "c: any" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "identifier", + "Text": "Type" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 138, + "LSPosition": { + "line": 3, + "character": 44 + }, + "Name": "11", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "Type(a: any, b: any, c: any): void", + "parameters": [ + { + "label": "a: any" + }, + { + "label": "b: any" + }, + { + "label": "c: any" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "identifier", + "Text": "Type" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 139, + "LSPosition": { + "line": 3, + "character": 45 + }, + "Name": "12", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "Type(a: any, b: any, c: any): void", + "parameters": [ + { + "label": "a: any" + }, + { + "label": "b: any" + }, + { + "label": "c: any" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "identifier", + "Text": "Type" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAnonymousTypeVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAnonymousTypeVS.baseline new file mode 100644 index 00000000000..c53949589cc --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAnonymousTypeVS.baseline @@ -0,0 +1,107 @@ +// === SignatureHelp === +=== /signatureHelpAnonymousTypeVS.ts === +// const comparers: Array<(a: any, b: any) => boolean> = []; +// +// comparers.push((a, b) => true); +// ^ +// | ---------------------------------------------------------------------- +// | þtype(a: any, **b: any**): boolean +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 77, + "LSPosition": { + "line": 2, + "character": 18 + }, + "Name": "", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "�type(a: any, b: any): boolean", + "parameters": [ + { + "label": "a: any" + }, + { + "label": "b: any" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "text", + "Text": "�type" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "boolean" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpBindingPattern.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpBindingPattern.baseline index c6339b43846..ecddae751b3 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpBindingPattern.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpBindingPattern.baseline @@ -32,14 +32,8 @@ // nonEmptyObj() // ^ // | ---------------------------------------------------------------------- -// | nonEmptyObj(**{ a, b, }: { - a: number; - b: string; -}**): void -// | - `{ a, b, }: { - a: number; - b: string; -}`: An object with a and b properties. +// | nonEmptyObj(**{ a, b }: { a: number; b: string; }**): void +// | - `{ a, b }: { a: number; b: string; }`: An object with a and b properties. // | ---------------------------------------------------------------------- // @@ -50,14 +44,8 @@ // nonEmptyArr() // ^ // | ---------------------------------------------------------------------- -// | nonEmptyArr(**[x, y,]: [ - number, - string -]**): void -// | - `[x, y,]: [ - number, - string -]`: A tuple with two elements. +// | nonEmptyArr(**[x, y]: [number, string]**): void +// | - `[x, y]: [number, string]`: A tuple with two elements. // | ---------------------------------------------------------------------- // @@ -69,23 +57,14 @@ // idLeading(123, { a: 1, b: 2 }) // ^ // | ---------------------------------------------------------------------- -// | idLeading(**first: number**, { a, b, }: { - a: number; - b: string; -}): void +// | idLeading(**first: number**, { a, b }: { a: number; b: string; }): void // | - `first: number`: The first number parameter. // | ---------------------------------------------------------------------- // ^ // | ---------------------------------------------------------------------- -// | idLeading(first: number, **{ a, b, }: { - a: number; - b: string; -}**): void -// | - `{ a, b, }: { - a: number; - b: string; -}`: An object with a and b properties. +// | idLeading(first: number, **{ a, b }: { a: number; b: string; }**): void +// | - `{ a, b }: { a: number; b: string; }`: An object with a and b properties. // | ---------------------------------------------------------------------- // @@ -97,22 +76,13 @@ // bindingLeading({ a: 1, b: 2 }, 123 ) // ^ // | ---------------------------------------------------------------------- -// | bindingLeading(**{ a, b, }: { - a: number; - b: string; -}**, last: number): void -// | - `{ a, b, }: { - a: number; - b: string; -}`: An object with a and b properties. +// | bindingLeading(**{ a, b }: { a: number; b: string; }**, last: number): void +// | - `{ a, b }: { a: number; b: string; }`: An object with a and b properties. // | ---------------------------------------------------------------------- // ^ // | ---------------------------------------------------------------------- -// | bindingLeading({ a, b, }: { - a: number; - b: string; -}, **last: number**): void +// | bindingLeading({ a, b }: { a: number; b: string; }, **last: number**): void // | - `last: number`: The last number parameter. // | ---------------------------------------------------------------------- @@ -129,32 +99,14 @@ // multipleBindings({ a: 0, b: "" }, { c: true, d: "" }) // ^ // | ---------------------------------------------------------------------- -// | multipleBindings(**{ a, b, }: { - a: any; - b: any; -}**, { c, d, }: { - c: any; - d: any; -}): void -// | - `{ a, b, }: { - a: any; - b: any; -}`: The first parameter +// | multipleBindings(**{ a, b }: { a: any; b: any; }**, { c, d }: { c: any; d: any; }): void +// | - `{ a, b }: { a: any; b: any; }`: The first parameter // | ---------------------------------------------------------------------- // ^ // | ---------------------------------------------------------------------- -// | multipleBindings({ a, b, }: { - a: any; - b: any; -}, **{ c, d, }: { - c: any; - d: any; -}**): void -// | - `{ c, d, }: { - c: any; - d: any; -}`: The second parameter +// | multipleBindings({ a, b }: { a: any; b: any; }, **{ c, d }: { c: any; d: any; }**): void +// | - `{ c, d }: { c: any; d: any; }`: The second parameter // | ---------------------------------------------------------------------- // @@ -230,10 +182,10 @@ "item": { "signatures": [ { - "label": "nonEmptyObj({ a, b, }: {\n a: number;\n b: string;\n}): void", + "label": "nonEmptyObj({ a, b }: { a: number; b: string; }): void", "parameters": [ { - "label": "{ a, b, }: {\n a: number;\n b: string;\n}", + "label": "{ a, b }: { a: number; b: string; }", "documentation": { "kind": "markdown", "value": "An object with a and b properties.\n" @@ -259,10 +211,10 @@ "item": { "signatures": [ { - "label": "nonEmptyArr([x, y,]: [\n number,\n string\n]): void", + "label": "nonEmptyArr([x, y]: [number, string]): void", "parameters": [ { - "label": "[x, y,]: [\n number,\n string\n]", + "label": "[x, y]: [number, string]", "documentation": { "kind": "markdown", "value": "A tuple with two elements.\n" @@ -288,7 +240,7 @@ "item": { "signatures": [ { - "label": "idLeading(first: number, { a, b, }: {\n a: number;\n b: string;\n}): void", + "label": "idLeading(first: number, { a, b }: { a: number; b: string; }): void", "parameters": [ { "label": "first: number", @@ -298,7 +250,7 @@ } }, { - "label": "{ a, b, }: {\n a: number;\n b: string;\n}", + "label": "{ a, b }: { a: number; b: string; }", "documentation": { "kind": "markdown", "value": "An object with a and b properties.\n" @@ -324,7 +276,7 @@ "item": { "signatures": [ { - "label": "idLeading(first: number, { a, b, }: {\n a: number;\n b: string;\n}): void", + "label": "idLeading(first: number, { a, b }: { a: number; b: string; }): void", "parameters": [ { "label": "first: number", @@ -334,7 +286,7 @@ } }, { - "label": "{ a, b, }: {\n a: number;\n b: string;\n}", + "label": "{ a, b }: { a: number; b: string; }", "documentation": { "kind": "markdown", "value": "An object with a and b properties.\n" @@ -360,10 +312,10 @@ "item": { "signatures": [ { - "label": "bindingLeading({ a, b, }: {\n a: number;\n b: string;\n}, last: number): void", + "label": "bindingLeading({ a, b }: { a: number; b: string; }, last: number): void", "parameters": [ { - "label": "{ a, b, }: {\n a: number;\n b: string;\n}", + "label": "{ a, b }: { a: number; b: string; }", "documentation": { "kind": "markdown", "value": "An object with a and b properties.\n" @@ -396,10 +348,10 @@ "item": { "signatures": [ { - "label": "bindingLeading({ a, b, }: {\n a: number;\n b: string;\n}, last: number): void", + "label": "bindingLeading({ a, b }: { a: number; b: string; }, last: number): void", "parameters": [ { - "label": "{ a, b, }: {\n a: number;\n b: string;\n}", + "label": "{ a, b }: { a: number; b: string; }", "documentation": { "kind": "markdown", "value": "An object with a and b properties.\n" @@ -432,17 +384,17 @@ "item": { "signatures": [ { - "label": "multipleBindings({ a, b, }: {\n a: any;\n b: any;\n}, { c, d, }: {\n c: any;\n d: any;\n}): void", + "label": "multipleBindings({ a, b }: { a: any; b: any; }, { c, d }: { c: any; d: any; }): void", "parameters": [ { - "label": "{ a, b, }: {\n a: any;\n b: any;\n}", + "label": "{ a, b }: { a: any; b: any; }", "documentation": { "kind": "markdown", "value": "The first parameter\n" } }, { - "label": "{ c, d, }: {\n c: any;\n d: any;\n}", + "label": "{ c, d }: { c: any; d: any; }", "documentation": { "kind": "markdown", "value": "The second parameter\n" @@ -468,17 +420,17 @@ "item": { "signatures": [ { - "label": "multipleBindings({ a, b, }: {\n a: any;\n b: any;\n}, { c, d, }: {\n c: any;\n d: any;\n}): void", + "label": "multipleBindings({ a, b }: { a: any; b: any; }, { c, d }: { c: any; d: any; }): void", "parameters": [ { - "label": "{ a, b, }: {\n a: any;\n b: any;\n}", + "label": "{ a, b }: { a: any; b: any; }", "documentation": { "kind": "markdown", "value": "The first parameter\n" } }, { - "label": "{ c, d, }: {\n c: any;\n d: any;\n}", + "label": "{ c, d }: { c: any; d: any; }", "documentation": { "kind": "markdown", "value": "The second parameter\n" diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpBindingPatternVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpBindingPatternVS.baseline new file mode 100644 index 00000000000..328538322b3 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpBindingPatternVS.baseline @@ -0,0 +1,1874 @@ +// === SignatureHelp === +=== /signatureHelpBindingPatternVS.ts === +// +// /** +// * @param options An empty object binding pattern. +// */ +// function emptyObj({}) {} +// emptyObj() +// ^ +// | ---------------------------------------------------------------------- +// | emptyObj(**{}: {}**): void +// | - `{}: {}`: An empty object binding pattern. + +// | ---------------------------------------------------------------------- +// +// /** +// * @param items An empty array binding pattern. +// */ +// function emptyArr([]) {} +// emptyArr() +// ^ +// | ---------------------------------------------------------------------- +// | emptyArr(**[]: Iterable**): void +// | - `[]: Iterable`: An empty array binding pattern. + +// | ---------------------------------------------------------------------- +// +// /** +// * @param param An object with a and b properties. +// */ +// function nonEmptyObj({a, b}: {a: number, b: string}) {} +// nonEmptyObj() +// ^ +// | ---------------------------------------------------------------------- +// | nonEmptyObj(**{ a, b }: { a: number; b: string; }**): void +// | - `{ a, b }: { a: number; b: string; }`: An object with a and b properties. + +// | ---------------------------------------------------------------------- +// +// /** +// * @param tuple A tuple with two elements. +// */ +// function nonEmptyArr([x, y]: [number, string]) {} +// nonEmptyArr() +// ^ +// | ---------------------------------------------------------------------- +// | nonEmptyArr(**[x, y]: [number, string]**): void +// | - `[x, y]: [number, string]`: A tuple with two elements. + +// | ---------------------------------------------------------------------- +// +// /** +// * @param first The first number parameter. +// * @param second An object with a and b properties. +// */ +// function idLeading(first: number, {a, b}: {a: number, b: string}) {} +// idLeading(123, { a: 1, b: 2 }) +// ^ +// | ---------------------------------------------------------------------- +// | idLeading(**first: number**, { a, b }: { a: number; b: string; }): void +// | - `first: number`: The first number parameter. + +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | idLeading(first: number, **{ a, b }: { a: number; b: string; }**): void +// | - `{ a, b }: { a: number; b: string; }`: An object with a and b properties. + +// | ---------------------------------------------------------------------- +// +// /** +// * @param first An object with a and b properties. +// * @param last The last number parameter. +// */ +// function bindingLeading({a, b}: {a: number, b: string}, last: number) {} +// bindingLeading({ a: 1, b: 2 }, 123 ) +// ^ +// | ---------------------------------------------------------------------- +// | bindingLeading(**{ a, b }: { a: number; b: string; }**, last: number): void +// | - `{ a, b }: { a: number; b: string; }`: An object with a and b properties. + +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | bindingLeading({ a, b }: { a: number; b: string; }, **last: number**): void +// | - `last: number`: The last number parameter. + +// | ---------------------------------------------------------------------- +// +// /** +// * @param param1 {Object} The first parameter +// * @param param1.a {number} Comment a +// * @param param1.b {string} Comment b +// * @param param2 {Object} The second parameter +// * @param param2.c {boolean} Comment c +// * @param param2.d {unknown} Comment d +// */ +// function multipleBindings({ a, b }, { c, d }) {} +// multipleBindings({ a: 0, b: "" }, { c: true, d: "" }) +// ^ +// | ---------------------------------------------------------------------- +// | multipleBindings(**{ a, b }: { a: any; b: any; }**, { c, d }: { c: any; d: any; }): void +// | - `{ a, b }: { a: any; b: any; }`: The first parameter + +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | multipleBindings({ a, b }: { a: any; b: any; }, **{ c, d }: { c: any; d: any; }**): void +// | - `{ c, d }: { c: any; d: any; }`: The second parameter + +// | ---------------------------------------------------------------------- +// +[ + { + "marker": { + "Position": 94, + "LSPosition": { + "line": 5, + "character": 9 + }, + "Name": "emptyObj", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "emptyObj({}: {}): void", + "parameters": [ + { + "label": "{}: {}", + "documentation": { + "kind": "markdown", + "value": "An empty object binding pattern.\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "emptyObj" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 187, + "LSPosition": { + "line": 11, + "character": 9 + }, + "Name": "emptyArr", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "emptyArr([]: Iterable): void", + "parameters": [ + { + "label": "[]: Iterable", + "documentation": { + "kind": "markdown", + "value": "An empty array binding pattern.\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "emptyArr" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "Iterable" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "undefined" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 317, + "LSPosition": { + "line": 17, + "character": 12 + }, + "Name": "nonEmptyObj", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "nonEmptyObj({ a, b }: { a: number; b: string; }): void", + "parameters": [ + { + "label": "{ a, b }: { a: number; b: string; }", + "documentation": { + "kind": "markdown", + "value": "An object with a and b properties.\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "nonEmptyObj" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 433, + "LSPosition": { + "line": 23, + "character": 12 + }, + "Name": "nonEmptyArr", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "nonEmptyArr([x, y]: [number, string]): void", + "parameters": [ + { + "label": "[x, y]: [number, string]", + "documentation": { + "kind": "markdown", + "value": "A tuple with two elements.\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "nonEmptyArr" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "x" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "y" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 622, + "LSPosition": { + "line": 30, + "character": 13 + }, + "Name": "idLeading", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "idLeading(first: number, { a, b }: { a: number; b: string; }): void", + "parameters": [ + { + "label": "first: number", + "documentation": { + "kind": "markdown", + "value": "The first number parameter.\n" + } + }, + { + "label": "{ a, b }: { a: number; b: string; }", + "documentation": { + "kind": "markdown", + "value": "An object with a and b properties.\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "idLeading" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "first" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 638, + "LSPosition": { + "line": 30, + "character": 29 + }, + "Name": "bindingTrailing", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "idLeading(first: number, { a, b }: { a: number; b: string; }): void", + "parameters": [ + { + "label": "first: number", + "documentation": { + "kind": "markdown", + "value": "The first number parameter.\n" + } + }, + { + "label": "{ a, b }: { a: number; b: string; }", + "documentation": { + "kind": "markdown", + "value": "An object with a and b properties.\n" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "idLeading" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "first" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 830, + "LSPosition": { + "line": 37, + "character": 15 + }, + "Name": "bindingLeading", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "bindingLeading({ a, b }: { a: number; b: string; }, last: number): void", + "parameters": [ + { + "label": "{ a, b }: { a: number; b: string; }", + "documentation": { + "kind": "markdown", + "value": "An object with a and b properties.\n" + } + }, + { + "label": "last: number", + "documentation": { + "kind": "markdown", + "value": "The last number parameter.\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "bindingLeading" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "last" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 850, + "LSPosition": { + "line": 37, + "character": 35 + }, + "Name": "idTrailing", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "bindingLeading({ a, b }: { a: number; b: string; }, last: number): void", + "parameters": [ + { + "label": "{ a, b }: { a: number; b: string; }", + "documentation": { + "kind": "markdown", + "value": "An object with a and b properties.\n" + } + }, + { + "label": "last: number", + "documentation": { + "kind": "markdown", + "value": "The last number parameter.\n" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "bindingLeading" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "last" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1189, + "LSPosition": { + "line": 48, + "character": 32 + }, + "Name": "firstObjParam", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "multipleBindings({ a, b }: { a: any; b: any; }, { c, d }: { c: any; d: any; }): void", + "parameters": [ + { + "label": "{ a, b }: { a: any; b: any; }", + "documentation": { + "kind": "markdown", + "value": "The first parameter\n" + } + }, + { + "label": "{ c, d }: { c: any; d: any; }", + "documentation": { + "kind": "markdown", + "value": "The second parameter\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "multipleBindings" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1209, + "LSPosition": { + "line": 48, + "character": 52 + }, + "Name": "secondObjParam", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "multipleBindings({ a, b }: { a: any; b: any; }, { c, d }: { c: any; d: any; }): void", + "parameters": [ + { + "label": "{ a, b }: { a: any; b: any; }", + "documentation": { + "kind": "markdown", + "value": "The first parameter\n" + } + }, + { + "label": "{ c, d }: { c: any; d: any; }", + "documentation": { + "kind": "markdown", + "value": "The second parameter\n" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "multipleBindings" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "property name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassMembersVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassMembersVS.baseline new file mode 100644 index 00000000000..06551f397e9 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassMembersVS.baseline @@ -0,0 +1,1440 @@ +// === SignatureHelp === +=== /signatureHelpCommentsClassMembersVS.ts === +// /** This is comment for c1*/ +// class c1 { +// /** p1 is property of c1*/ +// public p1: number; +// /** sum with property*/ +// public p2(/** number to add*/b: number) { +// return this.p1 + b; +// } +// /** getter property 1*/ +// public get p3() { +// return this.p2(this.p1); +// ^ +// | ---------------------------------------------------------------------- +// | p2(**b: number**): number +// | - `b: number`: number to add +// | sum with property +// | ---------------------------------------------------------------------- +// } +// /** setter property 1*/ +// public set p3(/** this is value*/value: number) { +// this.p1 = this.p2(value); +// ^ +// | ---------------------------------------------------------------------- +// | p2(**b: number**): number +// | - `b: number`: number to add +// | sum with property +// | ---------------------------------------------------------------------- +// } +// /** pp1 is property of c1*/ +// private pp1: number; +// /** sum with property*/ +// private pp2(/** number to add*/b: number) { +// return this.p1 + b; +// } +// /** getter property 2*/ +// private get pp3() { +// return this.pp2(this.pp1); +// ^ +// | ---------------------------------------------------------------------- +// | pp2(**b: number**): number +// | - `b: number`: number to add +// | sum with property +// | ---------------------------------------------------------------------- +// } +// /** setter property 2*/ +// private set pp3( /** this is value*/value: number) { +// this.pp1 = this.pp2(value); +// ^ +// | ---------------------------------------------------------------------- +// | pp2(**b: number**): number +// | - `b: number`: number to add +// | sum with property +// | ---------------------------------------------------------------------- +// } +// /** Constructor method*/ +// constructor() { +// } +// /** s1 is static property of c1*/ +// static s1: number; +// /** static sum with property*/ +// static s2(/** number to add*/b: number) { +// return c1.s1 + b; +// } +// /** static getter property*/ +// static get s3() { +// return c1.s2(c1.s1); +// ^ +// | ---------------------------------------------------------------------- +// | s2(**b: number**): number +// | - `b: number`: number to add +// | static sum with property +// | ---------------------------------------------------------------------- +// } +// /** setter property 3*/ +// static set s3( /** this is value*/value: number) { +// c1.s1 = c1.s2(value); +// ^ +// | ---------------------------------------------------------------------- +// | s2(**b: number**): number +// | - `b: number`: number to add +// | static sum with property +// | ---------------------------------------------------------------------- +// } +// public nc_p1: number; +// public nc_p2(b: number) { +// return this.nc_p1 + b; +// } +// public get nc_p3() { +// return this.nc_p2(this.nc_p1); +// ^ +// | ---------------------------------------------------------------------- +// | nc_p2(**b: number**): number +// | ---------------------------------------------------------------------- +// } +// public set nc_p3(value: number) { +// this.nc_p1 = this.nc_p2(value); +// ^ +// | ---------------------------------------------------------------------- +// | nc_p2(**b: number**): number +// | ---------------------------------------------------------------------- +// } +// private nc_pp1: number; +// private nc_pp2(b: number) { +// return this.nc_pp1 + b; +// } +// private get nc_pp3() { +// return this.nc_pp2(this.nc_pp1); +// ^ +// | ---------------------------------------------------------------------- +// | nc_pp2(**b: number**): number +// | ---------------------------------------------------------------------- +// } +// private set nc_pp3(value: number) { +// this.nc_pp1 = this.nc_pp2(value); +// ^ +// | ---------------------------------------------------------------------- +// | nc_pp2(**b: number**): number +// | ---------------------------------------------------------------------- +// } +// static nc_s1: number; +// static nc_s2(b: number) { +// return c1.nc_s1 + b; +// } +// static get nc_s3() { +// return c1.nc_s2(c1.nc_s1); +// ^ +// | ---------------------------------------------------------------------- +// | nc_s2(**b: number**): number +// | ---------------------------------------------------------------------- +// } +// static set nc_s3(value: number) { +// c1.nc_s1 = c1.nc_s2(value); +// ^ +// | ---------------------------------------------------------------------- +// | nc_s2(**b: number**): number +// | ---------------------------------------------------------------------- +// } +// } +// var i1 = new c1(); +// ^ +// | ---------------------------------------------------------------------- +// | c1(): c1 +// | Constructor method +// | ---------------------------------------------------------------------- +// var i1_p = i1.p1; +// var i1_f = i1.p2; +// var i1_r = i1.p2(20); +// ^ +// | ---------------------------------------------------------------------- +// | p2(**b: number**): number +// | - `b: number`: number to add +// | sum with property +// | ---------------------------------------------------------------------- +// var i1_prop = i1.p3; +// i1.p3 = i1_prop; +// var i1_nc_p = i1.nc_p1; +// var i1_ncf = i1.nc_p2; +// var i1_ncr = i1.nc_p2(20); +// ^ +// | ---------------------------------------------------------------------- +// | nc_p2(**b: number**): number +// | ---------------------------------------------------------------------- +// var i1_ncprop = i1.nc_p3; +// i1.nc_p3 = i1_ncprop; +// var i1_s_p = c1.s1; +// var i1_s_f = c1.s2; +// var i1_s_r = c1.s2(20); +// ^ +// | ---------------------------------------------------------------------- +// | s2(**b: number**): number +// | - `b: number`: number to add +// | static sum with property +// | ---------------------------------------------------------------------- +// var i1_s_prop = c1.s3; +// c1.s3 = i1_s_prop; +// var i1_s_nc_p = c1.nc_s1; +// var i1_s_ncf = c1.nc_s2; +// var i1_s_ncr = c1.nc_s2(20); +// ^ +// | ---------------------------------------------------------------------- +// | nc_s2(**b: number**): number +// | ---------------------------------------------------------------------- +// var i1_s_ncprop = c1.nc_s3; +// c1.nc_s3 = i1_s_ncprop; +// var i1_c = c1; +// +// class cProperties { +// private val: number; +// /** getter only property*/ +// public get p1() { +// return this.val; +// } +// public get nc_p1() { +// return this.val; +// } +// /**setter only property*/ +// public set p2(value: number) { +// this.val = value; +// } +// public set nc_p2(value: number) { +// this.val = value; +// } +// } +// var cProperties_i = new cProperties(); +// cProperties_i.p2 = cProperties_i.p1; +// cProperties_i.nc_p2 = cProperties_i.nc_p1; +// class cWithConstructorProperty { +// /** +// * this is class cWithConstructorProperty's constructor +// * @param a this is first parameter a +// */ +// constructor(/**more info about a*/public a: number) { +// var bbbb = 10; +// this.a = a + 2 + bbbb; +// } +// } +[ + { + "marker": { + "Position": 275, + "LSPosition": { + "line": 10, + "character": 23 + }, + "Name": "8", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "p2(b: number): number", + "documentation": { + "kind": "markdown", + "value": "sum with property" + }, + "parameters": [ + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "number to add" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "p2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 399, + "LSPosition": { + "line": 14, + "character": 26 + }, + "Name": "13", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "p2(b: number): number", + "documentation": { + "kind": "markdown", + "value": "sum with property" + }, + "parameters": [ + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "number to add" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "p2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 656, + "LSPosition": { + "line": 24, + "character": 24 + }, + "Name": "20", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "pp2(b: number): number", + "documentation": { + "kind": "markdown", + "value": "sum with property" + }, + "parameters": [ + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "number to add" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "pp2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 786, + "LSPosition": { + "line": 28, + "character": 28 + }, + "Name": "25", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "pp2(b: number): number", + "documentation": { + "kind": "markdown", + "value": "sum with property" + }, + "parameters": [ + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "number to add" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "pp2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1105, + "LSPosition": { + "line": 41, + "character": 21 + }, + "Name": "35", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "s2(b: number): number", + "documentation": { + "kind": "markdown", + "value": "static sum with property" + }, + "parameters": [ + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "number to add" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "s2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1224, + "LSPosition": { + "line": 45, + "character": 22 + }, + "Name": "42", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "s2(b: number): number", + "documentation": { + "kind": "markdown", + "value": "static sum with property" + }, + "parameters": [ + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "number to add" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "s2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1382, + "LSPosition": { + "line": 52, + "character": 26 + }, + "Name": "47", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "nc_p2(b: number): number", + "parameters": [ + { + "label": "b: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "nc_p2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1471, + "LSPosition": { + "line": 55, + "character": 32 + }, + "Name": "49", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "nc_p2(b: number): number", + "parameters": [ + { + "label": "b: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "nc_p2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1637, + "LSPosition": { + "line": 62, + "character": 27 + }, + "Name": "54", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "nc_pp2(b: number): number", + "parameters": [ + { + "label": "b: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "nc_pp2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1731, + "LSPosition": { + "line": 65, + "character": 34 + }, + "Name": "56", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "nc_pp2(b: number): number", + "parameters": [ + { + "label": "b: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "nc_pp2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1885, + "LSPosition": { + "line": 72, + "character": 24 + }, + "Name": "61", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "nc_s2(b: number): number", + "parameters": [ + { + "label": "b: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "nc_s2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1968, + "LSPosition": { + "line": 75, + "character": 28 + }, + "Name": "63", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "nc_s2(b: number): number", + "parameters": [ + { + "label": "b: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "nc_s2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2000, + "LSPosition": { + "line": 78, + "character": 16 + }, + "Name": "65", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "c1(): c1", + "documentation": { + "kind": "markdown", + "value": "Constructor method" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "class name", + "Text": "c1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "c1" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2056, + "LSPosition": { + "line": 81, + "character": 17 + }, + "Name": "71", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "p2(b: number): number", + "documentation": { + "kind": "markdown", + "value": "sum with property" + }, + "parameters": [ + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "number to add" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "p2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2168, + "LSPosition": { + "line": 86, + "character": 22 + }, + "Name": "81", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "nc_p2(b: number): number", + "parameters": [ + { + "label": "b: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "nc_p2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2280, + "LSPosition": { + "line": 91, + "character": 19 + }, + "Name": "92", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "s2(b: number): number", + "documentation": { + "kind": "markdown", + "value": "static sum with property" + }, + "parameters": [ + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "number to add" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "s2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2402, + "LSPosition": { + "line": 96, + "character": 24 + }, + "Name": "102", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "nc_s2(b: number): number", + "parameters": [ + { + "label": "b: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "nc_s2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassVS.baseline new file mode 100644 index 00000000000..1aeea65402c --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassVS.baseline @@ -0,0 +1,420 @@ +// === SignatureHelp === +=== /signatureHelpCommentsClassVS.ts === +// /** This is class c2 without constructor*/ +// class c2 { +// } +// var i2 = new c2(); +// ^ +// | ---------------------------------------------------------------------- +// | c2(): c2 +// | ---------------------------------------------------------------------- +// var i2_c = c2; +// class c3 { +// /** Constructor comment*/ +// constructor() { +// } +// } +// var i3 = new c3(); +// ^ +// | ---------------------------------------------------------------------- +// | c3(): c3 +// | Constructor comment +// | ---------------------------------------------------------------------- +// var i3_c = c3; +// /** Class comment*/ +// class c4 { +// /** Constructor comment*/ +// constructor() { +// } +// } +// var i4 = new c4(); +// ^ +// | ---------------------------------------------------------------------- +// | c4(): c4 +// | Constructor comment +// | ---------------------------------------------------------------------- +// var i4_c = c4; +// /** Class with statics*/ +// class c5 { +// static s1: number; +// } +// var i5 = new c5(); +// ^ +// | ---------------------------------------------------------------------- +// | c5(): c5 +// | ---------------------------------------------------------------------- +// var i5_c = c5; +// /** class with statics and constructor*/ +// class c6 { +// /** s1 comment*/ +// static s1: number; +// /** constructor comment*/ +// constructor() { +// } +// } +// var i6 = new c6(); +// ^ +// | ---------------------------------------------------------------------- +// | c6(): c6 +// | constructor comment +// | ---------------------------------------------------------------------- +// var i6_c = c6; +// +// class a { +// /** +// constructor for a +// @param a this is my a +// */ +// constructor(a: string) { +// } +// } +// new a("Hello"); +// ^ +// | ---------------------------------------------------------------------- +// | a(**a: string**): a +// | - `a: string`: this is my a + +// | constructor for a +// | ---------------------------------------------------------------------- +// namespace m { +// export namespace m2 { +// /** class comment */ +// export class c1 { +// /** constructor comment*/ +// constructor() { +// } +// } +// } +// } +// var myVar = new m.m2.c1(); +[ + { + "marker": { + "Position": 72, + "LSPosition": { + "line": 3, + "character": 16 + }, + "Name": "3", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "c2(): c2", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "class name", + "Text": "c2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "c2" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 175, + "LSPosition": { + "line": 10, + "character": 16 + }, + "Name": "8", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "c3(): c3", + "documentation": { + "kind": "markdown", + "value": "Constructor comment" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "class name", + "Text": "c3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "c3" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 298, + "LSPosition": { + "line": 18, + "character": 16 + }, + "Name": "13", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "c4(): c4", + "documentation": { + "kind": "markdown", + "value": "Constructor comment" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "class name", + "Text": "c4" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "c4" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 393, + "LSPosition": { + "line": 24, + "character": 16 + }, + "Name": "18", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "c5(): c5", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "class name", + "Text": "c5" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "c5" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 581, + "LSPosition": { + "line": 34, + "character": 16 + }, + "Name": "23", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "c6(): c6", + "documentation": { + "kind": "markdown", + "value": "constructor comment" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "class name", + "Text": "c6" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "c6" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 716, + "LSPosition": { + "line": 45, + "character": 6 + }, + "Name": "27", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "a(a: string): a", + "documentation": { + "kind": "markdown", + "value": "constructor for a" + }, + "parameters": [ + { + "label": "a: string", + "documentation": { + "kind": "markdown", + "value": "this is my a\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "class name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "a" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsCommentParsingVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsCommentParsingVS.baseline new file mode 100644 index 00000000000..7fb118be26d --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsCommentParsingVS.baseline @@ -0,0 +1,6307 @@ +// === SignatureHelp === +=== /signatureHelpCommentsCommentParsingVS.ts === +// /// This is simple /// comments +// function simple() { +// } +// +// simple( ); +// ^ +// | ---------------------------------------------------------------------- +// | simple(): void +// | ---------------------------------------------------------------------- +// +// /// multiLine /// Comments +// /// This is example of multiline /// comments +// /// Another multiLine +// function multiLine() { +// } +// multiLine( ); +// ^ +// | ---------------------------------------------------------------------- +// | multiLine(): void +// | ---------------------------------------------------------------------- +// +// /** this is eg of single line jsdoc style comment */ +// function jsDocSingleLine() { +// } +// jsDocSingleLine(); +// ^ +// | ---------------------------------------------------------------------- +// | jsDocSingleLine(): void +// | this is eg of single line jsdoc style comment +// | ---------------------------------------------------------------------- +// +// +// /** this is multiple line jsdoc stule comment +// *New line1 +// *New Line2*/ +// function jsDocMultiLine() { +// } +// jsDocMultiLine(); +// ^ +// | ---------------------------------------------------------------------- +// | jsDocMultiLine(): void +// | this is multiple line jsdoc stule comment +// | New line1 +// | New Line2 +// | ---------------------------------------------------------------------- +// +// /** multiple line jsdoc comments no longer merge +// *New line1 +// *New Line2*/ +// /** Shoul mege this line as well +// * and this too*/ /** Another this one too*/ +// function jsDocMultiLineMerge() { +// } +// jsDocMultiLineMerge(); +// ^ +// | ---------------------------------------------------------------------- +// | jsDocMultiLineMerge(): void +// | Another this one too +// | ---------------------------------------------------------------------- +// +// +// /// Triple slash comment +// /** jsdoc comment */ +// function jsDocMixedComments1() { +// } +// jsDocMixedComments1(); +// ^ +// | ---------------------------------------------------------------------- +// | jsDocMixedComments1(): void +// | jsdoc comment +// | ---------------------------------------------------------------------- +// +// /// Triple slash comment +// /** jsdoc comment */ /** another jsDocComment*/ +// function jsDocMixedComments2() { +// } +// jsDocMixedComments2(); +// ^ +// | ---------------------------------------------------------------------- +// | jsDocMixedComments2(): void +// | another jsDocComment +// | ---------------------------------------------------------------------- +// +// /** jsdoc comment */ /*** triplestar jsDocComment*/ +// /// Triple slash comment +// function jsDocMixedComments3() { +// } +// jsDocMixedComments3(); +// ^ +// | ---------------------------------------------------------------------- +// | jsDocMixedComments3(): void +// | * triplestar jsDocComment +// | ---------------------------------------------------------------------- +// +// /** jsdoc comment */ /** another jsDocComment*/ +// /// Triple slash comment +// /// Triple slash comment 2 +// function jsDocMixedComments4() { +// } +// jsDocMixedComments4(); +// ^ +// | ---------------------------------------------------------------------- +// | jsDocMixedComments4(): void +// | another jsDocComment +// | ---------------------------------------------------------------------- +// +// /// Triple slash comment 1 +// /** jsdoc comment */ /** another jsDocComment*/ +// /// Triple slash comment +// /// Triple slash comment 2 +// function jsDocMixedComments5() { +// } +// jsDocMixedComments5(); +// ^ +// | ---------------------------------------------------------------------- +// | jsDocMixedComments5(): void +// | another jsDocComment +// | ---------------------------------------------------------------------- +// +// /** another jsDocComment*/ +// /// Triple slash comment 1 +// /// Triple slash comment +// /// Triple slash comment 2 +// /** jsdoc comment */ +// function jsDocMixedComments6() { +// } +// jsDocMixedComments6(); +// ^ +// | ---------------------------------------------------------------------- +// | jsDocMixedComments6(): void +// | jsdoc comment +// | ---------------------------------------------------------------------- +// +// // This shoulnot be help comment +// function noHelpComment1() { +// } +// noHelpComment1(); +// ^ +// | ---------------------------------------------------------------------- +// | noHelpComment1(): void +// | ---------------------------------------------------------------------- +// +// /* This shoulnot be help comment */ +// function noHelpComment2() { +// } +// noHelpComment2(); +// ^ +// | ---------------------------------------------------------------------- +// | noHelpComment2(): void +// | ---------------------------------------------------------------------- +// +// function noHelpComment3() { +// } +// noHelpComment3(); +// ^ +// | ---------------------------------------------------------------------- +// | noHelpComment3(): void +// | ---------------------------------------------------------------------- +// /** Adds two integers and returns the result +// * @param {number} a first number +// * @param b second number +// */ +// function sum(a: number, b: number) { +// return a + b; +// } +// sum(10, 20); +// ^ +// | ---------------------------------------------------------------------- +// | sum(**a: number**, b: number): number +// | - `a: number`: first number + +// | Adds two integers and returns the result +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | sum(a: number, **b: number**): number +// | - `b: number`: second number + +// | Adds two integers and returns the result +// | ---------------------------------------------------------------------- +// /** This is multiplication function +// * @param +// * @param a first number +// * @param b +// * @param c { +// @param d @anotherTag +// * @param e LastParam @anotherTag*/ +// function multiply(a: number, b: number, c?: number, d?, e?) { +// } +// multiply(10, 20, 30, 40, 50); +// ^ +// | ---------------------------------------------------------------------- +// | multiply(**a: number**, b: number, c?: number, d?: any, e?: any): void +// | - `a: number`: first number + +// | This is multiplication function +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | multiply(a: number, **b: number**, c?: number, d?: any, e?: any): void +// | This is multiplication function +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | multiply(a: number, b: number, **c?: number**, d?: any, e?: any): void +// | This is multiplication function +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | multiply(a: number, b: number, c?: number, **d?: any**, e?: any): void +// | This is multiplication function +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | multiply(a: number, b: number, c?: number, d?: any, **e?: any**): void +// | - `e?: any`: LastParam +// | This is multiplication function +// | ---------------------------------------------------------------------- +// /** fn f1 with number +// * @param { string} b about b +// */ +// function f1(a: number); +// function f1(b: string); +// /**@param opt optional parameter*/ +// function f1(aOrb, opt?) { +// return aOrb; +// } +// f1(10); +// ^ +// | ---------------------------------------------------------------------- +// | f1(**a: number**): any +// | fn f1 with number +// | ---------------------------------------------------------------------- +// f1("hello"); +// ^ +// | ---------------------------------------------------------------------- +// | f1(**b: string**): any +// | - `b: string`: about b + +// | fn f1 with number +// | ---------------------------------------------------------------------- +// +// /** This is subtract function +// @param { a +// *@param { number | } b this is about b +// @param { { () => string; } } c this is optional param c +// @param { { () => string; } d this is optional param d +// @param { { () => string; } } e this is optional param e +// @param { { { () => string; } } f this is optional param f +// */ +// function subtract(a: number, b: number, c?: () => string, d?: () => string, e?: () => string, f?: () => string) { +// } +// subtract(10, 20, null, null, null, null); +// ^ +// | ---------------------------------------------------------------------- +// | subtract(**a: number**, b: number, c?: () => string, d?: () => string, e?: () => string, f?: () => string): void +// | This is subtract function +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | subtract(a: number, **b: number**, c?: () => string, d?: () => string, e?: () => string, f?: () => string): void +// | - `b: number`: this is about b + +// | This is subtract function +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | subtract(a: number, b: number, **c?: () => string**, d?: () => string, e?: () => string, f?: () => string): void +// | - `c?: () => string`: this is optional param c + +// | This is subtract function +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | subtract(a: number, b: number, c?: () => string, **d?: () => string**, e?: () => string, f?: () => string): void +// | - `d?: () => string`: this is optional param d + +// | This is subtract function +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | subtract(a: number, b: number, c?: () => string, d?: () => string, **e?: () => string**, f?: () => string): void +// | - `e?: () => string`: this is optional param e + +// | This is subtract function +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | subtract(a: number, b: number, c?: () => string, d?: () => string, e?: () => string, **f?: () => string**): void +// | This is subtract function +// | ---------------------------------------------------------------------- +// /** this is square function +// @paramTag { number } a this is input number of paramTag +// @param { number } a this is input number +// @returnType { number } it is return type +// */ +// function square(a: number) { +// return a * a; +// } +// square(10); +// ^ +// | ---------------------------------------------------------------------- +// | square(**a: number**): number +// | - `a: number`: this is input number + +// | this is square function +// | ---------------------------------------------------------------------- +// /** this is divide function +// @param { number} a this is a +// @paramTag { number } g this is optional param g +// @param { number} b this is b +// */ +// function divide(a: number, b: number) { +// } +// divide(10, 20); +// ^ +// | ---------------------------------------------------------------------- +// | divide(**a: number**, b: number): void +// | - `a: number`: this is a + +// | this is divide function +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | divide(a: number, **b: number**): void +// | - `b: number`: this is b + +// | this is divide function +// | ---------------------------------------------------------------------- +// /** +// Function returns string concat of foo and bar +// @param {string} foo is string +// @param {string} bar is second string +// */ +// function fooBar(foo: string, bar: string) { +// return foo + bar; +// } +// fooBar("foo","bar"); +// ^ +// | ---------------------------------------------------------------------- +// | fooBar(**foo: string**, bar: string): string +// | - `foo: string`: is string + +// | Function returns string concat of foo and bar +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | fooBar(foo: string, **bar: string**): string +// | - `bar: string`: is second string + +// | Function returns string concat of foo and bar +// | ---------------------------------------------------------------------- +// /** This is a comment */ +// var x; +// /** +// * This is a comment +// */ +// var y; +// /** this is jsdoc style function with param tag as well as inline parameter help +// *@param a it is first parameter +// *@param c it is third parameter +// */ +// function jsDocParamTest(/** this is inline comment for a */a: number, /** this is inline comment for b*/ b: number, c: number, d: number) { +// return a + b + c + d; +// ^ +// | ---------------------------------------------------------------------- +// | No signaturehelp at /*39*/. +// | ---------------------------------------------------------------------- +// } +// jsDocParamTest(30, 40, 50, 60); +// ^ +// | ---------------------------------------------------------------------- +// | jsDocParamTest(**a: number**, b: number, c: number, d: number): number +// | - `a: number`: this is inline comment for a +// | this is jsdoc style function with param tag as well as inline parameter help +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | jsDocParamTest(a: number, **b: number**, c: number, d: number): number +// | - `b: number`: this is inline comment for b +// | this is jsdoc style function with param tag as well as inline parameter help +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | jsDocParamTest(a: number, b: number, **c: number**, d: number): number +// | - `c: number`: it is third parameter + +// | this is jsdoc style function with param tag as well as inline parameter help +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | jsDocParamTest(a: number, b: number, c: number, **d: number**): number +// | this is jsdoc style function with param tag as well as inline parameter help +// | ---------------------------------------------------------------------- +// /** This is function comment +// * And properly aligned comment +// */ +// function jsDocCommentAlignmentTest1() { +// } +// jsDocCommentAlignmentTest1(); +// ^ +// | ---------------------------------------------------------------------- +// | jsDocCommentAlignmentTest1(): void +// | This is function comment +// | And properly aligned comment +// | ---------------------------------------------------------------------- +// /** This is function comment +// * And aligned with 4 space char margin +// */ +// function jsDocCommentAlignmentTest2() { +// } +// jsDocCommentAlignmentTest2(); +// ^ +// | ---------------------------------------------------------------------- +// | jsDocCommentAlignmentTest2(): void +// | This is function comment +// | And aligned with 4 space char margin +// | ---------------------------------------------------------------------- +// /** This is function comment +// * And aligned with 4 space char margin +// * @param {string} a this is info about a +// * spanning on two lines and aligned perfectly +// * @param b this is info about b +// * spanning on two lines and aligned perfectly +// * spanning one more line alined perfectly +// * spanning another line with more margin +// * @param c this is info about b +// * not aligned text about parameter will eat only one space +// */ +// function jsDocCommentAlignmentTest3(a: string, b, c) { +// } +// jsDocCommentAlignmentTest3("hello",1, 2); +// ^ +// | ---------------------------------------------------------------------- +// | jsDocCommentAlignmentTest3(**a: string**, b: any, c: any): void +// | - `a: string`: this is info about a +spanning on two lines and aligned perfectly + +// | This is function comment +// | And aligned with 4 space char margin +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | jsDocCommentAlignmentTest3(a: string, **b: any**, c: any): void +// | - `b: any`: this is info about b +spanning on two lines and aligned perfectly +spanning one more line alined perfectly + spanning another line with more margin + +// | This is function comment +// | And aligned with 4 space char margin +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | jsDocCommentAlignmentTest3(a: string, b: any, **c: any**): void +// | - `c: any`: this is info about b +not aligned text about parameter will eat only one space + +// | This is function comment +// | And aligned with 4 space char margin +// | ---------------------------------------------------------------------- +// +// ^ +// | ---------------------------------------------------------------------- +// | No signaturehelp at /**/. +// | ---------------------------------------------------------------------- +// class NoQuickInfoClass { +// } +[ + { + "marker": { + "Position": 63, + "LSPosition": { + "line": 4, + "character": 8 + }, + "Name": "1", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "simple(): void", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "simple" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 198, + "LSPosition": { + "line": 11, + "character": 11 + }, + "Name": "2", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "multiLine(): void", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "multiLine" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 302, + "LSPosition": { + "line": 16, + "character": 16 + }, + "Name": "3", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocSingleLine(): void", + "documentation": { + "kind": "markdown", + "value": "this is eg of single line jsdoc style comment" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocSingleLine" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 422, + "LSPosition": { + "line": 24, + "character": 15 + }, + "Name": "4", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocMultiLine(): void", + "documentation": { + "kind": "markdown", + "value": "this is multiple line jsdoc stule comment\nNew line1\nNew Line2" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocMultiLine" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 631, + "LSPosition": { + "line": 33, + "character": 20 + }, + "Name": "5", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocMultiLineMerge(): void", + "documentation": { + "kind": "markdown", + "value": "Another this one too" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocMultiLineMerge" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 737, + "LSPosition": { + "line": 40, + "character": 20 + }, + "Name": "6", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocMixedComments1(): void", + "documentation": { + "kind": "markdown", + "value": "jsdoc comment" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocMixedComments1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 869, + "LSPosition": { + "line": 46, + "character": 20 + }, + "Name": "7", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocMixedComments2(): void", + "documentation": { + "kind": "markdown", + "value": "another jsDocComment" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocMixedComments2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1005, + "LSPosition": { + "line": 52, + "character": 20 + }, + "Name": "8", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocMixedComments3(): void", + "documentation": { + "kind": "markdown", + "value": "* triplestar jsDocComment" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocMixedComments3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1164, + "LSPosition": { + "line": 59, + "character": 20 + }, + "Name": "9", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocMixedComments4(): void", + "documentation": { + "kind": "markdown", + "value": "another jsDocComment" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocMixedComments4" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1350, + "LSPosition": { + "line": 67, + "character": 20 + }, + "Name": "10", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocMixedComments5(): void", + "documentation": { + "kind": "markdown", + "value": "another jsDocComment" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocMixedComments5" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1536, + "LSPosition": { + "line": 76, + "character": 20 + }, + "Name": "11", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocMixedComments6(): void", + "documentation": { + "kind": "markdown", + "value": "jsdoc comment" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocMixedComments6" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1618, + "LSPosition": { + "line": 81, + "character": 15 + }, + "Name": "12", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "noHelpComment1(): void", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "noHelpComment1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1703, + "LSPosition": { + "line": 86, + "character": 15 + }, + "Name": "13", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "noHelpComment2(): void", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "noHelpComment2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1752, + "LSPosition": { + "line": 90, + "character": 15 + }, + "Name": "14", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "noHelpComment3(): void", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "noHelpComment3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1928, + "LSPosition": { + "line": 98, + "character": 4 + }, + "Name": "16", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "sum(a: number, b: number): number", + "documentation": { + "kind": "markdown", + "value": "Adds two integers and returns the result" + }, + "parameters": [ + { + "label": "a: number", + "documentation": { + "kind": "markdown", + "value": "first number\n" + } + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "second number\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "sum" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1932, + "LSPosition": { + "line": 98, + "character": 8 + }, + "Name": "17", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "sum(a: number, b: number): number", + "documentation": { + "kind": "markdown", + "value": "Adds two integers and returns the result" + }, + "parameters": [ + { + "label": "a: number", + "documentation": { + "kind": "markdown", + "value": "first number\n" + } + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "second number\n" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "sum" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2166, + "LSPosition": { + "line": 108, + "character": 9 + }, + "Name": "19", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "multiply(a: number, b: number, c?: number, d?: any, e?: any): void", + "documentation": { + "kind": "markdown", + "value": "This is multiplication function" + }, + "parameters": [ + { + "label": "a: number", + "documentation": { + "kind": "markdown", + "value": "first number\n" + } + }, + { + "label": "b: number" + }, + { + "label": "c?: number" + }, + { + "label": "d?: any" + }, + { + "label": "e?: any", + "documentation": { + "kind": "markdown", + "value": "LastParam " + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "multiply" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "e" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2169, + "LSPosition": { + "line": 108, + "character": 12 + }, + "Name": "20", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "multiply(a: number, b: number, c?: number, d?: any, e?: any): void", + "documentation": { + "kind": "markdown", + "value": "This is multiplication function" + }, + "parameters": [ + { + "label": "a: number", + "documentation": { + "kind": "markdown", + "value": "first number\n" + } + }, + { + "label": "b: number" + }, + { + "label": "c?: number" + }, + { + "label": "d?: any" + }, + { + "label": "e?: any", + "documentation": { + "kind": "markdown", + "value": "LastParam " + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "multiply" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "e" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2173, + "LSPosition": { + "line": 108, + "character": 16 + }, + "Name": "21", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "multiply(a: number, b: number, c?: number, d?: any, e?: any): void", + "documentation": { + "kind": "markdown", + "value": "This is multiplication function" + }, + "parameters": [ + { + "label": "a: number", + "documentation": { + "kind": "markdown", + "value": "first number\n" + } + }, + { + "label": "b: number" + }, + { + "label": "c?: number" + }, + { + "label": "d?: any" + }, + { + "label": "e?: any", + "documentation": { + "kind": "markdown", + "value": "LastParam " + } + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "multiply" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "e" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2178, + "LSPosition": { + "line": 108, + "character": 21 + }, + "Name": "22", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "multiply(a: number, b: number, c?: number, d?: any, e?: any): void", + "documentation": { + "kind": "markdown", + "value": "This is multiplication function" + }, + "parameters": [ + { + "label": "a: number", + "documentation": { + "kind": "markdown", + "value": "first number\n" + } + }, + { + "label": "b: number" + }, + { + "label": "c?: number" + }, + { + "label": "d?: any" + }, + { + "label": "e?: any", + "documentation": { + "kind": "markdown", + "value": "LastParam " + } + } + ], + "activeParameter": 3, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "multiply" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "e" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2182, + "LSPosition": { + "line": 108, + "character": 25 + }, + "Name": "23", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "multiply(a: number, b: number, c?: number, d?: any, e?: any): void", + "documentation": { + "kind": "markdown", + "value": "This is multiplication function" + }, + "parameters": [ + { + "label": "a: number", + "documentation": { + "kind": "markdown", + "value": "first number\n" + } + }, + { + "label": "b: number" + }, + { + "label": "c?: number" + }, + { + "label": "d?: any" + }, + { + "label": "e?: any", + "documentation": { + "kind": "markdown", + "value": "LastParam " + } + } + ], + "activeParameter": 4, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "multiply" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "e" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2372, + "LSPosition": { + "line": 118, + "character": 3 + }, + "Name": "25", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f1(a: number): any", + "documentation": { + "kind": "markdown", + "value": "fn f1 with number" + }, + "parameters": [ + { + "label": "a: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + } + ] + } + }, + { + "label": "f1(b: string): any", + "documentation": { + "kind": "markdown", + "value": "fn f1 with number" + }, + "parameters": [ + { + "label": "b: string", + "documentation": { + "kind": "markdown", + "value": "about b\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2380, + "LSPosition": { + "line": 119, + "character": 3 + }, + "Name": "26", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f1(a: number): any", + "documentation": { + "kind": "markdown", + "value": "fn f1 with number" + }, + "parameters": [ + { + "label": "a: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + } + ] + } + }, + { + "label": "f1(b: string): any", + "documentation": { + "kind": "markdown", + "value": "fn f1 with number" + }, + "parameters": [ + { + "label": "b: string", + "documentation": { + "kind": "markdown", + "value": "about b\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + } + ] + } + } + ], + "activeSignature": 1 + } + }, + { + "marker": { + "Position": 2823, + "LSPosition": { + "line": 131, + "character": 9 + }, + "Name": "28", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "subtract(a: number, b: number, c?: () => string, d?: () => string, e?: () => string, f?: () => string): void", + "documentation": { + "kind": "markdown", + "value": "This is subtract function" + }, + "parameters": [ + { + "label": "a: number" + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "this is about b\n" + } + }, + { + "label": "c?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param c\n" + } + }, + { + "label": "d?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param d\n" + } + }, + { + "label": "e?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param e\n" + } + }, + { + "label": "f?: () => string" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "subtract" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "e" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "f" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2827, + "LSPosition": { + "line": 131, + "character": 13 + }, + "Name": "29", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "subtract(a: number, b: number, c?: () => string, d?: () => string, e?: () => string, f?: () => string): void", + "documentation": { + "kind": "markdown", + "value": "This is subtract function" + }, + "parameters": [ + { + "label": "a: number" + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "this is about b\n" + } + }, + { + "label": "c?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param c\n" + } + }, + { + "label": "d?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param d\n" + } + }, + { + "label": "e?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param e\n" + } + }, + { + "label": "f?: () => string" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "subtract" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "e" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "f" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2832, + "LSPosition": { + "line": 131, + "character": 18 + }, + "Name": "30", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "subtract(a: number, b: number, c?: () => string, d?: () => string, e?: () => string, f?: () => string): void", + "documentation": { + "kind": "markdown", + "value": "This is subtract function" + }, + "parameters": [ + { + "label": "a: number" + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "this is about b\n" + } + }, + { + "label": "c?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param c\n" + } + }, + { + "label": "d?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param d\n" + } + }, + { + "label": "e?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param e\n" + } + }, + { + "label": "f?: () => string" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "subtract" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "e" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "f" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2839, + "LSPosition": { + "line": 131, + "character": 25 + }, + "Name": "31", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "subtract(a: number, b: number, c?: () => string, d?: () => string, e?: () => string, f?: () => string): void", + "documentation": { + "kind": "markdown", + "value": "This is subtract function" + }, + "parameters": [ + { + "label": "a: number" + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "this is about b\n" + } + }, + { + "label": "c?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param c\n" + } + }, + { + "label": "d?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param d\n" + } + }, + { + "label": "e?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param e\n" + } + }, + { + "label": "f?: () => string" + } + ], + "activeParameter": 3, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "subtract" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "e" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "f" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2846, + "LSPosition": { + "line": 131, + "character": 32 + }, + "Name": "32", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "subtract(a: number, b: number, c?: () => string, d?: () => string, e?: () => string, f?: () => string): void", + "documentation": { + "kind": "markdown", + "value": "This is subtract function" + }, + "parameters": [ + { + "label": "a: number" + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "this is about b\n" + } + }, + { + "label": "c?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param c\n" + } + }, + { + "label": "d?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param d\n" + } + }, + { + "label": "e?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param e\n" + } + }, + { + "label": "f?: () => string" + } + ], + "activeParameter": 4, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "subtract" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "e" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "f" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 2853, + "LSPosition": { + "line": 131, + "character": 39 + }, + "Name": "33", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "subtract(a: number, b: number, c?: () => string, d?: () => string, e?: () => string, f?: () => string): void", + "documentation": { + "kind": "markdown", + "value": "This is subtract function" + }, + "parameters": [ + { + "label": "a: number" + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "this is about b\n" + } + }, + { + "label": "c?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param c\n" + } + }, + { + "label": "d?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param d\n" + } + }, + { + "label": "e?: () => string", + "documentation": { + "kind": "markdown", + "value": "this is optional param e\n" + } + }, + { + "label": "f?: () => string" + } + ], + "activeParameter": 5, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "subtract" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "e" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "f" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 3085, + "LSPosition": { + "line": 140, + "character": 7 + }, + "Name": "34", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "square(a: number): number", + "documentation": { + "kind": "markdown", + "value": "this is square function" + }, + "parameters": [ + { + "label": "a: number", + "documentation": { + "kind": "markdown", + "value": "this is input number\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "square" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 3276, + "LSPosition": { + "line": 148, + "character": 7 + }, + "Name": "35", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "divide(a: number, b: number): void", + "documentation": { + "kind": "markdown", + "value": "this is divide function" + }, + "parameters": [ + { + "label": "a: number", + "documentation": { + "kind": "markdown", + "value": "this is a\n" + } + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "this is b\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "divide" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 3280, + "LSPosition": { + "line": 148, + "character": 11 + }, + "Name": "36", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "divide(a: number, b: number): void", + "documentation": { + "kind": "markdown", + "value": "this is divide function" + }, + "parameters": [ + { + "label": "a: number", + "documentation": { + "kind": "markdown", + "value": "this is a\n" + } + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "this is b\n" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "divide" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 3491, + "LSPosition": { + "line": 157, + "character": 7 + }, + "Name": "37", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "fooBar(foo: string, bar: string): string", + "documentation": { + "kind": "markdown", + "value": "Function returns string concat of foo and bar" + }, + "parameters": [ + { + "label": "foo: string", + "documentation": { + "kind": "markdown", + "value": "is string\n" + } + }, + { + "label": "bar: string", + "documentation": { + "kind": "markdown", + "value": "is second string\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "fooBar" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "foo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "bar" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 3497, + "LSPosition": { + "line": 157, + "character": 13 + }, + "Name": "38", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "fooBar(foo: string, bar: string): string", + "documentation": { + "kind": "markdown", + "value": "Function returns string concat of foo and bar" + }, + "parameters": [ + { + "label": "foo: string", + "documentation": { + "kind": "markdown", + "value": "is string\n" + } + }, + { + "label": "bar: string", + "documentation": { + "kind": "markdown", + "value": "is second string\n" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "fooBar" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "foo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "bar" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 3874, + "LSPosition": { + "line": 169, + "character": 11 + }, + "Name": "39", + "Data": {} + }, + "item": null + }, + { + "marker": { + "Position": 3906, + "LSPosition": { + "line": 171, + "character": 15 + }, + "Name": "40", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocParamTest(a: number, b: number, c: number, d: number): number", + "documentation": { + "kind": "markdown", + "value": "this is jsdoc style function with param tag as well as inline parameter help" + }, + "parameters": [ + { + "label": "a: number", + "documentation": { + "kind": "markdown", + "value": "this is inline comment for a" + } + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "this is inline comment for b" + } + }, + { + "label": "c: number", + "documentation": { + "kind": "markdown", + "value": "it is third parameter\n" + } + }, + { + "label": "d: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocParamTest" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 3910, + "LSPosition": { + "line": 171, + "character": 19 + }, + "Name": "41", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocParamTest(a: number, b: number, c: number, d: number): number", + "documentation": { + "kind": "markdown", + "value": "this is jsdoc style function with param tag as well as inline parameter help" + }, + "parameters": [ + { + "label": "a: number", + "documentation": { + "kind": "markdown", + "value": "this is inline comment for a" + } + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "this is inline comment for b" + } + }, + { + "label": "c: number", + "documentation": { + "kind": "markdown", + "value": "it is third parameter\n" + } + }, + { + "label": "d: number" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocParamTest" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 3914, + "LSPosition": { + "line": 171, + "character": 23 + }, + "Name": "42", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocParamTest(a: number, b: number, c: number, d: number): number", + "documentation": { + "kind": "markdown", + "value": "this is jsdoc style function with param tag as well as inline parameter help" + }, + "parameters": [ + { + "label": "a: number", + "documentation": { + "kind": "markdown", + "value": "this is inline comment for a" + } + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "this is inline comment for b" + } + }, + { + "label": "c: number", + "documentation": { + "kind": "markdown", + "value": "it is third parameter\n" + } + }, + { + "label": "d: number" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocParamTest" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 3918, + "LSPosition": { + "line": 171, + "character": 27 + }, + "Name": "43", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocParamTest(a: number, b: number, c: number, d: number): number", + "documentation": { + "kind": "markdown", + "value": "this is jsdoc style function with param tag as well as inline parameter help" + }, + "parameters": [ + { + "label": "a: number", + "documentation": { + "kind": "markdown", + "value": "this is inline comment for a" + } + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "this is inline comment for b" + } + }, + { + "label": "c: number", + "documentation": { + "kind": "markdown", + "value": "it is third parameter\n" + } + }, + { + "label": "d: number" + } + ], + "activeParameter": 3, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocParamTest" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "d" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 4059, + "LSPosition": { + "line": 177, + "character": 27 + }, + "Name": "45", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocCommentAlignmentTest1(): void", + "documentation": { + "kind": "markdown", + "value": "This is function comment\nAnd properly aligned comment" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocCommentAlignmentTest1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 4210, + "LSPosition": { + "line": 183, + "character": 27 + }, + "Name": "46", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocCommentAlignmentTest2(): void", + "documentation": { + "kind": "markdown", + "value": "This is function comment\n And aligned with 4 space char margin" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocCommentAlignmentTest2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 4826, + "LSPosition": { + "line": 197, + "character": 27 + }, + "Name": "47", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocCommentAlignmentTest3(a: string, b: any, c: any): void", + "documentation": { + "kind": "markdown", + "value": "This is function comment\n And aligned with 4 space char margin" + }, + "parameters": [ + { + "label": "a: string", + "documentation": { + "kind": "markdown", + "value": "this is info about a\nspanning on two lines and aligned perfectly\n" + } + }, + { + "label": "b: any", + "documentation": { + "kind": "markdown", + "value": "this is info about b\nspanning on two lines and aligned perfectly\nspanning one more line alined perfectly\n spanning another line with more margin\n" + } + }, + { + "label": "c: any", + "documentation": { + "kind": "markdown", + "value": "this is info about b\nnot aligned text about parameter will eat only one space\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocCommentAlignmentTest3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 4834, + "LSPosition": { + "line": 197, + "character": 35 + }, + "Name": "48", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocCommentAlignmentTest3(a: string, b: any, c: any): void", + "documentation": { + "kind": "markdown", + "value": "This is function comment\n And aligned with 4 space char margin" + }, + "parameters": [ + { + "label": "a: string", + "documentation": { + "kind": "markdown", + "value": "this is info about a\nspanning on two lines and aligned perfectly\n" + } + }, + { + "label": "b: any", + "documentation": { + "kind": "markdown", + "value": "this is info about b\nspanning on two lines and aligned perfectly\nspanning one more line alined perfectly\n spanning another line with more margin\n" + } + }, + { + "label": "c: any", + "documentation": { + "kind": "markdown", + "value": "this is info about b\nnot aligned text about parameter will eat only one space\n" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocCommentAlignmentTest3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 4837, + "LSPosition": { + "line": 197, + "character": 38 + }, + "Name": "49", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "jsDocCommentAlignmentTest3(a: string, b: any, c: any): void", + "documentation": { + "kind": "markdown", + "value": "This is function comment\n And aligned with 4 space char margin" + }, + "parameters": [ + { + "label": "a: string", + "documentation": { + "kind": "markdown", + "value": "this is info about a\nspanning on two lines and aligned perfectly\n" + } + }, + { + "label": "b: any", + "documentation": { + "kind": "markdown", + "value": "this is info about b\nspanning on two lines and aligned perfectly\nspanning one more line alined perfectly\n spanning another line with more margin\n" + } + }, + { + "label": "c: any", + "documentation": { + "kind": "markdown", + "value": "this is info about b\nnot aligned text about parameter will eat only one space\n" + } + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "jsDocCommentAlignmentTest3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 4841, + "LSPosition": { + "line": 198, + "character": 0 + }, + "Name": "", + "Data": {} + }, + "item": null + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionDeclarationVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionDeclarationVS.baseline new file mode 100644 index 00000000000..029497a00b7 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionDeclarationVS.baseline @@ -0,0 +1,390 @@ +// === SignatureHelp === +=== /signatureHelpCommentsFunctionDeclarationVS.ts === +// /** This comment should appear for foo*/ +// function foo() { +// } +// foo(); +// ^ +// | ---------------------------------------------------------------------- +// | foo(): void +// | This comment should appear for foo +// | ---------------------------------------------------------------------- +// /** This is comment for function signature*/ +// function fooWithParameters(/** this is comment about a*/a: string, +// /** this is comment for b*/ +// b: number) { +// var d = a; +// } +// fooWithParameters("a",10); +// ^ +// | ---------------------------------------------------------------------- +// | fooWithParameters(**a: string**, b: number): void +// | - `a: string`: this is comment about a +// | This is comment for function signature +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | fooWithParameters(a: string, **b: number**): void +// | - `b: number`: this is comment for b +// | This is comment for function signature +// | ---------------------------------------------------------------------- +// /** +// * Does something +// * @param a a string +// */ +// declare function fn(a: string); +// fn("hello"); +// ^ +// | ---------------------------------------------------------------------- +// | fn(**a: string**): any +// | - `a: string`: a string + +// | Does something +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 64, + "LSPosition": { + "line": 3, + "character": 4 + }, + "Name": "4", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "foo(): void", + "documentation": { + "kind": "markdown", + "value": "This comment should appear for foo" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "foo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 263, + "LSPosition": { + "line": 10, + "character": 18 + }, + "Name": "10", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "fooWithParameters(a: string, b: number): void", + "documentation": { + "kind": "markdown", + "value": "This is comment for function signature" + }, + "parameters": [ + { + "label": "a: string", + "documentation": { + "kind": "markdown", + "value": "this is comment about a" + } + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "this is comment for b" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "fooWithParameters" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 267, + "LSPosition": { + "line": 10, + "character": 22 + }, + "Name": "11", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "fooWithParameters(a: string, b: number): void", + "documentation": { + "kind": "markdown", + "value": "This is comment for function signature" + }, + "parameters": [ + { + "label": "a: string", + "documentation": { + "kind": "markdown", + "value": "this is comment about a" + } + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "this is comment for b" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "fooWithParameters" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 351, + "LSPosition": { + "line": 16, + "character": 3 + }, + "Name": "12", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "fn(a: string): any", + "documentation": { + "kind": "markdown", + "value": "Does something" + }, + "parameters": [ + { + "label": "a: string", + "documentation": { + "kind": "markdown", + "value": "a string\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "fn" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionExpressionVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionExpressionVS.baseline new file mode 100644 index 00000000000..2b7d99a23df --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionExpressionVS.baseline @@ -0,0 +1,341 @@ +// === SignatureHelp === +=== /signatureHelpCommentsFunctionExpressionVS.ts === +// /** lambdaFoo var comment*/ +// var lambdaFoo = /** this is lambda comment*/ (/**param a*/a: number, /**param b*/b: number) => a + b; +// var lambddaNoVarComment = /** this is lambda multiplication*/ (/**param a*/a: number, /**param b*/b: number) => a * b; +// lambdaFoo(10, 20); +// ^ +// | ---------------------------------------------------------------------- +// | lambdaFoo(**a: number**, b: number): number +// | - `a: number`: param a +// | this is lambda comment +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | lambdaFoo(a: number, **b: number**): number +// | - `b: number`: param b +// | this is lambda comment +// | ---------------------------------------------------------------------- +// function anotherFunc(a: number) { +// /** documentation +// @param b {string} inner parameter */ +// var lambdaVar = /** inner docs */(b: string) => { +// var localVar = "Hello "; +// return localVar + b; +// } +// return lambdaVar("World") + a; +// } +// /** +// * On variable +// * @param s the first parameter! +// * @returns the parameter's length +// */ +// var assigned = /** +// * Summary on expression +// * @param s param on expression +// * @returns return on expression +// */function(/** On parameter */s: string) { +// return s.length; +// } +// assigned("hey"); +// ^ +// | ---------------------------------------------------------------------- +// | assigned(**s: string**): number +// | - `s: string`: On parameter +// | Summary on expression +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 259, + "LSPosition": { + "line": 3, + "character": 10 + }, + "Name": "5", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "lambdaFoo(a: number, b: number): number", + "documentation": { + "kind": "markdown", + "value": "this is lambda comment" + }, + "parameters": [ + { + "label": "a: number", + "documentation": { + "kind": "markdown", + "value": "param a" + } + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "param b" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "local name", + "Text": "lambdaFoo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 263, + "LSPosition": { + "line": 3, + "character": 14 + }, + "Name": "6", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "lambdaFoo(a: number, b: number): number", + "documentation": { + "kind": "markdown", + "value": "this is lambda comment" + }, + "parameters": [ + { + "label": "a: number", + "documentation": { + "kind": "markdown", + "value": "param a" + } + }, + { + "label": "b: number", + "documentation": { + "kind": "markdown", + "value": "param b" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "local name", + "Text": "lambdaFoo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 862, + "LSPosition": { + "line": 25, + "character": 9 + }, + "Name": "18", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "assigned(s: string): number", + "documentation": { + "kind": "markdown", + "value": "Summary on expression" + }, + "parameters": [ + { + "label": "s: string", + "documentation": { + "kind": "markdown", + "value": "On parameter" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "local name", + "Text": "assigned" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "s" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpConstructorCallParamPropertiesVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpConstructorCallParamPropertiesVS.baseline new file mode 100644 index 00000000000..d9f716ebeee --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpConstructorCallParamPropertiesVS.baseline @@ -0,0 +1,97 @@ +// === SignatureHelp === +=== /signatureHelpConstructorCallParamPropertiesVS.ts === +// class Circle { +// /** +// * Initialize a circle. +// * @param radius The radius of the circle. +// */ +// constructor(private radius: number) { +// } +// } +// var a = new Circle( +// ^ +// | ---------------------------------------------------------------------- +// | Circle(**radius: number**): Circle +// | - `radius: number`: The radius of the circle. + +// | Initialize a circle. +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 179, + "LSPosition": { + "line": 8, + "character": 19 + }, + "Name": "", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "Circle(radius: number): Circle", + "documentation": { + "kind": "markdown", + "value": "Initialize a circle." + }, + "parameters": [ + { + "label": "radius: number", + "documentation": { + "kind": "markdown", + "value": "The radius of the circle.\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "class name", + "Text": "Circle" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "radius" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "Circle" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpExpandedRestTuplesLocalLabels1VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpExpandedRestTuplesLocalLabels1VS.baseline new file mode 100644 index 00000000000..3fe608790c7 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpExpandedRestTuplesLocalLabels1VS.baseline @@ -0,0 +1,6213 @@ +// === SignatureHelp === +=== /signatureHelpExpandedRestTuplesLocalLabels1VS.ts === +// interface AppleInfo { +// color: "green" | "red"; +// } +// +// interface BananaInfo { +// curvature: number; +// } +// +// type FruitAndInfo1 = ["apple", AppleInfo] | ["banana", BananaInfo]; +// +// function logFruitTuple1(...[fruit, info]: FruitAndInfo1) {} +// logFruitTuple1(); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple1(**fruit: "apple"**, info: AppleInfo): void +// | ---------------------------------------------------------------------- +// +// function logFruitTuple2(...[, info]: FruitAndInfo1) {} +// logFruitTuple2(); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple2(**arg_0: "apple"**, info: AppleInfo): void +// | ---------------------------------------------------------------------- +// logFruitTuple2("apple", ); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple2(arg_0: "apple", **info: AppleInfo**): void +// | ---------------------------------------------------------------------- +// +// function logFruitTuple3(...[fruit, ...rest]: FruitAndInfo1) {} +// logFruitTuple3(); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple3(**fruit: "apple"**, rest_0: AppleInfo): void +// | ---------------------------------------------------------------------- +// logFruitTuple3("apple", ); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple3(fruit: "apple", **rest_0: AppleInfo**): void +// | ---------------------------------------------------------------------- +// function logFruitTuple4(...[fruit, ...[info]]: FruitAndInfo1) {} +// logFruitTuple4(); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple4(**fruit: "apple"**, info: AppleInfo): void +// | ---------------------------------------------------------------------- +// logFruitTuple4("apple", ); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple4(fruit: "apple", **info: AppleInfo**): void +// | ---------------------------------------------------------------------- +// +// type FruitAndInfo2 = ["apple", ...AppleInfo[]] | ["banana", ...BananaInfo[]]; +// +// function logFruitTuple5(...[fruit, firstInfo]: FruitAndInfo2) {} +// logFruitTuple5(); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple5(**fruit: "apple"**, ...firstInfo_n: AppleInfo[]): void +// | ---------------------------------------------------------------------- +// logFruitTuple5("apple", ); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple5(fruit: "apple", **...firstInfo_n: AppleInfo[]**): void +// | ---------------------------------------------------------------------- +// +// function logFruitTuple6(...[fruit, ...fruitInfo]: FruitAndInfo2) {} +// logFruitTuple6(); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple6(**fruit: "apple"**, ...fruitInfo: AppleInfo[]): void +// | ---------------------------------------------------------------------- +// logFruitTuple6("apple", ); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple6(fruit: "apple", **...fruitInfo: AppleInfo[]**): void +// | ---------------------------------------------------------------------- +// +// type FruitAndInfo3 = ["apple", ...AppleInfo[], number] | ["banana", ...BananaInfo[], number]; +// +// function logFruitTuple7(...[fruit, fruitInfoOrNumber, secondFruitInfoOrNumber]: FruitAndInfo3) {} +// logFruitTuple7(); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple7(**fruit: "apple"**, ...fruitInfoOrNumber_n: AppleInfo[], secondFruitInfoOrNumber: number): void +// | ---------------------------------------------------------------------- +// logFruitTuple7("apple", ); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple7(fruit: "apple", **...fruitInfoOrNumber_n: AppleInfo[]**, secondFruitInfoOrNumber: number): void +// | ---------------------------------------------------------------------- +// logFruitTuple7("apple", { color: "red" }, ); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple7(fruit: "apple", ...fruitInfoOrNumber_n: AppleInfo[], **secondFruitInfoOrNumber: number**): void +// | ---------------------------------------------------------------------- +// +// function logFruitTuple8(...[fruit, , secondFruitInfoOrNumber]: FruitAndInfo3) {} +// logFruitTuple8(); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple8(**fruit: "apple"**, ...arg_1: AppleInfo[], secondFruitInfoOrNumber: number): void +// | ---------------------------------------------------------------------- +// logFruitTuple8("apple", ); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple8(fruit: "apple", **...arg_1: AppleInfo[]**, secondFruitInfoOrNumber: number): void +// | ---------------------------------------------------------------------- +// logFruitTuple8("apple", { color: "red" }, ); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple8(fruit: "apple", ...arg_1: AppleInfo[], **secondFruitInfoOrNumber: number**): void +// | ---------------------------------------------------------------------- +// +// function logFruitTuple9(...[...[fruit, fruitInfoOrNumber, secondFruitInfoOrNumber]]: FruitAndInfo3) {} +// logFruitTuple9(); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple9(**fruit: "apple"**, ...fruitInfoOrNumber_n: AppleInfo[], secondFruitInfoOrNumber: number): void +// | ---------------------------------------------------------------------- +// logFruitTuple9("apple", ); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple9(fruit: "apple", **...fruitInfoOrNumber_n: AppleInfo[]**, secondFruitInfoOrNumber: number): void +// | ---------------------------------------------------------------------- +// logFruitTuple9("apple", { color: "red" }, ); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple9(fruit: "apple", ...fruitInfoOrNumber_n: AppleInfo[], **secondFruitInfoOrNumber: number**): void +// | ---------------------------------------------------------------------- +// +// function logFruitTuple10(...[fruit, {}, secondFruitInfoOrNumber]: FruitAndInfo3) {} +// logFruitTuple10(); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple10(**fruit: "apple"**, ...arg_1: AppleInfo[], secondFruitInfoOrNumber: number): void +// | ---------------------------------------------------------------------- +// logFruitTuple10("apple", ); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple10(fruit: "apple", **...arg_1: AppleInfo[]**, secondFruitInfoOrNumber: number): void +// | ---------------------------------------------------------------------- +// logFruitTuple10("apple", { color: "red" }, ); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple10(fruit: "apple", ...arg_1: AppleInfo[], **secondFruitInfoOrNumber: number**): void +// | ---------------------------------------------------------------------- +// +// function logFruitTuple11(...{}: FruitAndInfo3) {} +// logFruitTuple11(); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple11(**arg_0: "apple"**, ...arg_1: AppleInfo[], arg_2: number): void +// | ---------------------------------------------------------------------- +// logFruitTuple11("apple", ); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple11(arg_0: "apple", **...arg_1: AppleInfo[]**, arg_2: number): void +// | ---------------------------------------------------------------------- +// logFruitTuple11("apple", { color: "red" }, ); +// ^ +// | ---------------------------------------------------------------------- +// | logFruitTuple11(arg_0: "apple", ...arg_1: AppleInfo[], **arg_2: number**): void +// | ---------------------------------------------------------------------- +// function withPair(...[first, second]: [number, named: string]) {} +// withPair(); +// ^ +// | ---------------------------------------------------------------------- +// | withPair(**first: number**, named: string): void +// | ---------------------------------------------------------------------- +// withPair(101, ); +// ^ +// | ---------------------------------------------------------------------- +// | withPair(first: number, **named: string**): void +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 242, + "LSPosition": { + "line": 11, + "character": 15 + }, + "Name": "1", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple1(fruit: \"apple\", info: AppleInfo): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "info: AppleInfo" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "info" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple1(fruit: \"banana\", info: BananaInfo): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "info: BananaInfo" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "info" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 316, + "LSPosition": { + "line": 14, + "character": 15 + }, + "Name": "2", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple2(arg_0: \"apple\", info: AppleInfo): void", + "parameters": [ + { + "label": "arg_0: \"apple\"" + }, + { + "label": "info: AppleInfo" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_0" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "info" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple2(arg_0: \"banana\", info: BananaInfo): void", + "parameters": [ + { + "label": "arg_0: \"banana\"" + }, + { + "label": "info: BananaInfo" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_0" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "info" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 343, + "LSPosition": { + "line": 15, + "character": 24 + }, + "Name": "3", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple2(arg_0: \"apple\", info: AppleInfo): void", + "parameters": [ + { + "label": "arg_0: \"apple\"" + }, + { + "label": "info: AppleInfo" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_0" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "info" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple2(arg_0: \"banana\", info: BananaInfo): void", + "parameters": [ + { + "label": "arg_0: \"banana\"" + }, + { + "label": "info: BananaInfo" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_0" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "info" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 425, + "LSPosition": { + "line": 18, + "character": 15 + }, + "Name": "4", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple3(fruit: \"apple\", rest_0: AppleInfo): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "rest_0: AppleInfo" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "rest_0" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple3(fruit: \"banana\", rest_0: BananaInfo): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "rest_0: BananaInfo" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "rest_0" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 452, + "LSPosition": { + "line": 19, + "character": 24 + }, + "Name": "5", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple3(fruit: \"apple\", rest_0: AppleInfo): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "rest_0: AppleInfo" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "rest_0" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple3(fruit: \"banana\", rest_0: BananaInfo): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "rest_0: BananaInfo" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "rest_0" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 535, + "LSPosition": { + "line": 21, + "character": 15 + }, + "Name": "6", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple4(fruit: \"apple\", info: AppleInfo): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "info: AppleInfo" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple4" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "info" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple4(fruit: \"banana\", info: BananaInfo): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "info: BananaInfo" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple4" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "info" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 562, + "LSPosition": { + "line": 22, + "character": 24 + }, + "Name": "7", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple4(fruit: \"apple\", info: AppleInfo): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "info: AppleInfo" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple4" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "info" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple4(fruit: \"banana\", info: BananaInfo): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "info: BananaInfo" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple4" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "info" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 725, + "LSPosition": { + "line": 27, + "character": 15 + }, + "Name": "8", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple5(fruit: \"apple\", ...firstInfo_n: AppleInfo[]): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "...firstInfo_n: AppleInfo[]" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple5" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "firstInfo_n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple5(fruit: \"banana\", ...firstInfo_n: BananaInfo[]): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "...firstInfo_n: BananaInfo[]" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple5" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "firstInfo_n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 752, + "LSPosition": { + "line": 28, + "character": 24 + }, + "Name": "9", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple5(fruit: \"apple\", ...firstInfo_n: AppleInfo[]): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "...firstInfo_n: AppleInfo[]" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple5" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "firstInfo_n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple5(fruit: \"banana\", ...firstInfo_n: BananaInfo[]): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "...firstInfo_n: BananaInfo[]" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple5" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "firstInfo_n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 839, + "LSPosition": { + "line": 31, + "character": 15 + }, + "Name": "10", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple6(fruit: \"apple\", ...fruitInfo: AppleInfo[]): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "...fruitInfo: AppleInfo[]" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple6" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruitInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple6(fruit: \"banana\", ...fruitInfo: BananaInfo[]): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "...fruitInfo: BananaInfo[]" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple6" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruitInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 866, + "LSPosition": { + "line": 32, + "character": 24 + }, + "Name": "11", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple6(fruit: \"apple\", ...fruitInfo: AppleInfo[]): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "...fruitInfo: AppleInfo[]" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple6" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruitInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple6(fruit: \"banana\", ...fruitInfo: BananaInfo[]): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "...fruitInfo: BananaInfo[]" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple6" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruitInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1078, + "LSPosition": { + "line": 37, + "character": 15 + }, + "Name": "12", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple7(fruit: \"apple\", ...fruitInfoOrNumber_n: AppleInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "...fruitInfoOrNumber_n: AppleInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple7" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruitInfoOrNumber_n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple7(fruit: \"banana\", ...fruitInfoOrNumber_n: BananaInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "...fruitInfoOrNumber_n: BananaInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple7" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruitInfoOrNumber_n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1105, + "LSPosition": { + "line": 38, + "character": 24 + }, + "Name": "13", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple7(fruit: \"apple\", ...fruitInfoOrNumber_n: AppleInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "...fruitInfoOrNumber_n: AppleInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple7" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruitInfoOrNumber_n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple7(fruit: \"banana\", ...fruitInfoOrNumber_n: BananaInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "...fruitInfoOrNumber_n: BananaInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple7" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruitInfoOrNumber_n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1150, + "LSPosition": { + "line": 39, + "character": 42 + }, + "Name": "14", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple7(fruit: \"apple\", ...fruitInfoOrNumber_n: AppleInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "...fruitInfoOrNumber_n: AppleInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple7" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruitInfoOrNumber_n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple7(fruit: \"banana\", ...fruitInfoOrNumber_n: BananaInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "...fruitInfoOrNumber_n: BananaInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple7" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruitInfoOrNumber_n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1250, + "LSPosition": { + "line": 42, + "character": 15 + }, + "Name": "15", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple8(fruit: \"apple\", ...arg_1: AppleInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "...arg_1: AppleInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple8" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple8(fruit: \"banana\", ...arg_1: BananaInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "...arg_1: BananaInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple8" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1277, + "LSPosition": { + "line": 43, + "character": 24 + }, + "Name": "16", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple8(fruit: \"apple\", ...arg_1: AppleInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "...arg_1: AppleInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple8" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple8(fruit: \"banana\", ...arg_1: BananaInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "...arg_1: BananaInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple8" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1322, + "LSPosition": { + "line": 44, + "character": 42 + }, + "Name": "17", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple8(fruit: \"apple\", ...arg_1: AppleInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "...arg_1: AppleInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple8" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple8(fruit: \"banana\", ...arg_1: BananaInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "...arg_1: BananaInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple8" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1444, + "LSPosition": { + "line": 47, + "character": 15 + }, + "Name": "18", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple9(fruit: \"apple\", ...fruitInfoOrNumber_n: AppleInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "...fruitInfoOrNumber_n: AppleInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple9" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruitInfoOrNumber_n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple9(fruit: \"banana\", ...fruitInfoOrNumber_n: BananaInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "...fruitInfoOrNumber_n: BananaInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple9" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruitInfoOrNumber_n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1471, + "LSPosition": { + "line": 48, + "character": 24 + }, + "Name": "19", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple9(fruit: \"apple\", ...fruitInfoOrNumber_n: AppleInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "...fruitInfoOrNumber_n: AppleInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple9" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruitInfoOrNumber_n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple9(fruit: \"banana\", ...fruitInfoOrNumber_n: BananaInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "...fruitInfoOrNumber_n: BananaInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple9" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruitInfoOrNumber_n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1516, + "LSPosition": { + "line": 49, + "character": 42 + }, + "Name": "20", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple9(fruit: \"apple\", ...fruitInfoOrNumber_n: AppleInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "...fruitInfoOrNumber_n: AppleInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple9" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruitInfoOrNumber_n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple9(fruit: \"banana\", ...fruitInfoOrNumber_n: BananaInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "...fruitInfoOrNumber_n: BananaInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple9" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruitInfoOrNumber_n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1620, + "LSPosition": { + "line": 52, + "character": 16 + }, + "Name": "21", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple10(fruit: \"apple\", ...arg_1: AppleInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "...arg_1: AppleInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple10" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple10(fruit: \"banana\", ...arg_1: BananaInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "...arg_1: BananaInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple10" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1648, + "LSPosition": { + "line": 53, + "character": 25 + }, + "Name": "22", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple10(fruit: \"apple\", ...arg_1: AppleInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "...arg_1: AppleInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple10" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple10(fruit: \"banana\", ...arg_1: BananaInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "...arg_1: BananaInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple10" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1694, + "LSPosition": { + "line": 54, + "character": 43 + }, + "Name": "23", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple10(fruit: \"apple\", ...arg_1: AppleInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"apple\"" + }, + { + "label": "...arg_1: AppleInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple10" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple10(fruit: \"banana\", ...arg_1: BananaInfo[], secondFruitInfoOrNumber: number): void", + "parameters": [ + { + "label": "fruit: \"banana\"" + }, + { + "label": "...arg_1: BananaInfo[]" + }, + { + "label": "secondFruitInfoOrNumber: number" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple10" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fruit" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "secondFruitInfoOrNumber" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1764, + "LSPosition": { + "line": 57, + "character": 16 + }, + "Name": "24", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple11(arg_0: \"apple\", ...arg_1: AppleInfo[], arg_2: number): void", + "parameters": [ + { + "label": "arg_0: \"apple\"" + }, + { + "label": "...arg_1: AppleInfo[]" + }, + { + "label": "arg_2: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple11" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_0" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple11(arg_0: \"banana\", ...arg_1: BananaInfo[], arg_2: number): void", + "parameters": [ + { + "label": "arg_0: \"banana\"" + }, + { + "label": "...arg_1: BananaInfo[]" + }, + { + "label": "arg_2: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple11" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_0" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1792, + "LSPosition": { + "line": 58, + "character": 25 + }, + "Name": "25", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple11(arg_0: \"apple\", ...arg_1: AppleInfo[], arg_2: number): void", + "parameters": [ + { + "label": "arg_0: \"apple\"" + }, + { + "label": "...arg_1: AppleInfo[]" + }, + { + "label": "arg_2: number" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple11" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_0" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple11(arg_0: \"banana\", ...arg_1: BananaInfo[], arg_2: number): void", + "parameters": [ + { + "label": "arg_0: \"banana\"" + }, + { + "label": "...arg_1: BananaInfo[]" + }, + { + "label": "arg_2: number" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple11" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_0" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1838, + "LSPosition": { + "line": 59, + "character": 43 + }, + "Name": "26", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "logFruitTuple11(arg_0: \"apple\", ...arg_1: AppleInfo[], arg_2: number): void", + "parameters": [ + { + "label": "arg_0: \"apple\"" + }, + { + "label": "...arg_1: AppleInfo[]" + }, + { + "label": "arg_2: number" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple11" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_0" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"apple\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "AppleInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + }, + { + "label": "logFruitTuple11(arg_0: \"banana\", ...arg_1: BananaInfo[], arg_2: number): void", + "parameters": [ + { + "label": "arg_0: \"banana\"" + }, + { + "label": "...arg_1: BananaInfo[]" + }, + { + "label": "arg_2: number" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "logFruitTuple11" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_0" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "\"banana\"" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "BananaInfo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "arg_2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1916, + "LSPosition": { + "line": 61, + "character": 9 + }, + "Name": "27", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "withPair(first: number, named: string): void", + "parameters": [ + { + "label": "first: number" + }, + { + "label": "named: string" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "withPair" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "first" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "named" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1933, + "LSPosition": { + "line": 62, + "character": 14 + }, + "Name": "28", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "withPair(first: number, named: string): void", + "parameters": [ + { + "label": "first: number" + }, + { + "label": "named: string" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "withPair" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "first" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "named" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpInferenceJsDocImportTagVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpInferenceJsDocImportTagVS.baseline new file mode 100644 index 00000000000..467d77b2183 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpInferenceJsDocImportTagVS.baseline @@ -0,0 +1,88 @@ +// === SignatureHelp === +=== /b.js === +// /** +// * @import { +// * Foo +// * } from './a' +// */ +// +// /** +// * @param {Foo} a +// */ +// function foo(a) {} +// foo() +// ^ +// | ---------------------------------------------------------------------- +// | foo(**a: Foo**): void +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 98, + "LSPosition": { + "line": 10, + "character": 4 + }, + "Name": "", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "foo(a: Foo): void", + "parameters": [ + { + "label": "a: Foo" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "foo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "Foo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpIteratorNextVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpIteratorNextVS.baseline new file mode 100644 index 00000000000..a131f37aab0 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpIteratorNextVS.baseline @@ -0,0 +1,1343 @@ +// === SignatureHelp === +=== /signatureHelpIteratorNextVS.ts === +// declare const iterator: Iterator; +// +// iterator.next(); +// ^ +// | ---------------------------------------------------------------------- +// | next(): IteratorResult +// | ---------------------------------------------------------------------- +// iterator.next( 0); +// ^ +// | ---------------------------------------------------------------------- +// | next(**value: number**): IteratorResult +// | ---------------------------------------------------------------------- +// +// declare const generator: Generator; +// +// generator.next(); +// ^ +// | ---------------------------------------------------------------------- +// | next(): IteratorResult +// | ---------------------------------------------------------------------- +// generator.next( 0); +// ^ +// | ---------------------------------------------------------------------- +// | next(**value: number**): IteratorResult +// | ---------------------------------------------------------------------- +// +// declare const asyncIterator: AsyncIterator; +// +// asyncIterator.next(); +// ^ +// | ---------------------------------------------------------------------- +// | next(): Promise> +// | ---------------------------------------------------------------------- +// asyncIterator.next( 0); +// ^ +// | ---------------------------------------------------------------------- +// | next(**value: number**): Promise> +// | ---------------------------------------------------------------------- +// +// declare const asyncGenerator: AsyncGenerator; +// +// asyncGenerator.next(); +// ^ +// | ---------------------------------------------------------------------- +// | next(): Promise> +// | ---------------------------------------------------------------------- +// asyncGenerator.next( 0); +// ^ +// | ---------------------------------------------------------------------- +// | next(**value: number**): Promise> +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 71, + "LSPosition": { + "line": 2, + "character": 14 + }, + "Name": "1", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "next(): IteratorResult", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "next" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "IteratorResult" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + } + ] + } + }, + { + "label": "next(value: number): IteratorResult", + "parameters": [ + { + "label": "value: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "next" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "value" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "IteratorResult" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 88, + "LSPosition": { + "line": 3, + "character": 14 + }, + "Name": "2", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "next(): IteratorResult", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "next" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "IteratorResult" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + } + ] + } + }, + { + "label": "next(value: number): IteratorResult", + "parameters": [ + { + "label": "value: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "next" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "value" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "IteratorResult" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + } + ] + } + } + ], + "activeSignature": 1 + } + }, + { + "marker": { + "Position": 168, + "LSPosition": { + "line": 7, + "character": 15 + }, + "Name": "3", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "next(): IteratorResult", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "next" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "IteratorResult" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + } + ] + } + }, + { + "label": "next(value: number): IteratorResult", + "parameters": [ + { + "label": "value: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "next" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "value" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "IteratorResult" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 186, + "LSPosition": { + "line": 8, + "character": 15 + }, + "Name": "4", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "next(): IteratorResult", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "next" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "IteratorResult" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + } + ] + } + }, + { + "label": "next(value: number): IteratorResult", + "parameters": [ + { + "label": "value: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "next" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "value" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "IteratorResult" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + } + ] + } + } + ], + "activeSignature": 1 + } + }, + { + "marker": { + "Position": 278, + "LSPosition": { + "line": 12, + "character": 19 + }, + "Name": "5", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "next(): Promise>", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "next" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "Promise" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "text", + "Text": "IteratorResult" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + } + ] + } + }, + { + "label": "next(value: number): Promise>", + "parameters": [ + { + "label": "value: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "next" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "value" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "Promise" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "text", + "Text": "IteratorResult" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 300, + "LSPosition": { + "line": 13, + "character": 19 + }, + "Name": "6", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "next(): Promise>", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "next" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "Promise" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "text", + "Text": "IteratorResult" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + } + ] + } + }, + { + "label": "next(value: number): Promise>", + "parameters": [ + { + "label": "value: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "next" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "value" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "Promise" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "text", + "Text": "IteratorResult" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + } + ] + } + } + ], + "activeSignature": 1 + } + }, + { + "marker": { + "Position": 395, + "LSPosition": { + "line": 17, + "character": 20 + }, + "Name": "7", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "next(): Promise>", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "next" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "Promise" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "text", + "Text": "IteratorResult" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + } + ] + } + }, + { + "label": "next(value: number): Promise>", + "parameters": [ + { + "label": "value: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "next" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "value" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "Promise" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "text", + "Text": "IteratorResult" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 418, + "LSPosition": { + "line": 18, + "character": 20 + }, + "Name": "8", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "next(): Promise>", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "next" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "Promise" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "text", + "Text": "IteratorResult" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + } + ] + } + }, + { + "label": "next(value: number): Promise>", + "parameters": [ + { + "label": "value: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "next" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "value" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "Promise" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "text", + "Text": "IteratorResult" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + } + ] + } + } + ], + "activeSignature": 1 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocCallbackTagVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocCallbackTagVS.baseline new file mode 100644 index 00000000000..10921c06f1a --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocCallbackTagVS.baseline @@ -0,0 +1,497 @@ +// === SignatureHelp === +=== /jsdocCallbackTag.js === +// /** +// * @callback FooHandler - A kind of magic +// * @param {string} eventName - So many words +// * @param eventName2 {number | string} - Silence is golden +// * @param eventName3 - Osterreich mos def +// * @return {number} - DIVEKICK +// */ +// /** +// * @type {FooHandler} callback +// */ +// var t; +// +// /** +// * @callback FooHandler2 - What, another one? +// * @param {string=} eventName - it keeps happening +// * @param {string} [eventName2] - i WARNED you dog +// */ +// /** +// * @type {FooHandler2} callback +// */ +// var t2; +// t("!", 12, false); +// ^ +// | ---------------------------------------------------------------------- +// | t(**eventName: string**, eventName2: number | string, eventName3: any): number +// | - `eventName: string`: - So many words + +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | t(eventName: string, **eventName2: number | string**, eventName3: any): number +// | - `eventName2: number | string`: - Silence is golden + +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | t(eventName: string, eventName2: number | string, **eventName3: any**): number +// | - `eventName3: any`: - Osterreich mos def + +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 480, + "LSPosition": { + "line": 21, + "character": 2 + }, + "Name": "4", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "t(eventName: string, eventName2: number | string, eventName3: any): number", + "parameters": [ + { + "label": "eventName: string", + "documentation": { + "kind": "markdown", + "value": "- So many words\n" + } + }, + { + "label": "eventName2: number | string", + "documentation": { + "kind": "markdown", + "value": "- Silence is golden\n" + } + }, + { + "label": "eventName3: any", + "documentation": { + "kind": "markdown", + "value": "- Osterreich mos def\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "local name", + "Text": "t" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "eventName" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "eventName2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "|" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "eventName3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 485, + "LSPosition": { + "line": 21, + "character": 7 + }, + "Name": "5", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "t(eventName: string, eventName2: number | string, eventName3: any): number", + "parameters": [ + { + "label": "eventName: string", + "documentation": { + "kind": "markdown", + "value": "- So many words\n" + } + }, + { + "label": "eventName2: number | string", + "documentation": { + "kind": "markdown", + "value": "- Silence is golden\n" + } + }, + { + "label": "eventName3: any", + "documentation": { + "kind": "markdown", + "value": "- Osterreich mos def\n" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "local name", + "Text": "t" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "eventName" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "eventName2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "|" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "eventName3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 489, + "LSPosition": { + "line": 21, + "character": 11 + }, + "Name": "6", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "t(eventName: string, eventName2: number | string, eventName3: any): number", + "parameters": [ + { + "label": "eventName: string", + "documentation": { + "kind": "markdown", + "value": "- So many words\n" + } + }, + { + "label": "eventName2: number | string", + "documentation": { + "kind": "markdown", + "value": "- Silence is golden\n" + } + }, + { + "label": "eventName3: any", + "documentation": { + "kind": "markdown", + "value": "- Osterreich mos def\n" + } + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "local name", + "Text": "t" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "eventName" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "eventName2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "|" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "eventName3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocTagsVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocTagsVS.baseline new file mode 100644 index 00000000000..ba8e0a81e31 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocTagsVS.baseline @@ -0,0 +1,301 @@ +// === SignatureHelp === +=== /signatureHelpJSDocTagsVS.ts === +// /** +// * This is class Foo. +// * @mytag comment1 comment2 +// */ +// class Foo { +// /** +// * This is the constructor. +// * @myjsdoctag this is a comment +// */ +// constructor(value: number) {} +// /** +// * method1 documentation +// * @mytag comment1 comment2 +// */ +// static method1() {} +// /** +// * @mytag +// */ +// method2() {} +// /** +// * @mytag comment1 comment2 +// */ +// property1: string; +// /** +// * @mytag1 some comments +// * some more comments about mytag1 +// * @mytag2 +// * here all the comments are on a new line +// * @mytag3 +// * @mytag +// */ +// property2: number; +// /** +// * @returns {number} a value +// */ +// method3(): number { return 3; } +// /** +// * @param {string} foo A value. +// * @returns {number} Another value +// * @mytag +// */ +// method4(foo: string): number { return 3; } +// /** @mytag */ +// method5() {} +// /** method documentation +// * @mytag a JSDoc tag +// */ +// newMethod() {} +// } +// var foo = new Foo(4); +// ^ +// | ---------------------------------------------------------------------- +// | Foo(**value: number**): Foo +// | This is the constructor. +// | ---------------------------------------------------------------------- +// Foo.method1(); +// ^ +// | ---------------------------------------------------------------------- +// | method1(): void +// | method1 documentation +// | ---------------------------------------------------------------------- +// foo.method2(); +// ^ +// | ---------------------------------------------------------------------- +// | method2(): void +// | ---------------------------------------------------------------------- +// foo.method3(); +// ^ +// | ---------------------------------------------------------------------- +// | method3(): number +// | ---------------------------------------------------------------------- +// foo.method4(); +// foo.property1; +// foo.property2; +// foo.method5(); +// foo.newMet +[ + { + "marker": { + "Position": 981, + "LSPosition": { + "line": 49, + "character": 18 + }, + "Name": "10", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "Foo(value: number): Foo", + "documentation": { + "kind": "markdown", + "value": "This is the constructor." + }, + "parameters": [ + { + "label": "value: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "class name", + "Text": "Foo" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "value" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "Foo" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 997, + "LSPosition": { + "line": 50, + "character": 12 + }, + "Name": "11", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "method1(): void", + "documentation": { + "kind": "markdown", + "value": "method1 documentation" + }, + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "method1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1012, + "LSPosition": { + "line": 51, + "character": 12 + }, + "Name": "12", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "method2(): void", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "method2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 1027, + "LSPosition": { + "line": 52, + "character": 12 + }, + "Name": "13", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "method3(): number", + "parameters": [], + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "method3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSMissingPropertyAccessVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSMissingPropertyAccessVS.baseline new file mode 100644 index 00000000000..d17d7dda171 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSMissingPropertyAccessVS.baseline @@ -0,0 +1,464 @@ +// === SignatureHelp === +=== /test.js === +// foo.filter() +// ^ +// | ---------------------------------------------------------------------- +// | ReadonlyArray.filter(**predicate: (value: T, index: number, array: readonly T[]) => value is S**, thisArg?: any): S[] +// | - `predicate: (value: T, index: number, array: readonly T[]) => value is S`: A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array. + +// | Returns the elements of an array that meet the condition specified in a callback function. +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 11, + "LSPosition": { + "line": 0, + "character": 11 + }, + "Name": "", + "Data": {} + }, + "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." + }, + "parameters": [ + { + "label": "predicate: (value: T, index: number, array: readonly T[]) => value is S", + "documentation": { + "kind": "markdown", + "value": "A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.\n" + } + }, + { + "label": "thisArg?: any", + "documentation": { + "kind": "markdown", + "value": "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" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "ReadonlyArray.filter" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "S extends T" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "predicate" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "value" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "T" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "index" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "array" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "readonly" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "T" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "value" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "is" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "S" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "thisArg" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "S" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + } + ] + } + }, + { + "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." + }, + "parameters": [ + { + "label": "predicate: (value: T, index: number, array: readonly T[]) => unknown", + "documentation": { + "kind": "markdown", + "value": "A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.\n" + } + }, + { + "label": "thisArg?: any", + "documentation": { + "kind": "markdown", + "value": "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" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "ReadonlyArray.filter" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "predicate" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "value" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "T" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "index" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "array" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "readonly" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "T" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "unknown" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "thisArg" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "T" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs1VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs1VS.baseline new file mode 100644 index 00000000000..0901ea16f1f --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs1VS.baseline @@ -0,0 +1,648 @@ +// === SignatureHelp === +=== /signatureHelpRestArgs1VS.ts === +// function fn(a: number, b: number, c: number) {} +// const a = [1, 2] as const; +// const b = [1] as const; +// +// fn(...a, ); +// ^ +// | ---------------------------------------------------------------------- +// | fn(a: number, b: number, **c: number**): void +// | ---------------------------------------------------------------------- +// fn(, ...a); +// ^ +// | ---------------------------------------------------------------------- +// | fn(**a: number**, b: number, c: number): void +// | ---------------------------------------------------------------------- +// +// fn(...b, ); +// ^ +// | ---------------------------------------------------------------------- +// | fn(a: number, **b: number**, c: number): void +// | ---------------------------------------------------------------------- +// fn(, ...b, ); +// ^ +// | ---------------------------------------------------------------------- +// | fn(**a: number**, b: number, c: number): void +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | fn(a: number, b: number, **c: number**): void +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 109, + "LSPosition": { + "line": 4, + "character": 9 + }, + "Name": "1", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "fn(a: number, b: number, c: number): void", + "parameters": [ + { + "label": "a: number" + }, + { + "label": "b: number" + }, + { + "label": "c: number" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "fn" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 115, + "LSPosition": { + "line": 5, + "character": 3 + }, + "Name": "2", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "fn(a: number, b: number, c: number): void", + "parameters": [ + { + "label": "a: number" + }, + { + "label": "b: number" + }, + { + "label": "c: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "fn" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 134, + "LSPosition": { + "line": 7, + "character": 9 + }, + "Name": "3", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "fn(a: number, b: number, c: number): void", + "parameters": [ + { + "label": "a: number" + }, + { + "label": "b: number" + }, + { + "label": "c: number" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "fn" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 140, + "LSPosition": { + "line": 8, + "character": 3 + }, + "Name": "4", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "fn(a: number, b: number, c: number): void", + "parameters": [ + { + "label": "a: number" + }, + { + "label": "b: number" + }, + { + "label": "c: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "fn" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 148, + "LSPosition": { + "line": 8, + "character": 11 + }, + "Name": "5", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "fn(a: number, b: number, c: number): void", + "parameters": [ + { + "label": "a: number" + }, + { + "label": "b: number" + }, + { + "label": "c: number" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "fn" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs2VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs2VS.baseline new file mode 100644 index 00000000000..14f40157eea --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs2VS.baseline @@ -0,0 +1,139 @@ +// === SignatureHelp === +=== /index.js === +// const promisify = function (thisArg, fnName) { +// const fn = thisArg[fnName]; +// return function () { +// return new Promise((resolve) => { +// fn.call(thisArg, ...arguments, ); +// ^ +// | ---------------------------------------------------------------------- +// | Function.call(thisArg: any, **...argArray: any[]**): any +// | - `...argArray: any[]`: A list of arguments to be passed to the method. + +// | Calls a method of an object, substituting another object for the current object. +// | ---------------------------------------------------------------------- +// }); +// }; +// }; +[ + { + "marker": { + "Position": 189, + "LSPosition": { + "line": 4, + "character": 43 + }, + "Name": "1", + "Data": {} + }, + "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." + }, + "parameters": [ + { + "label": "thisArg: any", + "documentation": { + "kind": "markdown", + "value": "The object to be used as the current object.\n" + } + }, + { + "label": "...argArray: any[]", + "documentation": { + "kind": "markdown", + "value": "A list of arguments to be passed to the method.\n" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "Function.call" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "thisArg" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "argArray" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs3VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs3VS.baseline new file mode 100644 index 00000000000..fbf9b94fcde --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs3VS.baseline @@ -0,0 +1,706 @@ +// === SignatureHelp === +=== /signatureHelpRestArgs3VS.ts === +// const layers = Object.assign({}, ...[]); +// ^ +// | ---------------------------------------------------------------------- +// | assign(target: object, **...sources: any[]**): any +// | - `...sources: any[]`: One or more source objects from which to copy properties + +// | Copy the values of all of the enumerable own properties from one or more source objects to a +// | target object. Returns the target object. +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 33, + "LSPosition": { + "line": 0, + "character": 33 + }, + "Name": "1", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "assign(target: T, source: U): T & U", + "documentation": { + "kind": "markdown", + "value": "Copy the values of all of the enumerable own properties from one or more source objects to a\ntarget object. Returns the target object." + }, + "parameters": [ + { + "label": "target: T", + "documentation": { + "kind": "markdown", + "value": "The target object to copy to.\n" + } + }, + { + "label": "source: U", + "documentation": { + "kind": "markdown", + "value": "The source object from which to copy properties.\n" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "assign" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "T extends {}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "U" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "target" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "T" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "source" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "U" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "T" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "&" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "U" + } + ] + } + }, + { + "label": "assign(target: T, source1: U, source2: V): T & U & V", + "documentation": { + "kind": "markdown", + "value": "Copy the values of all of the enumerable own properties from one or more source objects to a\ntarget object. Returns the target object." + }, + "parameters": [ + { + "label": "target: T", + "documentation": { + "kind": "markdown", + "value": "The target object to copy to.\n" + } + }, + { + "label": "source1: U", + "documentation": { + "kind": "markdown", + "value": "The first source object from which to copy properties.\n" + } + }, + { + "label": "source2: V", + "documentation": { + "kind": "markdown", + "value": "The second source object from which to copy properties.\n" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "assign" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "T extends {}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "U" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "V" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "target" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "T" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "source1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "U" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "source2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "V" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "T" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "&" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "U" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "&" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "V" + } + ] + } + }, + { + "label": "assign(target: T, source1: U, source2: V, source3: W): T & U & V & W", + "documentation": { + "kind": "markdown", + "value": "Copy the values of all of the enumerable own properties from one or more source objects to a\ntarget object. Returns the target object." + }, + "parameters": [ + { + "label": "target: T", + "documentation": { + "kind": "markdown", + "value": "The target object to copy to.\n" + } + }, + { + "label": "source1: U", + "documentation": { + "kind": "markdown", + "value": "The first source object from which to copy properties.\n" + } + }, + { + "label": "source2: V", + "documentation": { + "kind": "markdown", + "value": "The second source object from which to copy properties.\n" + } + }, + { + "label": "source3: W", + "documentation": { + "kind": "markdown", + "value": "The third source object from which to copy properties.\n" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "assign" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "T extends {}" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "U" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "V" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "W" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "target" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "T" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "source1" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "U" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "source2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "V" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "source3" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "W" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "T" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "&" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "U" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "&" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "V" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "&" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "text", + "Text": "W" + } + ] + } + }, + { + "label": "assign(target: object, ...sources: any[]): any", + "documentation": { + "kind": "markdown", + "value": "Copy the values of all of the enumerable own properties from one or more source objects to a\ntarget object. Returns the target object." + }, + "parameters": [ + { + "label": "target: object", + "documentation": { + "kind": "markdown", + "value": "The target object to copy to.\n" + } + }, + { + "label": "...sources: any[]", + "documentation": { + "kind": "markdown", + "value": "One or more source objects from which to copy properties\n" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "assign" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "target" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "object" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "..." + }, + { + "ClassificationTypeName": "parameter name", + "Text": "sources" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "[" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "]" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + } + ] + } + } + ], + "activeSignature": 3 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpSkippedArgs1VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpSkippedArgs1VS.baseline new file mode 100644 index 00000000000..2a22bdf49fb --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpSkippedArgs1VS.baseline @@ -0,0 +1,641 @@ +// === SignatureHelp === +=== /signatureHelpSkippedArgs1VS.ts === +// function fn(a: number, b: number, c: number) {} +// fn(, , , , ); +// ^ +// | ---------------------------------------------------------------------- +// | fn(**a: number**, b: number, c: number): void +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | fn(a: number, **b: number**, c: number): void +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | fn(a: number, b: number, **c: number**): void +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | fn(a: number, b: number, c: number): void +// | ---------------------------------------------------------------------- +// ^ +// | ---------------------------------------------------------------------- +// | fn(a: number, b: number, c: number): void +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 51, + "LSPosition": { + "line": 1, + "character": 3 + }, + "Name": "1", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "fn(a: number, b: number, c: number): void", + "parameters": [ + { + "label": "a: number" + }, + { + "label": "b: number" + }, + { + "label": "c: number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "fn" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 53, + "LSPosition": { + "line": 1, + "character": 5 + }, + "Name": "2", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "fn(a: number, b: number, c: number): void", + "parameters": [ + { + "label": "a: number" + }, + { + "label": "b: number" + }, + { + "label": "c: number" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "fn" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 55, + "LSPosition": { + "line": 1, + "character": 7 + }, + "Name": "3", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "fn(a: number, b: number, c: number): void", + "parameters": [ + { + "label": "a: number" + }, + { + "label": "b: number" + }, + { + "label": "c: number" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "fn" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 57, + "LSPosition": { + "line": 1, + "character": 9 + }, + "Name": "4", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "fn(a: number, b: number, c: number): void", + "parameters": [ + { + "label": "a: number" + }, + { + "label": "b: number" + }, + { + "label": "c: number" + } + ], + "activeParameter": 3, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "fn" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 59, + "LSPosition": { + "line": 1, + "character": 11 + }, + "Name": "5", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "fn(a: number, b: number, c: number): void", + "parameters": [ + { + "label": "a: number" + }, + { + "label": "b: number" + }, + { + "label": "c: number" + } + ], + "activeParameter": 4, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "fn" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpTypeArguments2VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpTypeArguments2VS.baseline new file mode 100644 index 00000000000..a58563e5c4e --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpTypeArguments2VS.baseline @@ -0,0 +1,748 @@ +// === SignatureHelp === +=== /signatureHelpTypeArguments2VS.ts === +// /** some documentation +// * @template T some documentation 2 +// * @template W +// * @template U,V others +// * @param a ok +// * @param b not ok +// */ +// function f(a: number, b: string, c: boolean): void { } +// f<; +// ^ +// | ---------------------------------------------------------------------- +// | f<**T**, U, V, W>(a: number, b: string, c: boolean): void +// | some documentation +// | ---------------------------------------------------------------------- +// f(a: number, b: string, c: boolean): void +// | some documentation +// | ---------------------------------------------------------------------- +// f(a: number, b: string, c: boolean): void +// | some documentation +// | ---------------------------------------------------------------------- +// f(a: number, b: string, c: boolean): void +// | some documentation +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 205, + "LSPosition": { + "line": 8, + "character": 2 + }, + "Name": "f0", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f(a: number, b: string, c: boolean): void", + "documentation": { + "kind": "markdown", + "value": "some documentation" + }, + "parameters": [ + { + "label": "T" + }, + { + "label": "U" + }, + { + "label": "V" + }, + { + "label": "W" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "T" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "U" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "V" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "W" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "boolean" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 217, + "LSPosition": { + "line": 9, + "character": 10 + }, + "Name": "f1", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f(a: number, b: string, c: boolean): void", + "documentation": { + "kind": "markdown", + "value": "some documentation" + }, + "parameters": [ + { + "label": "T" + }, + { + "label": "U" + }, + { + "label": "V" + }, + { + "label": "W" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "T" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "U" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "V" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "W" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "boolean" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 237, + "LSPosition": { + "line": 10, + "character": 18 + }, + "Name": "f2", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f(a: number, b: string, c: boolean): void", + "documentation": { + "kind": "markdown", + "value": "some documentation" + }, + "parameters": [ + { + "label": "T" + }, + { + "label": "U" + }, + { + "label": "V" + }, + { + "label": "W" + } + ], + "activeParameter": 2, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "T" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "U" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "V" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "W" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "boolean" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 266, + "LSPosition": { + "line": 11, + "character": 27 + }, + "Name": "f3", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f(a: number, b: string, c: boolean): void", + "documentation": { + "kind": "markdown", + "value": "some documentation" + }, + "parameters": [ + { + "label": "T" + }, + { + "label": "U" + }, + { + "label": "V" + }, + { + "label": "W" + } + ], + "activeParameter": 3, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "<" + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "T" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "U" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "V" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "type parameter name", + "Text": "W" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ">" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "c" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "boolean" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpWithUnknownVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpWithUnknownVS.baseline new file mode 100644 index 00000000000..76356cce033 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpWithUnknownVS.baseline @@ -0,0 +1,89 @@ +// === SignatureHelp === +=== /signatureHelpWithUnknownVS.ts === +// eval(\ +// ^ +// | ---------------------------------------------------------------------- +// | eval(**x: string**): any +// | - `x: string`: A String value that contains valid JavaScript code. + +// | Evaluates JavaScript code and executes it. +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 6, + "LSPosition": { + "line": 0, + "character": 6 + }, + "Name": "1", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "eval(x: string): any", + "documentation": { + "kind": "markdown", + "value": "Evaluates JavaScript code and executes it." + }, + "parameters": [ + { + "label": "x: string", + "documentation": { + "kind": "markdown", + "value": "A String value that contains valid JavaScript code.\n" + } + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "eval" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "x" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "any" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelp_unionTypeVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelp_unionTypeVS.baseline new file mode 100644 index 00000000000..5a5a977a3c7 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelp_unionTypeVS.baseline @@ -0,0 +1,395 @@ +// === SignatureHelp === +=== /signatureHelp_unionTypeVS.ts === +// declare const a: (fn?: ((x: string) => string) | ((y: number) => number)) => void; +// declare const b: (x: string | number) => void; +// +// interface Callback { +// (x: string): string; +// (x: number): number; +// (x: string | number): string | number; +// } +// declare function c(callback: Callback): void; +// a(() => { +// ^ +// | ---------------------------------------------------------------------- +// | a(**fn?: ((x: string) => string) | ((y: number) => number)**): void +// | ---------------------------------------------------------------------- +// return undefined; +// }); +// +// b(); +// ^ +// | ---------------------------------------------------------------------- +// | b(**x: string | number**): void +// | ---------------------------------------------------------------------- +// +// c(() => {}); +// ^ +// | ---------------------------------------------------------------------- +// | Callback(**x: string | number**): string | number +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 296, + "LSPosition": { + "line": 9, + "character": 3 + }, + "Name": "1", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "a(fn?: ((x: string) => string) | ((y: number) => number)): void", + "parameters": [ + { + "label": "fn?: ((x: string) => string) | ((y: number) => number)" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "local name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "fn" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "x" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "|" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "y" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "=>" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 332, + "LSPosition": { + "line": 13, + "character": 2 + }, + "Name": "2", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "b(x: string | number): void", + "parameters": [ + { + "label": "x: string | number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "local name", + "Text": "b" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "x" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "|" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "void" + } + ] + } + } + ], + "activeSignature": 0 + } + }, + { + "marker": { + "Position": 339, + "LSPosition": { + "line": 15, + "character": 3 + }, + "Name": "3", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "Callback(x: string | number): string | number", + "parameters": [ + { + "label": "x: string | number" + } + ], + "activeParameter": 0, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "interface name", + "Text": "Callback" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "x" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "|" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "punctuation", + "Text": "|" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/signatureHelp/trailingCommaSignatureHelpVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/trailingCommaSignatureHelpVS.baseline new file mode 100644 index 00000000000..9fba82dc559 --- /dev/null +++ b/testdata/baselines/reference/fourslash/signatureHelp/trailingCommaSignatureHelpVS.baseline @@ -0,0 +1,253 @@ +// === SignatureHelp === +=== /trailingCommaSignatureHelpVS.ts === +// function str(n: number): string; +// /** +// * Stringifies a number with radix +// * @param radix The radix +// */ +// function str(n: number, radix: number): string; +// function str(n: number, radix?: number): string { return ""; } +// +// str(1, ) +// ^ +// | ---------------------------------------------------------------------- +// | str(n: number, **radix: number**): string +// | - `radix: number`: The radix + +// | Stringifies a number with radix +// | ---------------------------------------------------------------------- +// +// declare function f(a: T): T; +// f(2, ); +// ^ +// | ---------------------------------------------------------------------- +// | f(a: 2): 2 +// | ---------------------------------------------------------------------- +[ + { + "marker": { + "Position": 221, + "LSPosition": { + "line": 8, + "character": 7 + }, + "Name": "a", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "str(n: number): string", + "parameters": [ + { + "label": "n: number" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "str" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + } + ] + } + }, + { + "label": "str(n: number, radix: number): string", + "documentation": { + "kind": "markdown", + "value": "Stringifies a number with radix" + }, + "parameters": [ + { + "label": "n: number" + }, + { + "label": "radix: number", + "documentation": { + "kind": "markdown", + "value": "The radix\n" + } + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "str" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "n" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "," + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "parameter name", + "Text": "radix" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "number" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "keyword", + "Text": "string" + } + ] + } + } + ], + "activeSignature": 1 + } + }, + { + "marker": { + "Position": 261, + "LSPosition": { + "line": 11, + "character": 5 + }, + "Name": "b", + "Data": {} + }, + "item": { + "signatures": [ + { + "label": "f(a: 2): 2", + "parameters": [ + { + "label": "a: 2" + } + ], + "activeParameter": 1, + "_vs_colorizedLabel": { + "Runs": [ + { + "ClassificationTypeName": "method name", + "Text": "f" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(" + }, + { + "ClassificationTypeName": "parameter name", + "Text": "a" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "2" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " " + }, + { + "ClassificationTypeName": "string", + "Text": "2" + } + ] + } + } + ], + "activeSignature": 0 + } + } +] \ No newline at end of file