From 88dd5471e17a4ad18aca48400563037fe3b2bd10 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 27 May 2026 23:10:39 +0000 Subject: [PATCH 1/2] deps(deps): bump microsoft/typescript-go from `c54ff7c` to `94f31f3` Bumps [microsoft/typescript-go](https://github.com/microsoft/typescript-go) from `c54ff7c` to `94f31f3`. - [Commits](https://github.com/microsoft/typescript-go/compare/c54ff7cc5528734fd303461719b54b70115f5445...94f31f32f8b5713e8fb17aaa65ba73b596485459) --- updated-dependencies: - dependency-name: microsoft/typescript-go dependency-version: 94f31f32f8b5713e8fb17aaa65ba73b596485459 dependency-type: direct:production ... Signed-off-by: dependabot[bot] --- microsoft/typescript-go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/microsoft/typescript-go b/microsoft/typescript-go index c54ff7cc5..94f31f32f 160000 --- a/microsoft/typescript-go +++ b/microsoft/typescript-go @@ -1 +1 @@ -Subproject commit c54ff7cc5528734fd303461719b54b70115f5445 +Subproject commit 94f31f32f8b5713e8fb17aaa65ba73b596485459 From 73ccf96caf1e0ae92d7ca955bcc485d91d57cb84 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 27 May 2026 23:19:38 +0000 Subject: [PATCH 2/2] chore(sync): mirror internal packages into pkg/ (auto) --- go.mod | 2 +- go.sum | 4 +- pkg/checker/checker.go | 7 +- pkg/fourslash/baselineutil.go | 3 +- pkg/fourslash/fourslash.go | 80 + .../constructorFindAllReferences1VS_test.go | 23 + .../tests/decoratorOnPrivateMethod_test.go | 36 + .../findAllRefsForDefaultExportVS_test.go | 24 + .../findAllRefsInheritedProperties1VS_test.go | 25 + ...ReferencesAcrossMultipleProjectsVS_test.go | 25 + .../tests/tsxFindAllReferences1VS_test.go | 29 + pkg/ls/crossproject.go | 28 + pkg/ls/displaypartswriter.go | 1 + pkg/ls/findallreferences.go | 216 +- pkg/ls/hover.go | 283 +- pkg/ls/signaturehelp.go | 18 +- pkg/lsp/lsproto/_generate/fetchModel.mts | 6 + pkg/lsp/lsproto/_generate/generate.mts | 100 + pkg/lsp/lsproto/_generate/metaModelSchema.mts | 6 + pkg/lsp/lsproto/lsp_generated.go | 210 + pkg/lsp/server.go | 2 + pkg/printer/printer.go | 13 +- .../compiler/cjsExportGenericTypes.symbols | 35 + .../compiler/cjsExportGenericTypes.types | 37 + .../jsDocDontBreakWithNamespacesVS.baseline | 66 +- .../jsDocFunctionSignatures5VS.baseline | 97 +- .../jsDocFunctionSignatures6VS.baseline | 436 +- .../signatureHelp/jsdocReturnsTagVS.baseline | 59 +- .../quickInfoJsDocTags13VS.baseline | 136 +- .../quickInfoJsDocTextFormatting1VS.baseline | 265 +- .../signatureHelpAfterParameterVS.baseline | 864 ++-- .../signatureHelpAnonymousTypeVS.baseline | 53 +- .../signatureHelpBindingPatternVS.baseline | 1087 +++-- ...gnatureHelpCommentsClassMembersVS.baseline | 566 ++- .../signatureHelpCommentsClassVS.baseline | 144 +- ...atureHelpCommentsCommentParsingVS.baseline | 3221 ++++++++------ ...HelpCommentsFunctionDeclarationVS.baseline | 162 +- ...eHelpCommentsFunctionExpressionVS.baseline | 140 +- ...pConstructorCallParamPropertiesVS.baseline | 34 +- ...pExpandedRestTuplesLocalLabels1VS.baseline | 3774 ++++++++++------- ...tureHelpInferenceJsDocImportTagVS.baseline | 34 +- .../signatureHelpIteratorNextVS.baseline | 808 ++-- .../signatureHelpJSDocCallbackTagVS.baseline | 252 +- .../signatureHelpJSDocTagsVS.baseline | 100 +- ...tureHelpJSMissingPropertyAccessVS.baseline | 295 +- .../signatureHelpRestArgs1VS.baseline | 360 +- .../signatureHelpRestArgs2VS.baseline | 62 +- .../signatureHelpRestArgs3VS.baseline | 437 +- .../signatureHelpSkippedArgs1VS.baseline | 360 +- .../signatureHelpTypeArguments2VS.baseline | 444 +- .../signatureHelpWithUnknownVS.baseline | 34 +- .../signatureHelp_unionTypeVS.baseline | 219 +- .../trailingCommaSignatureHelpVS.baseline | 121 +- .../constructorFindAllReferences1VS.baseline | 68 + .../findAllRefsForDefaultExportVS.baseline | 290 ++ ...findAllRefsInheritedProperties1VS.baseline | 409 ++ ...eferencesAcrossMultipleProjectsVS.baseline | 417 ++ .../tsxFindAllReferences1VS.baseline | 361 ++ .../cases/compiler/cjsExportGenericTypes.ts | 25 + 59 files changed, 11092 insertions(+), 6321 deletions(-) create mode 100644 pkg/fourslash/tests/constructorFindAllReferences1VS_test.go create mode 100644 pkg/fourslash/tests/decoratorOnPrivateMethod_test.go create mode 100644 pkg/fourslash/tests/findAllRefsForDefaultExportVS_test.go create mode 100644 pkg/fourslash/tests/findAllRefsInheritedProperties1VS_test.go create mode 100644 pkg/fourslash/tests/findReferencesAcrossMultipleProjectsVS_test.go create mode 100644 pkg/fourslash/tests/tsxFindAllReferences1VS_test.go create mode 100644 testdata/baselines/reference/compiler/cjsExportGenericTypes.symbols create mode 100644 testdata/baselines/reference/compiler/cjsExportGenericTypes.types create mode 100644 testdata/baselines/reference/fourslash/vsFindAllReferences/constructorFindAllReferences1VS.baseline create mode 100644 testdata/baselines/reference/fourslash/vsFindAllReferences/findAllRefsForDefaultExportVS.baseline create mode 100644 testdata/baselines/reference/fourslash/vsFindAllReferences/findAllRefsInheritedProperties1VS.baseline create mode 100644 testdata/baselines/reference/fourslash/vsFindAllReferences/findReferencesAcrossMultipleProjectsVS.baseline create mode 100644 testdata/baselines/reference/fourslash/vsFindAllReferences/tsxFindAllReferences1VS.baseline create mode 100644 testdata/tests/cases/compiler/cjsExportGenericTypes.ts diff --git a/go.mod b/go.mod index 4c723ad95..f98775b6e 100644 --- a/go.mod +++ b/go.mod @@ -10,7 +10,7 @@ require ( github.com/peter-evans/patience v0.3.0 github.com/zeebo/xxh3 v1.1.0 golang.org/x/sync v0.20.0 - golang.org/x/sys v0.45.0 + golang.org/x/sys v0.43.0 golang.org/x/text v0.36.0 gotest.tools/v3 v3.5.2 ) diff --git a/go.sum b/go.sum index f0a842578..8e18cf74d 100644 --- a/go.sum +++ b/go.sum @@ -16,8 +16,8 @@ github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs= github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s= golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4= golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= -golang.org/x/sys v0.45.0 h1:dO4czNzziLiiXplLQgBCEpCvXQ3dnkn0SdaZSYdQ+FY= -golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI= +golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg= golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164= gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q= diff --git a/pkg/checker/checker.go b/pkg/checker/checker.go index 7c4e02155..52f3f5857 100644 --- a/pkg/checker/checker.go +++ b/pkg/checker/checker.go @@ -15691,8 +15691,9 @@ func (c *Checker) resolveEntityName(name *ast.Node, meaning ast.SymbolFlags, ign (symbol.Flags&ast.SymbolFlagsAlias != 0 || name.Parent != nil && name.Parent.Kind == ast.KindExportAssignment) { c.markSymbolOfAliasDeclarationIfTypeOnly(getAliasDeclarationFromName(name), nil) } - if symbol.Flags&meaning == 0 && !dontResolveAlias && symbol.Flags&ast.SymbolFlagsAlias != 0 { - return c.resolveAlias(symbol) + // We know a symbol with the given meaning exists along the alias chain, so resolve until we find it. + for symbol.Flags&meaning == 0 && !dontResolveAlias && symbol.Flags&ast.SymbolFlagsAlias != 0 { + symbol = c.resolveAlias(symbol) } } return symbol @@ -30219,7 +30220,7 @@ func (c *Checker) getClassElementPropertyKeyType(element *ast.Node) *Type { } return c.stringType } - panic("Unhandled case in getClassElementPropertyKeyType") + return c.errorType } func (c *Checker) getTypeOfPropertyOfContextualType(t *Type, name string) *Type { diff --git a/pkg/fourslash/baselineutil.go b/pkg/fourslash/baselineutil.go index 2aa0347eb..8b3d48581 100644 --- a/pkg/fourslash/baselineutil.go +++ b/pkg/fourslash/baselineutil.go @@ -26,6 +26,7 @@ const ( closingTagCmd baselineCommand = "Closing Tag" documentHighlightsCmd baselineCommand = "documentHighlights" findAllReferencesCmd baselineCommand = "findAllReferences" + vsFindAllReferencesCmd baselineCommand = "vsFindAllReferences" goToDefinitionCmd baselineCommand = "goToDefinition" goToImplementationCmd baselineCommand = "goToImplementation" goToSourceDefinitionCmd baselineCommand = "goToSourceDefinition" @@ -78,7 +79,7 @@ func getBaselineFileName(t *testing.T, command baselineCommand) string { func getBaselineExtension(command baselineCommand) string { switch command { - case quickInfoCmd, signatureHelpCmd, smartSelectionCmd, inlayHintsCmd, nonSuggestionDiagnosticsCmd, documentSymbolsCmd, closingTagCmd: + case quickInfoCmd, signatureHelpCmd, smartSelectionCmd, inlayHintsCmd, nonSuggestionDiagnosticsCmd, documentSymbolsCmd, closingTagCmd, vsFindAllReferencesCmd: return "baseline" case callHierarchyCmd: return "callHierarchy.txt" diff --git a/pkg/fourslash/fourslash.go b/pkg/fourslash/fourslash.go index b9f1c350c..eae1527bc 100644 --- a/pkg/fourslash/fourslash.go +++ b/pkg/fourslash/fourslash.go @@ -2330,6 +2330,86 @@ func (f *FourslashTest) VerifyBaselineFindAllReferences( } } +func (f *FourslashTest) VerifyBaselineVsFindAllReferences( + t *testing.T, + markers ...string, +) { + referenceLocations := f.lookupMarkersOrGetRanges(t, markers) + + for _, markerOrRange := range referenceLocations { + f.GoToMarkerOrRange(t, markerOrRange) + + params := &lsproto.ReferenceParams{ + TextDocument: lsproto.TextDocumentIdentifier{ + Uri: lsconv.FileNameToDocumentURI(f.activeFilename), + }, + Position: f.currentCaretPosition, + Context: &lsproto.ReferenceContext{ + IncludeDeclaration: true, + }, + } + result := sendRequest(t, f, lsproto.TextDocumentVSReferencesInfo, params) + // Sort cross-project results for deterministic baselines + if result.VsReferenceItems != nil && len(*result.VsReferenceItems) > 0 { + items := *result.VsReferenceItems + slices.SortStableFunc(items, func(a, b *lsproto.VsReferenceItem) int { + ap, bp := "", "" + if a.VSProjectName != nil { + ap = *a.VSProjectName + } + if b.VSProjectName != nil { + bp = *b.VSProjectName + } + if ap != bp { + if ap < bp { + return -1 + } + return 1 + } + if a.VSLocation.Uri != b.VSLocation.Uri { + if string(a.VSLocation.Uri) < string(b.VSLocation.Uri) { + return -1 + } + return 1 + } + if a.VSLocation.Range.Start.Line != b.VSLocation.Range.Start.Line { + return int(a.VSLocation.Range.Start.Line) - int(b.VSLocation.Range.Start.Line) + } + return int(a.VSLocation.Range.Start.Character) - int(b.VSLocation.Range.Start.Character) + }) + // Re-number IDs sequentially after sort + idRemap := make(map[int32]int32, len(items)) + for i, item := range items { + idRemap[item.VSId] = int32(i) + item.VSId = int32(i) + } + for _, item := range items { + if item.VSDefinitionId != nil { + newDefId := idRemap[*item.VSDefinitionId] + item.VSDefinitionId = &newDefId + } + } + } + // Include file contents with markers + var locations []lsproto.Location + if result.VsReferenceItems != nil { + for _, item := range *result.VsReferenceItems { + locations = append(locations, item.VSLocation) + } + } + fileContents := f.getBaselineForLocationsWithFileContents(locations, baselineFourslashLocationsOptions{ + marker: markerOrRange, + markerName: "/*FIND ALL REFS*/", + }) + + if jsonStr, err := core.StringifyJson(result, "", " "); err == nil { + f.addResultToBaseline(t, vsFindAllReferencesCmd, fileContents+"\n\n"+jsonStr) + } else { + t.Fatalf("Failed to stringify VS references result for baseline: %v", err) + } + } +} + func (f *FourslashTest) VerifyBaselineCodeLens(t *testing.T, preferences *lsutil.UserPreferences) { if preferences != nil { reset := f.ConfigureWithReset(t, *preferences) diff --git a/pkg/fourslash/tests/constructorFindAllReferences1VS_test.go b/pkg/fourslash/tests/constructorFindAllReferences1VS_test.go new file mode 100644 index 000000000..c15f62e67 --- /dev/null +++ b/pkg/fourslash/tests/constructorFindAllReferences1VS_test.go @@ -0,0 +1,23 @@ +package fourslash_test + +import ( + "testing" + + "github.com/buke/typescript-go-internal/pkg/fourslash" + "github.com/buke/typescript-go-internal/pkg/lsp/lsproto" + "github.com/buke/typescript-go-internal/pkg/testutil" +) + +func TestConstructorFindAllReferences1VS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `export class C { + /**/public constructor() { } + public foo() { } +} + +new C().foo();` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineVsFindAllReferences(t, "") +} diff --git a/pkg/fourslash/tests/decoratorOnPrivateMethod_test.go b/pkg/fourslash/tests/decoratorOnPrivateMethod_test.go new file mode 100644 index 000000000..efba2bde4 --- /dev/null +++ b/pkg/fourslash/tests/decoratorOnPrivateMethod_test.go @@ -0,0 +1,36 @@ +package fourslash_test + +import ( + "testing" + + "github.com/buke/typescript-go-internal/pkg/fourslash" + . "github.com/buke/typescript-go-internal/pkg/fourslash/tests/util" + "github.com/buke/typescript-go-internal/pkg/testutil" +) + +func TestDecoratorCompletionOnPrivateMethod(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = ` +// @experimentalDecorators: true +declare function dec(target: any, key: string): void; +class C { + @dec/**/ + #method() {} +}` + f, done := fourslash.NewFourslash(t, nil /*capabilities*/, content) + defer done() + // Verify completions don't panic on decorator applied to private method + f.VerifyCompletions(t, "", &fourslash.CompletionsExpectedList{ + IsIncomplete: false, + ItemDefaults: &fourslash.CompletionsExpectedItemDefaults{ + CommitCharacters: &DefaultCommitCharacters, + EditRange: Ignored, + }, + Items: &fourslash.CompletionsExpectedItems{ + Includes: []fourslash.CompletionsExpectedItem{ + "dec", + }, + }, + }) +} diff --git a/pkg/fourslash/tests/findAllRefsForDefaultExportVS_test.go b/pkg/fourslash/tests/findAllRefsForDefaultExportVS_test.go new file mode 100644 index 000000000..f908c2384 --- /dev/null +++ b/pkg/fourslash/tests/findAllRefsForDefaultExportVS_test.go @@ -0,0 +1,24 @@ +package fourslash_test + +import ( + "testing" + + "github.com/buke/typescript-go-internal/pkg/fourslash" + "github.com/buke/typescript-go-internal/pkg/lsp/lsproto" + "github.com/buke/typescript-go-internal/pkg/testutil" +) + +func TestFindAllRefsForDefaultExportVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `// @Filename: a.ts +export default function /*def*/f() {} +// @Filename: b.ts +import /*deg*/g from "./a"; +[|/*ref*/g|](); +// @Filename: c.ts +import { f } from "./a";` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineVsFindAllReferences(t, "def", "deg") +} diff --git a/pkg/fourslash/tests/findAllRefsInheritedProperties1VS_test.go b/pkg/fourslash/tests/findAllRefsInheritedProperties1VS_test.go new file mode 100644 index 000000000..0abea3ca9 --- /dev/null +++ b/pkg/fourslash/tests/findAllRefsInheritedProperties1VS_test.go @@ -0,0 +1,25 @@ +package fourslash_test + +import ( + "testing" + + "github.com/buke/typescript-go-internal/pkg/fourslash" + "github.com/buke/typescript-go-internal/pkg/lsp/lsproto" + "github.com/buke/typescript-go-internal/pkg/testutil" +) + +func TestFindAllRefsInheritedProperties1VS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `class class1 extends class1 { + /*1*/doStuff() { } + /*2*/propName: string; +} + +var v: class1; +v./*3*/doStuff(); +v./*4*/propName;` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineVsFindAllReferences(t, "1", "2", "3", "4") +} diff --git a/pkg/fourslash/tests/findReferencesAcrossMultipleProjectsVS_test.go b/pkg/fourslash/tests/findReferencesAcrossMultipleProjectsVS_test.go new file mode 100644 index 000000000..9ef7b6fc9 --- /dev/null +++ b/pkg/fourslash/tests/findReferencesAcrossMultipleProjectsVS_test.go @@ -0,0 +1,25 @@ +package fourslash_test + +import ( + "testing" + + "github.com/buke/typescript-go-internal/pkg/fourslash" + "github.com/buke/typescript-go-internal/pkg/lsp/lsproto" + "github.com/buke/typescript-go-internal/pkg/testutil" +) + +func TestFindReferencesAcrossMultipleProjectsVS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `//@Filename: a.ts +/*1*/var /*2*/x: number; +//@Filename: b.ts +/// +/*3*/x++; +//@Filename: c.ts +/// +/*4*/x++;` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineVsFindAllReferences(t, "1", "2", "3", "4") +} diff --git a/pkg/fourslash/tests/tsxFindAllReferences1VS_test.go b/pkg/fourslash/tests/tsxFindAllReferences1VS_test.go new file mode 100644 index 000000000..958c89a47 --- /dev/null +++ b/pkg/fourslash/tests/tsxFindAllReferences1VS_test.go @@ -0,0 +1,29 @@ +package fourslash_test + +import ( + "testing" + + "github.com/buke/typescript-go-internal/pkg/fourslash" + "github.com/buke/typescript-go-internal/pkg/lsp/lsproto" + "github.com/buke/typescript-go-internal/pkg/testutil" +) + +func TestTsxFindAllReferences1VS(t *testing.T) { + t.Parallel() + defer testutil.RecoverAndFail(t, "Panic on fourslash test") + const content = `//@Filename: file.tsx +declare namespace JSX { + interface Element { } + interface IntrinsicElements { + /*1*/div: { + name?: string; + isOpen?: boolean; + }; + span: { n: string; }; + } +} +var x = /*2*/;` + f, done := fourslash.NewFourslash(t, &lsproto.ClientCapabilities{VSSupportsVisualStudioExtensions: new(true)}, content) + defer done() + f.VerifyBaselineVsFindAllReferences(t, "1", "2", "3") +} diff --git a/pkg/ls/crossproject.go b/pkg/ls/crossproject.go index 71675a866..b0beeeae4 100644 --- a/pkg/ls/crossproject.go +++ b/pkg/ls/crossproject.go @@ -308,6 +308,34 @@ func combineReferences(results iter.Seq[lsproto.ReferencesResponse]) lsproto.Ref return lsproto.LocationsOrNull{Locations: combineResponseLocations(results)} } +func combineVsReferences(results iter.Seq[lsproto.VsReferencesResponse]) lsproto.VsReferencesResponse { + var combined []*lsproto.VsReferenceItem + // Re-number IDs across projects to maintain unique IDs and correct definition references + nextId := int32(0) + for resp := range results { + if resp.VsReferenceItems == nil { + continue + } + // Map old IDs to new IDs for this batch + idMap := make(map[int32]int32) + for _, item := range *resp.VsReferenceItems { + oldId := item.VSId + newId := nextId + idMap[oldId] = newId + nextId++ + + newItem := *item + newItem.VSId = newId + if item.VSDefinitionId != nil { + newDefId := idMap[*item.VSDefinitionId] + newItem.VSDefinitionId = &newDefId + } + combined = append(combined, &newItem) + } + } + return lsproto.VsReferencesResponse{VsReferenceItems: &combined} +} + func combineImplementations(results iter.Seq[lsproto.ImplementationResponse]) lsproto.ImplementationResponse { var combined []*lsproto.LocationLink var seenLocations collections.Set[lsproto.Location] diff --git a/pkg/ls/displaypartswriter.go b/pkg/ls/displaypartswriter.go index 40e6602b0..6ce4768e7 100644 --- a/pkg/ls/displaypartswriter.go +++ b/pkg/ls/displaypartswriter.go @@ -35,6 +35,7 @@ func (w *displayPartsWriter) addRun(classification lsproto.ClassificationTypeNam w.runs = append(w.runs, &lsproto.ClassifiedTextRun{ ClassificationTypeName: string(classification), Text: text, + VSType: "ClassifiedTextRun", }) } w.lastWritten = text diff --git a/pkg/ls/findallreferences.go b/pkg/ls/findallreferences.go index f845abb2f..0a170e4a2 100644 --- a/pkg/ls/findallreferences.go +++ b/pkg/ls/findallreferences.go @@ -669,6 +669,20 @@ func (l *LanguageService) ProvideReferences(ctx context.Context, params *lsproto ) } +func (l *LanguageService) ProvideVsReferences(ctx context.Context, params *lsproto.ReferenceParams, orchestrator CrossProjectOrchestrator) (lsproto.VsReferencesResponse, error) { + return handleCrossProject( + l, + ctx, + params, + orchestrator, + (*LanguageService).symbolAndEntriesToVsReferences, + combineVsReferences, + false, /*isRename*/ + false, /*implementations*/ + symbolEntryTransformOptions{}, + ) +} + func (l *LanguageService) symbolAndEntriesToReferences(ctx context.Context, params *lsproto.ReferenceParams, data SymbolAndEntriesData, options symbolEntryTransformOptions) (lsproto.ReferencesResponse, error) { // `findReferencedSymbols` except only computes the information needed to return reference locations locations := core.FlatMap(data.SymbolsAndEntries, func(s *SymbolAndEntries) []lsproto.Location { @@ -677,6 +691,206 @@ func (l *LanguageService) symbolAndEntriesToReferences(ctx context.Context, para return lsproto.LocationsOrNull{Locations: &locations}, nil } +func (l *LanguageService) symbolAndEntriesToVsReferences(ctx context.Context, params *lsproto.ReferenceParams, data SymbolAndEntriesData, options symbolEntryTransformOptions) (lsproto.VsReferencesResponse, error) { + caps := lsproto.GetClientCapabilities(ctx) + vsCapability := caps.VSSupportsVisualStudioExtensions + var items []*lsproto.VsReferenceItem + id := int32(0) + projectName := string(l.projectPath) + + for _, s := range data.SymbolsAndEntries { + if s.definition == nil { + continue + } + + // Convert definition to info + defInfo := l.definitionToReferencedSymbolDefinitionInfo(ctx, s.definition, data.OriginalNode, vsCapability) + if defInfo == nil { + continue + } + + // Create the definition item + definitionId := id + emptyStr := "" + defItem := &lsproto.VsReferenceItem{ + VSId: definitionId, + VSLocation: defInfo.location, + VSDefinitionText: defInfo.displayText, + VSKind: &[]lsproto.VsReferenceKind{lsproto.VsReferenceKindUnknown}, + VSProjectName: &projectName, + VSContainingType: &emptyStr, + } + items = append(items, defItem) + id++ + + // Create reference items grouped under the definition + for _, ref := range s.references { + // Skip the declaration itself (already represented by the definition item) + if s.definition.symbol != nil && isDeclarationOfSymbol(ref.node, s.definition.symbol) { + continue + } + + refLocation := l.getLocationOfEntry(ref) + + // Determine read/write kind + kind := lsproto.VsReferenceKindRead + if ref.kind != entryKindRange && ref.node != nil && ast.IsWriteAccessForReference(ref.node) { + kind = lsproto.VsReferenceKindWrite + } + + refItem := &lsproto.VsReferenceItem{ + VSId: id, + VSDefinitionId: &definitionId, + VSLocation: refLocation, + VSKind: &[]lsproto.VsReferenceKind{kind}, + VSProjectName: &projectName, + } + items = append(items, refItem) + id++ + } + } + + return lsproto.VsReferencesResponse{VsReferenceItems: &items}, nil +} + +// referencedSymbolDefinitionInfo holds the computed info for a definition +type referencedSymbolDefinitionInfo struct { + node *ast.Node + location lsproto.Location + displayText *lsproto.ClassifiedTextElement +} + +// definitionToReferencedSymbolDefinitionInfo converts a Definition to display info +func (l *LanguageService) definitionToReferencedSymbolDefinitionInfo(ctx context.Context, def *Definition, originalNode *ast.Node, vsCapability bool) *referencedSymbolDefinitionInfo { + switch def.Kind { + case definitionKindSymbol: + symbol := def.symbol + if symbol == nil { + return nil + } + // Get display parts + element := l.getDefinitionKindAndDisplayParts(ctx, symbol, originalNode, vsCapability) + + // Get the definition node + var node *ast.Node + if len(symbol.Declarations) > 0 { + decl := symbol.Declarations[0] + node = core.OrElse(decl.Name(), decl) + } else { + node = originalNode + } + + loc := l.getLocationOfEntry(&ReferenceEntry{kind: entryKindNode, node: node}) + return &referencedSymbolDefinitionInfo{ + node: node, + location: loc, + displayText: element, + } + + case definitionKindLabel: + node := def.node + if node == nil { + return nil + } + loc := l.getLocationOfEntry(&ReferenceEntry{kind: entryKindNode, node: node}) + return &referencedSymbolDefinitionInfo{ + node: node, + location: loc, + displayText: &lsproto.ClassifiedTextElement{ + Runs: []*lsproto.ClassifiedTextRun{{Text: node.Text(), ClassificationTypeName: string(lsproto.ClassificationTypeNameText), VSType: "ClassifiedTextRun"}}, + VSType: "ClassifiedTextElement", + }, + } + + case definitionKindKeyword: + node := def.node + if node == nil { + return nil + } + name := scanner.TokenToString(node.Kind) + loc := l.getLocationOfEntry(&ReferenceEntry{kind: entryKindNode, node: node}) + return &referencedSymbolDefinitionInfo{ + node: node, + location: loc, + displayText: &lsproto.ClassifiedTextElement{ + Runs: []*lsproto.ClassifiedTextRun{{Text: name, ClassificationTypeName: string(lsproto.ClassificationTypeNameKeyword), VSType: "ClassifiedTextRun"}}, + VSType: "ClassifiedTextElement", + }, + } + + case definitionKindThis: + node := def.node + if node == nil { + return nil + } + symbol := def.symbol + if symbol == nil { + return nil + } + element := l.getDefinitionKindAndDisplayParts(ctx, symbol, node, vsCapability) + loc := l.getLocationOfEntry(&ReferenceEntry{kind: entryKindNode, node: node}) + return &referencedSymbolDefinitionInfo{ + node: node, + location: loc, + displayText: element, + } + + case definitionKindString: + node := def.node + if node == nil { + return nil + } + loc := l.getLocationOfEntry(&ReferenceEntry{kind: entryKindNode, node: node}) + return &referencedSymbolDefinitionInfo{ + node: node, + location: loc, + displayText: &lsproto.ClassifiedTextElement{ + Runs: []*lsproto.ClassifiedTextRun{{Text: node.Text(), ClassificationTypeName: string(lsproto.ClassificationTypeNameString), VSType: "ClassifiedTextRun"}}, + VSType: "ClassifiedTextElement", + }, + } + + case definitionKindTripleSlashReference: + if def.tripleSlashFileRef == nil || def.tripleSlashFileRef.file == nil { + return nil + } + node := def.tripleSlashFileRef.file.AsNode() + loc := l.getLocationOfEntry(&ReferenceEntry{kind: entryKindNode, node: node}) + return &referencedSymbolDefinitionInfo{ + node: node, + location: loc, + displayText: &lsproto.ClassifiedTextElement{ + Runs: []*lsproto.ClassifiedTextRun{{Text: `"` + def.tripleSlashFileRef.reference.FileName + `"`, ClassificationTypeName: string(lsproto.ClassificationTypeNameString), VSType: "ClassifiedTextRun"}}, + VSType: "ClassifiedTextElement", + }, + } + + default: + return nil + } +} + +// getDefinitionKindAndDisplayParts returns the classified display text for a symbol definition. +func (l *LanguageService) getDefinitionKindAndDisplayParts(ctx context.Context, symbol *ast.Symbol, originalNode *ast.Node, vsCapability bool) *lsproto.ClassifiedTextElement { + program := l.GetProgram() + c, done := program.GetTypeChecker(ctx) + defer done() + + meaning := getIntersectingMeaningFromDeclarations(originalNode, symbol, ast.SemanticMeaningAll) + + info := getQuickInfoAndDeclarationAtLocation(c, symbol, originalNode, nil, vsCapability, meaning) + + if vsCapability { + return &lsproto.ClassifiedTextElement{Runs: info.displayParts.GetRuns(), VSType: "ClassifiedTextElement"} + } + // Fallback: single unclassified run with the full text + text := info.displayParts.String() + return &lsproto.ClassifiedTextElement{ + Runs: []*lsproto.ClassifiedTextRun{{Text: text, ClassificationTypeName: string(lsproto.ClassificationTypeNameText), VSType: "ClassifiedTextRun"}}, + VSType: "ClassifiedTextElement", + } +} + func (l *LanguageService) ProvideImplementations(ctx context.Context, params *lsproto.ImplementationParams, orchestrator CrossProjectOrchestrator) (lsproto.ImplementationResponse, error) { return l.provideImplementationsEx(ctx, params, symbolEntryTransformOptions{}, orchestrator) } @@ -729,7 +943,7 @@ func (l *LanguageService) convertSymbolAndEntriesToLocations(s *SymbolAndEntries } func isDeclarationOfSymbol(node *ast.Node, target *ast.Symbol) bool { - if target == nil { + if node == nil || target == nil { return false } diff --git a/pkg/ls/hover.go b/pkg/ls/hover.go index 462bd36e2..08f4ae792 100644 --- a/pkg/ls/hover.go +++ b/pkg/ls/hover.go @@ -11,6 +11,8 @@ import ( "github.com/buke/typescript-go-internal/pkg/collections" "github.com/buke/typescript-go-internal/pkg/core" "github.com/buke/typescript-go-internal/pkg/lsp/lsproto" + "github.com/buke/typescript-go-internal/pkg/nodebuilder" + "github.com/buke/typescript-go-internal/pkg/printer" "github.com/buke/typescript-go-internal/pkg/scanner" ) @@ -83,7 +85,8 @@ func (l *LanguageService) ProvideHover(ctx context.Context, params *lsproto.Hove } func (l *LanguageService) getQuickInfoAndDocumentationForSymbol(c *checker.Checker, symbol *ast.Symbol, node *ast.Node, contentFormat lsproto.MarkupKind, vc *checker.VerbosityContext) (string, string) { - quickInfo, declaration := getQuickInfoAndDeclarationAtLocation(c, symbol, node, vc) + info := getQuickInfoAndDeclarationAtLocation(c, symbol, node, vc, false /*vsCapability*/, getMeaningFromLocation(node)) + quickInfo := info.displayParts.String() if quickInfo == "" { return "", "" } @@ -93,7 +96,7 @@ func (l *LanguageService) getQuickInfoAndDocumentationForSymbol(c *checker.Check return quickInfo, documentation } - documentation = l.getDocumentationFromDeclaration(c, symbol, declaration, node, contentFormat, false /*commentOnly*/) + documentation = l.getDocumentationFromDeclaration(c, symbol, info.declaration, node, contentFormat, false /*commentOnly*/) if documentation != "" { return quickInfo, documentation } @@ -301,29 +304,114 @@ func shouldGetType(node *ast.Node) bool { } } -func getQuickInfoAndDeclarationAtLocation(c *checker.Checker, symbol *ast.Symbol, node *ast.Node, vc *checker.VerbosityContext) (string, *ast.Node) { +// symbolDisplayInfo holds the result of getSymbolDisplayPartsDocumentationAndSymbolKind. +type symbolDisplayInfo struct { + displayParts *displayPartsWriter + declaration *ast.Node +} + +// getQuickInfoAndDeclarationAtLocation builds classified display parts using displayPartsWriter when vsCapability is true. +// When vsCapability is false, it still builds the plain text string but skips classification runs. +func getQuickInfoAndDeclarationAtLocation(c *checker.Checker, symbol *ast.Symbol, node *ast.Node, vc *checker.VerbosityContext, vsCapability bool, meaning ast.SemanticMeaning) symbolDisplayInfo { container := getContainerNode(node) if vc == nil { vc = &checker.VerbosityContext{} } - typeToString := func(t *checker.Type, enclosing *ast.Node, flags checker.TypeFormatFlags) string { + dpw := newDisplayPartsWriter(vsCapability) + + // Source file for printer context + var sourceFile *ast.SourceFile + if node != nil { + sourceFile = ast.GetSourceFileOfNode(node) + } + + // nodeBuilderFlags for classified output (same as signatureHelpNodeBuilderFlags) + const classifiedNodeBuilderFlags = nodebuilder.FlagsIgnoreErrors | nodebuilder.FlagsUseAliasDefinedOutsideCurrentScope | nodebuilder.FlagsWriteTypeParametersInQualifiedName + + // writeTypeClassified writes a type to dpw with proper classification (punctuation, symbols, keywords). + // Falls back to flat text when vsCapability is false or when TypeToTypeNode fails. + writeTypeClassified := func(t *checker.Type, enclosing *ast.Node, flags checker.TypeFormatFlags) { flags |= checker.TypeFormatFlagsMultilineObjectLiterals - return c.TypeToStringEx(t, enclosing, flags, vc) + if !vsCapability { + dpw.Write(c.TypeToStringEx(t, enclosing, flags, vc)) + return + } + emitContext := printer.NewEmitContext() + idToSymbol := make(map[*ast.IdentifierNode]*ast.Symbol) + nb := checker.NewNodeBuilderEx(c, emitContext, idToSymbol) + combinedFlags := nodebuilder.Flags(flags&checker.TypeFormatFlagsNodeBuilderFlagsMask) | classifiedNodeBuilderFlags + typeNode := nb.TypeToTypeNode(t, enclosing, combinedFlags, nodebuilder.InternalFlagsNone, nil) + if typeNode == nil { + dpw.Write(c.TypeToStringEx(t, enclosing, flags, vc)) + return + } + p := printer.NewPrinter(printer.PrinterOptions{NewLine: core.NewLineKindLF}, printer.PrintHandlers{}, emitContext) + p.IdToSymbol = idToSymbol + tempDpw := newDisplayPartsWriter(true) + p.Write(typeNode, sourceFile, tempDpw, nil) + dpw.WriteFrom(tempDpw) } - signatureToString := func(sig *checker.Signature, enclosing *ast.Node, flags checker.TypeFormatFlags) string { + + // writeSignatureClassified writes a signature to dpw with proper classification. + writeSignatureClassified := func(sig *checker.Signature, enclosing *ast.Node, flags checker.TypeFormatFlags) { flags |= checker.TypeFormatFlagsMultilineObjectLiterals - return c.SignatureToStringEx(sig, enclosing, flags, vc) + if !vsCapability { + dpw.Write(c.SignatureToStringEx(sig, enclosing, flags, vc)) + return + } + isConstructor := sig.Flags()&checker.SignatureFlagsConstruct != 0 && flags&checker.TypeFormatFlagsWriteCallStyleSignature == 0 + var sigOutput ast.Kind + if flags&checker.TypeFormatFlagsWriteArrowStyleSignature != 0 { + if isConstructor { + sigOutput = ast.KindConstructorType + } else { + sigOutput = ast.KindFunctionType + } + } else { + if isConstructor { + sigOutput = ast.KindConstructSignature + } else { + sigOutput = ast.KindCallSignature + } + } + emitContext := printer.NewEmitContext() + idToSymbol := make(map[*ast.IdentifierNode]*ast.Symbol) + nb := checker.NewNodeBuilderEx(c, emitContext, idToSymbol) + combinedFlags := nodebuilder.Flags(flags&checker.TypeFormatFlagsNodeBuilderFlagsMask) | classifiedNodeBuilderFlags + sigNode := nb.SignatureToSignatureDeclaration(sig, sigOutput, enclosing, combinedFlags, nodebuilder.InternalFlagsNone, nil) + if sigNode == nil { + dpw.Write(c.SignatureToStringEx(sig, enclosing, flags, vc)) + return + } + p := printer.NewPrinter(printer.PrinterOptions{NewLine: core.NewLineKindLF}, printer.PrintHandlers{}, emitContext) + p.IdToSymbol = idToSymbol + tempDpw := newDisplayPartsWriter(true) + p.Write(sigNode, sourceFile, tempDpw, nil) + dpw.WriteFrom(tempDpw) + } + + // writeSymbolClassified writes a symbol name to dpw with proper classification based on symbol flags. + writeSymbolClassified := func(symbol *ast.Symbol, enclosing *ast.Node, meaning ast.SymbolFlags, flags checker.SymbolFormatFlags) { + if !vsCapability { + dpw.Write(c.SymbolToStringEx(symbol, enclosing, meaning, flags)) + return + } + // Use WriteSymbol which calls classificationForSymbol to determine the correct classification + text := c.SymbolToStringEx(symbol, enclosing, meaning, flags) + dpw.WriteSymbol(text, symbol) } if node.Kind == ast.KindThisKeyword && ast.IsInExpressionContext(node) || ast.IsThisInTypeQuery(node) { - return "this: " + typeToString(c.GetTypeAtLocation(node), container, typeFormatFlags), nil + dpw.WriteKeyword("this") + dpw.WritePunctuation(": ") + writeTypeClassified(c.GetTypeAtLocation(node), container, typeFormatFlags) + return symbolDisplayInfo{displayParts: dpw} } if symbol == nil { if shouldGetType(node) { - return typeToString(c.GetTypeAtLocation(node), container, typeFormatFlags), nil + writeTypeClassified(c.GetTypeAtLocation(node), container, typeFormatFlags) } - return "", nil + return symbolDisplayInfo{displayParts: dpw} } - var b strings.Builder var visitedAliases collections.Set[*ast.Symbol] var aliasLevel int var firstDeclaration *ast.Node @@ -333,48 +421,56 @@ func getQuickInfoAndDeclarationAtLocation(c *checker.Checker, symbol *ast.Symbol } } writeNewLine := func() { - if b.Len() != 0 { - b.WriteString("\n") + if dpw.String() != "" { + dpw.Write("\n") } if aliasLevel != 0 { - b.WriteString("(alias) ") + dpw.WritePunctuation("(") + dpw.Write("alias") + dpw.WritePunctuation(") ") } } - writeSignatures := func(signatures []*checker.Signature, prefix string, symbol *ast.Symbol) { + writeSignatures := func(signatures []*checker.Signature, prefix string, parenthesized bool, symbol *ast.Symbol) { for i, sig := range signatures { writeNewLine() if i == 3 && len(signatures) >= 5 { - b.WriteString(fmt.Sprintf("// +%v more overloads", len(signatures)-3)) + dpw.WriteComment(fmt.Sprintf("// +%v more overloads", len(signatures)-3)) break } - b.WriteString(prefix) - b.WriteString(c.SymbolToStringEx(symbol, container, ast.SymbolFlagsNone, symbolFormatFlags)) + if parenthesized { + dpw.WritePunctuation("(") + dpw.Write(prefix) + dpw.WritePunctuation(") ") + } else { + dpw.WriteKeyword(prefix) + } + writeSymbolClassified(symbol, container, ast.SymbolFlagsNone, symbolFormatFlags) if symbol.Flags&ast.SymbolFlagsOptional != 0 { - b.WriteByte('?') + dpw.WritePunctuation("?") } - b.WriteString(signatureToString(sig, container, typeFormatFlags|checker.TypeFormatFlagsWriteCallStyleSignature|checker.TypeFormatFlagsWriteTypeArgumentsOfSignature)) + writeSignatureClassified(sig, container, typeFormatFlags|checker.TypeFormatFlagsWriteCallStyleSignature|checker.TypeFormatFlagsWriteTypeArgumentsOfSignature) } } writeTypeParams := func(params []*checker.Type) { if len(params) > 0 { - b.WriteString("<") + dpw.WritePunctuation("<") for i, tp := range params { if i != 0 { - b.WriteString(", ") + dpw.WritePunctuation(", ") } - b.WriteString(c.SymbolToStringEx(tp.Symbol(), nil, ast.SymbolFlagsNone, symbolFormatFlags)) + writeSymbolClassified(tp.Symbol(), nil, ast.SymbolFlagsNone, symbolFormatFlags) cons := c.GetConstraintOfTypeParameter(tp) if cons != nil { - b.WriteString(" extends ") - b.WriteString(typeToString(cons, nil, typeFormatFlags)) + dpw.WriteKeyword(" extends ") + writeTypeClassified(cons, nil, typeFormatFlags) } def := c.GetDefaultFromTypeParameter(tp) if def != nil { - b.WriteString(" = ") - b.WriteString(typeToString(def, nil, typeFormatFlags)) + dpw.WriteOperator(" = ") + writeTypeClassified(def, nil, typeFormatFlags) } } - b.WriteString(">") + dpw.WritePunctuation(">") } } symbolWasExpanded := false @@ -418,7 +514,7 @@ func getQuickInfoAndDeclarationAtLocation(c *checker.Checker, symbol *ast.Symbol if expanded != "" { vc.CanIncreaseVerbosity = vc.CanIncreaseVerbosity || expandVC.CanIncreaseVerbosity vc.Truncated = vc.Truncated || expandVC.Truncated - b.WriteString(expanded) + dpw.Write(expanded) symbolWasExpanded = true return true } @@ -436,7 +532,7 @@ func getQuickInfoAndDeclarationAtLocation(c *checker.Checker, symbol *ast.Symbol } } var flags ast.SymbolFlags - switch getMeaningFromLocation(node) { + switch meaning { case ast.SemanticMeaningValue: flags = symbol.Flags & (ast.SymbolFlagsValue | ast.SymbolFlagsSignature) case ast.SemanticMeaningType: @@ -447,7 +543,7 @@ func getQuickInfoAndDeclarationAtLocation(c *checker.Checker, symbol *ast.Symbol flags = symbol.Flags & (ast.SymbolFlagsValue | ast.SymbolFlagsSignature | ast.SymbolFlagsType | ast.SymbolFlagsNamespace) } if flags == 0 { - if aliasLevel != 0 || b.Len() != 0 { + if aliasLevel != 0 || dpw.String() != "" { return } flags = symbol.Flags & (ast.SymbolFlagsValue | ast.SymbolFlagsSignature | ast.SymbolFlagsType | ast.SymbolFlagsNamespace) @@ -463,45 +559,52 @@ func getQuickInfoAndDeclarationAtLocation(c *checker.Checker, symbol *ast.Symbol if symbol.CheckFlags&ast.CheckFlagsIndexSymbol == 0 { switch { case flags&ast.SymbolFlagsProperty != 0: - b.WriteString("(property) ") + dpw.WritePunctuation("(") + dpw.Write("property") + dpw.WritePunctuation(") ") case flags&ast.SymbolFlagsAccessor != 0: - b.WriteString("(accessor) ") + dpw.WritePunctuation("(") + dpw.Write("accessor") + dpw.WritePunctuation(") ") default: decl := symbol.ValueDeclaration if decl != nil { decl = ast.GetRootDeclaration(decl) switch { case ast.IsParameterDeclaration(decl): - b.WriteString("(parameter) ") + dpw.WritePunctuation("(") + dpw.Write("parameter") + dpw.WritePunctuation(") ") case ast.IsVarLet(decl): - b.WriteString("let ") + dpw.WriteKeyword("let ") case ast.IsVarConst(decl): - b.WriteString("const ") + dpw.WriteKeyword("const ") case ast.IsVarUsing(decl): - b.WriteString("using ") + dpw.WriteKeyword("using ") case ast.IsVarAwaitUsing(decl): - b.WriteString("await using ") + dpw.WriteKeyword("await ") + dpw.WriteKeyword("using ") default: - b.WriteString("var ") + dpw.WriteKeyword("var ") } } } if symbol.Name == ast.InternalSymbolNameExportEquals && symbol.Parent != nil && symbol.Parent.Flags&ast.SymbolFlagsModule != 0 { - b.WriteString("exports") + dpw.Write("exports") } else { - b.WriteString(c.SymbolToStringEx(symbol, container, ast.SymbolFlagsNone, symbolFormatFlags)) + writeSymbolClassified(symbol, container, ast.SymbolFlagsNone, symbolFormatFlags) } if symbol.Flags&ast.SymbolFlagsOptional != 0 { - b.WriteByte('?') + dpw.WritePunctuation("?") } - b.WriteString(": ") + dpw.WritePunctuation(": ") } if callNode := getCallOrNewExpression(node); callNode != nil { flags := typeFormatFlags | checker.TypeFormatFlagsWriteTypeArgumentsOfSignature | checker.TypeFormatFlagsWriteArrowStyleSignature if ast.IsCallExpression(callNode) { flags |= checker.TypeFormatFlagsWriteCallStyleSignature } - b.WriteString(signatureToString(c.GetResolvedSignature(callNode), container, flags)) + writeSignatureClassified(c.GetResolvedSignature(callNode), container, flags) } else { t := c.GetTypeOfSymbolAtLocation(symbol, node) // If the type is a constrained type parameter, support expansion: @@ -513,36 +616,39 @@ func getQuickInfoAndDeclarationAtLocation(c *checker.Checker, symbol *ast.Symbol Level: vc.Level - 1, MaxTruncationLength: vc.MaxTruncationLength, } - b.WriteString(typeParameterToString(c, t, container, expandVC)) + dpw.Write(typeParameterToString(c, t, container, expandVC)) vc.CanIncreaseVerbosity = vc.CanIncreaseVerbosity || expandVC.CanIncreaseVerbosity vc.Truncated = vc.Truncated || expandVC.Truncated } else { - b.WriteString(typeToString(t, container, typeFormatFlags)) + writeTypeClassified(t, container, typeFormatFlags) vc.CanIncreaseVerbosity = true } } else { - b.WriteString(typeToString(t, container, typeFormatFlags)) + writeTypeClassified(t, container, typeFormatFlags) } } setDeclaration(symbol.ValueDeclaration) } if flags&ast.SymbolFlagsEnumMember != 0 { writeNewLine() - b.WriteString("(enum member) ") + dpw.WritePunctuation("(") + dpw.Write("enum member") + dpw.WritePunctuation(") ") t := c.GetTypeOfSymbol(symbol) - b.WriteString(typeToString(t, container, typeFormatFlags)) + writeTypeClassified(t, container, typeFormatFlags) if t.Flags()&checker.TypeFlagsLiteral != 0 { - b.WriteString(" = ") - b.WriteString(t.AsLiteralType().String()) + dpw.WriteOperator(" = ") + dpw.WriteLiteral(t.AsLiteralType().String()) } setDeclaration(symbol.ValueDeclaration) } if flags&(ast.SymbolFlagsFunction|ast.SymbolFlagsMethod) != 0 { - prefix := core.IfElse(flags&ast.SymbolFlagsMethod != 0, "(method) ", "function ") + isMethod := flags&ast.SymbolFlagsMethod != 0 + prefix := core.IfElse(isMethod, "method", "function ") if ast.IsIdentifier(node) && (ast.IsFunctionLikeDeclaration(node.Parent) || ast.IsMethodSignatureDeclaration(node.Parent)) && node.Parent.Name() == node { setDeclaration(node.Parent) signatures := []*checker.Signature{c.GetSignatureFromDeclaration(node.Parent)} - writeSignatures(signatures, prefix, symbol) + writeSignatures(signatures, prefix, isMethod, symbol) } else { signatures := getSignaturesAtLocation(c, symbol, checker.SignatureKindCall, node) if len(signatures) == 1 { @@ -550,18 +656,18 @@ func getQuickInfoAndDeclarationAtLocation(c *checker.Checker, symbol *ast.Symbol setDeclaration(d) } } - writeSignatures(signatures, prefix, symbol) + writeSignatures(signatures, prefix, isMethod, symbol) } setDeclaration(symbol.ValueDeclaration) } if flags&(ast.SymbolFlagsClass|ast.SymbolFlagsInterface) != 0 { if node.Kind == ast.KindThisKeyword || ast.IsThisInTypeQuery(node) { writeNewLine() - b.WriteString("this") + dpw.WriteKeyword("this") } else if node.Kind == ast.KindConstructorKeyword && (ast.IsConstructorDeclaration(node.Parent) || ast.IsConstructSignatureDeclaration(node.Parent)) { setDeclaration(node.Parent) signatures := []*checker.Signature{c.GetSignatureFromDeclaration(node.Parent)} - writeSignatures(signatures, "constructor ", symbol) + writeSignatures(signatures, "constructor ", false, symbol) } else { var signatures []*checker.Signature if flags&ast.SymbolFlagsClass != 0 && getCallOrNewExpression(node) != nil { @@ -571,32 +677,34 @@ func getQuickInfoAndDeclarationAtLocation(c *checker.Checker, symbol *ast.Symbol if d := signatures[0].Declaration(); d != nil && d.Flags&ast.NodeFlagsJSDoc == 0 { setDeclaration(d) } - writeSignatures(signatures, "constructor ", symbol) + writeSignatures(signatures, "constructor ", false, symbol) } else { writeNewLine() if flags&ast.SymbolFlagsClass != 0 { classExpression := ast.GetDeclarationOfKind(symbol, ast.KindClassExpression) if classExpression != nil { // Local class expression: show "(local class)" prefix - b.WriteString("(local class) ") + dpw.WritePunctuation("(") + dpw.Write("local class") + dpw.WritePunctuation(") ") } if !tryExpandSymbol(symbol, flags) { if classExpression == nil { if core.Some(symbol.Declarations, func(d *ast.Node) bool { return ast.IsClassDeclaration(d) && ast.HasAbstractModifier(d) }) { - b.WriteString("abstract ") + dpw.WriteKeyword("abstract ") } - b.WriteString("class ") + dpw.WriteKeyword("class ") } - b.WriteString(c.SymbolToStringEx(symbol, container, ast.SymbolFlagsNone, symbolFormatFlags)) + writeSymbolClassified(symbol, container, ast.SymbolFlagsNone, symbolFormatFlags) params := c.GetDeclaredTypeOfSymbol(symbol).AsInterfaceType().LocalTypeParameters() writeTypeParams(params) } } else { if !tryExpandSymbol(symbol, flags) { - b.WriteString("interface ") - b.WriteString(c.SymbolToStringEx(symbol, container, ast.SymbolFlagsNone, symbolFormatFlags)) + dpw.WriteKeyword("interface ") + writeSymbolClassified(symbol, container, ast.SymbolFlagsNone, symbolFormatFlags) params := c.GetDeclaredTypeOfSymbol(symbol).AsInterfaceType().LocalTypeParameters() writeTypeParams(params) } @@ -615,10 +723,10 @@ func getQuickInfoAndDeclarationAtLocation(c *checker.Checker, symbol *ast.Symbol if core.Some(symbol.Declarations, func(d *ast.Node) bool { return ast.IsEnumDeclaration(d) && ast.IsEnumConst(d) }) { - b.WriteString("const ") + dpw.WriteKeyword("const ") } - b.WriteString("enum ") - b.WriteString(c.SymbolToStringEx(symbol, container, ast.SymbolFlagsNone, symbolFormatFlags)) + dpw.WriteKeyword("enum ") + writeSymbolClassified(symbol, container, ast.SymbolFlagsNone, symbolFormatFlags) } setDeclaration(core.Find(symbol.Declarations, ast.IsEnumDeclaration)) } @@ -626,26 +734,28 @@ func getQuickInfoAndDeclarationAtLocation(c *checker.Checker, symbol *ast.Symbol writeNewLine() if !tryExpandSymbol(symbol, flags) { isModule := symbol.ValueDeclaration != nil && (ast.IsSourceFile(symbol.ValueDeclaration) || ast.IsAmbientModule(symbol.ValueDeclaration)) - b.WriteString(core.IfElse(isModule, "module ", "namespace ")) - b.WriteString(c.SymbolToStringEx(symbol, container, ast.SymbolFlagsNone, symbolFormatFlags)) + dpw.WriteKeyword(core.IfElse(isModule, "module ", "namespace ")) + writeSymbolClassified(symbol, container, ast.SymbolFlagsNone, symbolFormatFlags) } setDeclaration(core.Find(symbol.Declarations, ast.IsModuleDeclaration)) } if flags&ast.SymbolFlagsTypeParameter != 0 { writeNewLine() - b.WriteString("(type parameter) ") + dpw.WritePunctuation("(") + dpw.Write("type parameter") + dpw.WritePunctuation(") ") tp := c.GetDeclaredTypeOfSymbol(symbol) - b.WriteString(c.SymbolToStringEx(symbol, container, ast.SymbolFlagsNone, symbolFormatFlags)) + writeSymbolClassified(symbol, container, ast.SymbolFlagsNone, symbolFormatFlags) cons := c.GetConstraintOfTypeParameter(tp) if cons != nil { - b.WriteString(" extends ") - b.WriteString(typeToString(cons, container, typeFormatFlags)) + dpw.WriteKeyword(" extends ") + writeTypeClassified(cons, container, typeFormatFlags) } // Show context: "in ClassName" or "in funcName(...)" if symbol.Parent != nil { // Class/Interface type parameter - b.WriteString(" in ") - b.WriteString(c.SymbolToStringEx(symbol.Parent, container, ast.SymbolFlagsNone, symbolFormatFlags)) + dpw.WriteKeyword(" in ") + writeSymbolClassified(symbol.Parent, container, ast.SymbolFlagsNone, symbolFormatFlags) if parentType := c.GetDeclaredTypeOfSymbol(symbol.Parent); parentType.AsInterfaceType() != nil { parentParams := parentType.AsInterfaceType().LocalTypeParameters() writeTypeParams(parentParams) @@ -656,19 +766,20 @@ func getQuickInfoAndDeclarationAtLocation(c *checker.Checker, symbol *ast.Symbol if decl != nil && decl.Parent != nil { declaration := decl.Parent if ast.IsFunctionLike(declaration) { - b.WriteString(" in ") + dpw.WriteKeyword(" in ") if declaration.Kind == ast.KindConstructSignature { - b.WriteString("new ") + dpw.WriteKeyword("new ") } else if declaration.Kind != ast.KindCallSignature && declaration.Name() != nil { - b.WriteString(c.SymbolToStringEx(declaration.Symbol(), container, ast.SymbolFlagsNone, symbolFormatFlags)) + writeSymbolClassified(declaration.Symbol(), container, ast.SymbolFlagsNone, symbolFormatFlags) } sig := c.GetSignatureFromDeclaration(declaration) if sig != nil { - b.WriteString(c.SignatureToStringEx(sig, container, typeFormatFlags|checker.TypeFormatFlagsWriteTypeArgumentsOfSignature, nil)) + writeSignatureClassified(sig, container, typeFormatFlags|checker.TypeFormatFlagsWriteTypeArgumentsOfSignature) } } else if ast.IsTypeAliasDeclaration(declaration) { - b.WriteString(" in type ") - b.WriteString(c.SymbolToStringEx(declaration.Symbol(), container, ast.SymbolFlagsNone, symbolFormatFlags)) + dpw.WriteKeyword(" in ") + dpw.WriteKeyword("type ") + writeSymbolClassified(declaration.Symbol(), container, ast.SymbolFlagsNone, symbolFormatFlags) if declSymbol := declaration.Symbol(); declSymbol != nil { taParams := c.GetTypeAliasTypeParameters(declSymbol) writeTypeParams(taParams) @@ -680,27 +791,27 @@ func getQuickInfoAndDeclarationAtLocation(c *checker.Checker, symbol *ast.Symbol } if flags&ast.SymbolFlagsTypeAlias != 0 { writeNewLine() - b.WriteString("type ") - b.WriteString(c.SymbolToStringEx(symbol, container, ast.SymbolFlagsNone, symbolFormatFlags)) + dpw.WriteKeyword("type ") + writeSymbolClassified(symbol, container, ast.SymbolFlagsNone, symbolFormatFlags) writeTypeParams(c.GetTypeAliasTypeParameters(symbol)) - b.WriteString(" = ") + dpw.WriteOperator(" = ") var typeAliasType *checker.Type if node.Parent != nil && ast.IsConstTypeReference(node.Parent) { typeAliasType = c.GetTypeAtLocation(node.Parent) } else { typeAliasType = c.GetDeclaredTypeOfSymbol(symbol) } - b.WriteString(typeToString(typeAliasType, container, typeFormatFlags|checker.TypeFormatFlagsInTypeAlias)) + writeTypeClassified(typeAliasType, container, typeFormatFlags|checker.TypeFormatFlagsInTypeAlias) setDeclaration(core.Find(symbol.Declarations, ast.IsTypeOrJSTypeAliasDeclaration)) } if flags&ast.SymbolFlagsSignature != 0 { writeNewLine() - b.WriteString(typeToString(c.GetTypeOfSymbol(symbol), container, typeFormatFlags)) + writeTypeClassified(c.GetTypeOfSymbol(symbol), container, typeFormatFlags) } } writeSymbol(symbol) - return b.String(), firstDeclaration + return symbolDisplayInfo{displayParts: dpw, declaration: firstDeclaration} } // typeParameterToString renders a type parameter declaration (e.g., "T extends FooType"). diff --git a/pkg/ls/signaturehelp.go b/pkg/ls/signaturehelp.go index 218e8c5ba..fad28daf2 100644 --- a/pkg/ls/signaturehelp.go +++ b/pkg/ls/signaturehelp.go @@ -364,7 +364,8 @@ func (l *LanguageService) createSignatureHelpItems(ctx context.Context, candidat // Set VS-specific colorized label if we have classified runs if len(item.ColorizedRuns) > 0 { sigInfo.VSColorizedLabel = &lsproto.ClassifiedTextElement{ - Runs: item.ColorizedRuns, + Runs: item.ColorizedRuns, + VSType: "ClassifiedTextElement", } } @@ -465,8 +466,7 @@ func returnTypeToDisplayParts(candidateSignature *checker.Signature, c *checker. dpw := newDisplayPartsWriter(vsCapability) // Add ": " prefix - dpw.WritePunctuation(":") - dpw.WriteSpace(" ") + dpw.WritePunctuation(": ") predicate := c.GetTypePredicateOfSignature(candidateSignature) if predicate != nil { @@ -514,8 +514,7 @@ func (l *LanguageService) itemInfoForTypeParameters(candidateSignature *checker. dpw.WritePunctuation(lessThanToken) for i, typeParameter := range signatureHelpTypeParameters { if i > 0 { - dpw.WritePunctuation(",") - dpw.WriteSpace(" ") + dpw.WritePunctuation(", ") } label := *typeParameter.parameterInfo.Label.String dpw.WriteClassified(label, lsproto.ClassificationTypeNameTypeParameterName) @@ -540,8 +539,7 @@ func (l *LanguageService) itemInfoForTypeParameters(candidateSignature *checker. paramNode := checker.NewNodeBuilder(c, emitContext).SymbolToParameterDeclaration(param, enclosingDeclaration, signatureHelpNodeBuilderFlags, nodebuilder.InternalFlagsNone, nil) if j > 0 { - paramDpw.WritePunctuation(",") - paramDpw.WriteSpace(" ") + paramDpw.WritePunctuation(", ") } // Use a temporary writer for p.Write since the printer calls Clear() on its writer tempDpw := newDisplayPartsWriter(vsCapability) @@ -583,8 +581,7 @@ func (l *LanguageService) itemInfoForParameters(candidateSignature *checker.Sign dpw.WritePunctuation(lessThanToken) for i, typeParameter := range signatureHelpTypeParameters { if i > 0 { - dpw.WritePunctuation(",") - dpw.WriteSpace(" ") + dpw.WritePunctuation(", ") } label := *typeParameter.parameterInfo.Label.String dpw.WriteClassified(label, lsproto.ClassificationTypeNameTypeParameterName) @@ -620,8 +617,7 @@ func (l *LanguageService) itemInfoForParameters(candidateSignature *checker.Sign paramNode := checker.NewNodeBuilder(c, emitContext).SymbolToParameterDeclaration(param, enclosingDeclaratipn, signatureHelpNodeBuilderFlags, nodebuilder.InternalFlagsNone, nil) if j > 0 { - paramDpw.WritePunctuation(",") - paramDpw.WriteSpace(" ") + paramDpw.WritePunctuation(", ") } // Use a temporary writer for p.Write since the printer calls Clear() on its writer tempDpw := newDisplayPartsWriter(vsCapability) diff --git a/pkg/lsp/lsproto/_generate/fetchModel.mts b/pkg/lsp/lsproto/_generate/fetchModel.mts index 163c339c5..bb800abef 100755 --- a/pkg/lsp/lsproto/_generate/fetchModel.mts +++ b/pkg/lsp/lsproto/_generate/fetchModel.mts @@ -36,4 +36,10 @@ metaModelSchema = metaModelSchema.replace( `$1\n\n\t/**\n\t * Whether this property uses omitzero without being a pointer.\n\t * Custom extension for special value types.\n\t */\n\tomitzeroValue?: boolean;\n}`, ); +// Patch the schema to add vsTypeDiscriminator property to Structure type +metaModelSchema = metaModelSchema.replace( + /(export type Structure = \{[\s\S]*?\tdeprecated\?: string;)\n}/m, + `$1\n\n\t/**\n\t * If set, adds a _vs_type field with this value as a type discriminator\n\t * for VS client-side deserialization.\n\t */\n\tvsTypeDiscriminator?: string;\n}`, +); + fs.writeFileSync(metaModelSchemaPath, metaModelSchema); diff --git a/pkg/lsp/lsproto/_generate/generate.mts b/pkg/lsp/lsproto/_generate/generate.mts index 33b6c7bf3..9c78a4900 100755 --- a/pkg/lsp/lsproto/_generate/generate.mts +++ b/pkg/lsp/lsproto/_generate/generate.mts @@ -177,6 +177,52 @@ const customStructures: Structure[] = [ ], documentation: "Options for the textDocument/_vs_onAutoInsert provider capability.", }, + { + name: "VsReferenceItem", + properties: [ + { + name: "_vs_id", + type: { kind: "base", name: "integer" }, + documentation: "Unique identifier for this reference item.", + }, + { + name: "_vs_definitionId", + type: { kind: "base", name: "integer" }, + optional: true, + documentation: "The ID of the definition item this reference belongs to. Absent for definition items themselves.", + }, + { + name: "_vs_kind", + type: { kind: "array", element: { kind: "reference", name: "VsReferenceKind" } }, + optional: true, + documentation: "The kind(s) of this reference (read, write, etc.).", + }, + { + name: "_vs_location", + type: { kind: "reference", name: "Location" }, + documentation: "The location of this reference.", + }, + { + name: "_vs_definitionText", + type: { kind: "reference", name: "ClassifiedTextElement" }, + optional: true, + documentation: "Classified display text for the definition (used for grouping headers in the UI).", + }, + { + name: "_vs_projectName", + type: { kind: "base", name: "string" }, + optional: true, + documentation: "The project name for this reference.", + }, + { + name: "_vs_containingType", + type: { kind: "base", name: "string" }, + optional: true, + documentation: "The containing type for this reference.", + }, + ], + documentation: "A VS-specific reference item with grouping support for Find All References.", + }, { name: "VsOnAutoInsertParams", properties: [ @@ -486,11 +532,13 @@ const customStructures: Structure[] = [ { name: "Style", type: { kind: "base", name: "integer" }, + optional: true, 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.", + vsTypeDiscriminator: "ClassifiedTextRun", }, { name: "ClassifiedTextElement", @@ -502,10 +550,35 @@ const customStructures: Structure[] = [ }, ], documentation: "A classified text element containing an array of classified text runs, used for colorized labels in VS.", + vsTypeDiscriminator: "ClassifiedTextElement", }, ]; const customEnumerations: Enumeration[] = [ + { + name: "VsReferenceKind", + type: { kind: "base", name: "integer" }, + values: [ + { name: "Inactive", value: 0 }, + { name: "Comment", value: 1 }, + { name: "String", value: 2 }, + { name: "Read", value: 3 }, + { name: "Write", value: 4 }, + { name: "Reference", value: 5 }, + { name: "Name", value: 6 }, + { name: "Qualified", value: 7 }, + { name: "TypeArgument", value: 8 }, + { name: "TypeConstraint", value: 9 }, + { name: "BaseType", value: 10 }, + { name: "Constructor", value: 11 }, + { name: "Destructor", value: 12 }, + { name: "Import", value: 13 }, + { name: "Declaration", value: 14 }, + { name: "AddressOf", value: 15 }, + { name: "NotReference", value: 16 }, + { name: "Unknown", value: 17 }, + ], + }, { name: "CodeLensKind", type: { @@ -671,6 +744,20 @@ const customRequests: Request[] = [ messageDirection: "clientToServer", documentation: "Request for auto-insert when a trigger character is typed (VS-specific).", }, + { + method: "textDocument/_vs_references", + typeName: "VsReferencesRequest", + params: { kind: "reference", name: "ReferenceParams" }, + result: { + kind: "or", + items: [ + { kind: "array", element: { kind: "reference", name: "VsReferenceItem" } }, + { kind: "base", name: "null" }, + ], + }, + messageDirection: "clientToServer", + documentation: "VS-specific request for Find All References with grouped reference items.", + }, ]; // compareStructures is the set of generated structures for which a Compare method should be emitted. @@ -781,6 +868,12 @@ function patchAndPreprocessModel() { optional: true, documentation: "Provider options for the VS auto-insert feature via textDocument/_vs_onAutoInsert.", }); + structure.properties.push({ + name: "_vs_referencesProvider", + type: { kind: "base", name: "boolean" }, + optional: true, + documentation: "The server provides VS-specific grouped references via textDocument/_vs_references.", + }); } // Patch HoverParams to add verbosityLevel @@ -2131,6 +2224,13 @@ function generateCode() { } } + // Special: add _vs_type discriminator field for VS ObjectContentConverter + if ((structure as any).vsTypeDiscriminator) { + writeLine(""); + writeLine(`\t// VS type discriminator required by ObjectContentConverter for deserialization.`); + writeLine(`\tVSType string \`json:"_vs_type"\``); + } + // Special: add RegisterOptions field to Registration if (structure.name === "Registration") { writeLine(""); diff --git a/pkg/lsp/lsproto/_generate/metaModelSchema.mts b/pkg/lsp/lsproto/_generate/metaModelSchema.mts index 30b2efc27..60ac3e061 100644 --- a/pkg/lsp/lsproto/_generate/metaModelSchema.mts +++ b/pkg/lsp/lsproto/_generate/metaModelSchema.mts @@ -403,6 +403,12 @@ export type Structure = { * the property contains the deprecation message. */ deprecated?: string; + + /** + * If set, adds a _vs_type field with this value as a type discriminator + * for VS client-side deserialization. + */ + vsTypeDiscriminator?: string; }; /** diff --git a/pkg/lsp/lsproto/lsp_generated.go b/pkg/lsp/lsproto/lsp_generated.go index 38a2efe89..def40b236 100644 --- a/pkg/lsp/lsproto/lsp_generated.go +++ b/pkg/lsp/lsproto/lsp_generated.go @@ -17186,6 +17186,9 @@ type ServerCapabilities struct { // Provider options for the VS auto-insert feature via textDocument/_vs_onAutoInsert. VSOnAutoInsertProvider *VsOnAutoInsertOptions `json:"_vs_onAutoInsertProvider,omitzero"` + // The server provides VS-specific grouped references via textDocument/_vs_references. + VSReferencesProvider *bool `json:"_vs_referencesProvider,omitzero"` + // The server provides multi-document highlight support via custom/textDocument/multiDocumentHighlight. CustomMultiDocumentHighlightProvider *bool `json:"customMultiDocumentHighlightProvider,omitzero"` } @@ -17458,6 +17461,13 @@ func (s *ServerCapabilities) UnmarshalJSONFrom(dec *json.Decoder) error { if err := json.UnmarshalDecode(dec, &s.VSOnAutoInsertProvider); err != nil { return err } + case `"_vs_referencesProvider"`: + if dec.PeekKind() == 'n' { + return errNull("_vs_referencesProvider") + } + if err := json.UnmarshalDecode(dec, &s.VSReferencesProvider); err != nil { + return err + } case `"customMultiDocumentHighlightProvider"`: if dec.PeekKind() == 'n' { return errNull("customMultiDocumentHighlightProvider") @@ -28476,6 +28486,123 @@ func (s *VsOnAutoInsertOptions) UnmarshalJSONFrom(dec *json.Decoder) error { return nil } +// A VS-specific reference item with grouping support for Find All References. +type VsReferenceItem struct { + // Unique identifier for this reference item. + VSId int32 `json:"_vs_id"` + + // The ID of the definition item this reference belongs to. Absent for definition items themselves. + VSDefinitionId *int32 `json:"_vs_definitionId,omitzero"` + + // The kind(s) of this reference (read, write, etc.). + VSKind *[]VsReferenceKind `json:"_vs_kind,omitzero"` + + // The location of this reference. + VSLocation Location `json:"_vs_location"` + + // Classified display text for the definition (used for grouping headers in the UI). + VSDefinitionText *ClassifiedTextElement `json:"_vs_definitionText,omitzero"` + + // The project name for this reference. + VSProjectName *string `json:"_vs_projectName,omitzero"` + + // The containing type for this reference. + VSContainingType *string `json:"_vs_containingType,omitzero"` +} + +var _ json.UnmarshalerFrom = (*VsReferenceItem)(nil) + +func (s *VsReferenceItem) UnmarshalJSONFrom(dec *json.Decoder) error { + const ( + missingVSId uint = 1 << iota + missingVSLocation + _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 `"_vs_id"`: + missing &^= missingVSId + if err := json.UnmarshalDecode(dec, &s.VSId); err != nil { + return err + } + case `"_vs_definitionId"`: + if dec.PeekKind() == 'n' { + return errNull("_vs_definitionId") + } + if err := json.UnmarshalDecode(dec, &s.VSDefinitionId); err != nil { + return err + } + case `"_vs_kind"`: + if dec.PeekKind() == 'n' { + return errNull("_vs_kind") + } + if err := json.UnmarshalDecode(dec, &s.VSKind); err != nil { + return err + } + case `"_vs_location"`: + missing &^= missingVSLocation + if err := json.UnmarshalDecode(dec, &s.VSLocation); err != nil { + return err + } + case `"_vs_definitionText"`: + if dec.PeekKind() == 'n' { + return errNull("_vs_definitionText") + } + if err := json.UnmarshalDecode(dec, &s.VSDefinitionText); err != nil { + return err + } + case `"_vs_projectName"`: + if dec.PeekKind() == 'n' { + return errNull("_vs_projectName") + } + if err := json.UnmarshalDecode(dec, &s.VSProjectName); err != nil { + return err + } + case `"_vs_containingType"`: + if dec.PeekKind() == 'n' { + return errNull("_vs_containingType") + } + if err := json.UnmarshalDecode(dec, &s.VSContainingType); 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&missingVSId != 0 { + missingProps = append(missingProps, "_vs_id") + } + if missing&missingVSLocation != 0 { + missingProps = append(missingProps, "_vs_location") + } + return errMissing(missingProps) + } + + return nil +} + // Parameters for the textDocument/_vs_onAutoInsert request. type VsOnAutoInsertParams struct { // The text document. @@ -29596,6 +29723,9 @@ type ClassifiedTextRun struct { // The style of this text run. Style int32 `json:"Style,omitzero"` + + // VS type discriminator required by ObjectContentConverter for deserialization. + VSType string `json:"_vs_type"` } var _ json.UnmarshalerFrom = (*ClassifiedTextRun)(nil) @@ -29671,6 +29801,9 @@ func (s *ClassifiedTextRun) UnmarshalJSONFrom(dec *json.Decoder) error { type ClassifiedTextElement struct { // The classified text runs that make up this element. Runs []*ClassifiedTextRun `json:"Runs"` + + // VS type discriminator required by ObjectContentConverter for deserialization. + VSType string `json:"_vs_type"` } var _ json.UnmarshalerFrom = (*ClassifiedTextElement)(nil) @@ -30864,6 +30997,41 @@ const ( TokenFormatRelative TokenFormat = "relative" ) +type VsReferenceKind int32 + +const ( + VsReferenceKindInactive VsReferenceKind = 0 + VsReferenceKindComment VsReferenceKind = 1 + VsReferenceKindString VsReferenceKind = 2 + VsReferenceKindRead VsReferenceKind = 3 + VsReferenceKindWrite VsReferenceKind = 4 + VsReferenceKindReference VsReferenceKind = 5 + VsReferenceKindName VsReferenceKind = 6 + VsReferenceKindQualified VsReferenceKind = 7 + VsReferenceKindTypeArgument VsReferenceKind = 8 + VsReferenceKindTypeConstraint VsReferenceKind = 9 + VsReferenceKindBaseType VsReferenceKind = 10 + VsReferenceKindConstructor VsReferenceKind = 11 + VsReferenceKindDestructor VsReferenceKind = 12 + VsReferenceKindImport VsReferenceKind = 13 + VsReferenceKindDeclaration VsReferenceKind = 14 + VsReferenceKindAddressOf VsReferenceKind = 15 + VsReferenceKindNotReference VsReferenceKind = 16 + VsReferenceKindUnknown VsReferenceKind = 17 +) + +const _VsReferenceKind_name = "InactiveCommentStringReadWriteReferenceNameQualifiedTypeArgumentTypeConstraintBaseTypeConstructorDestructorImportDeclarationAddressOfNotReferenceUnknown" + +var _VsReferenceKind_index = [...]uint16{0, 8, 15, 21, 25, 30, 39, 43, 52, 64, 78, 86, 97, 107, 113, 124, 133, 145, 152} + +func (e VsReferenceKind) String() string { + i := int(e) - 0 + if i < 0 || i >= len(_VsReferenceKind_index)-1 { + return fmt.Sprintf("VsReferenceKind(%d)", e) + } + return _VsReferenceKind_name[_VsReferenceKind_index[i]:_VsReferenceKind_index[i+1]] +} + type CodeLensKind string const ( @@ -31157,6 +31325,8 @@ func unmarshalParams(method Method, data []byte) (any, error) { return unmarshalPtrTo[MultiDocumentHighlightParams](data) case MethodTextDocumentVSOnAutoInsert: return unmarshalPtrTo[VsOnAutoInsertParams](data) + case MethodTextDocumentVSReferences: + return unmarshalPtrTo[ReferenceParams](data) case MethodWorkspaceDidChangeWorkspaceFolders: return unmarshalPtrTo[DidChangeWorkspaceFoldersParams](data) case MethodWindowWorkDoneProgressCancel: @@ -31366,6 +31536,8 @@ func unmarshalResult(method Method, data []byte) (any, error) { return unmarshalValue[CustomMultiDocumentHighlightResponse](data) case MethodTextDocumentVSOnAutoInsert: return unmarshalValue[VsOnAutoInsertResponse](data) + case MethodTextDocumentVSReferences: + return unmarshalValue[VsReferencesResponse](data) default: return unmarshalAny(data) } @@ -31690,6 +31862,8 @@ const ( MethodCustomTextDocumentMultiDocumentHighlight Method = "custom/textDocument/multiDocumentHighlight" // Request for auto-insert when a trigger character is typed (VS-specific). MethodTextDocumentVSOnAutoInsert Method = "textDocument/_vs_onAutoInsert" + // VS-specific request for Find All References with grouped reference items. + MethodTextDocumentVSReferences Method = "textDocument/_vs_references" // The `workspace/didChangeWorkspaceFolders` notification is sent from the client to the server when the workspace // folder configuration changes. MethodWorkspaceDidChangeWorkspaceFolders Method = "workspace/didChangeWorkspaceFolders" @@ -32247,6 +32421,12 @@ type VsOnAutoInsertResponse = VsOnAutoInsertResponseItemOrNull // Type mapping info for `textDocument/_vs_onAutoInsert` var TextDocumentVSOnAutoInsertInfo = RequestInfo[*VsOnAutoInsertParams, VsOnAutoInsertResponse]{Method: MethodTextDocumentVSOnAutoInsert} +// Response type for `textDocument/_vs_references` +type VsReferencesResponse = VsReferenceItemsOrNull + +// Type mapping info for `textDocument/_vs_references` +var TextDocumentVSReferencesInfo = RequestInfo[*ReferenceParams, VsReferencesResponse]{Method: MethodTextDocumentVSReferences} + // Type mapping info for `workspace/didChangeWorkspaceFolders` var WorkspaceDidChangeWorkspaceFoldersInfo = NotificationInfo[*DidChangeWorkspaceFoldersParams]{Method: MethodWorkspaceDidChangeWorkspaceFolders} @@ -35788,6 +35968,36 @@ func (o *VsOnAutoInsertResponseItemOrNull) UnmarshalJSONFrom(dec *json.Decoder) } } +type VsReferenceItemsOrNull struct { + VsReferenceItems *[]*VsReferenceItem +} + +var _ json.MarshalerTo = (*VsReferenceItemsOrNull)(nil) + +func (o *VsReferenceItemsOrNull) MarshalJSONTo(enc *json.Encoder) error { + if o.VsReferenceItems != nil { + return json.MarshalEncode(enc, o.VsReferenceItems) + } + return enc.WriteToken(json.Null) +} + +var _ json.UnmarshalerFrom = (*VsReferenceItemsOrNull)(nil) + +func (o *VsReferenceItemsOrNull) UnmarshalJSONFrom(dec *json.Decoder) error { + *o = VsReferenceItemsOrNull{} + + switch dec.PeekKind() { + case 'n': + _, err := dec.ReadToken() + return err + case '[': + o.VsReferenceItems = new([]*VsReferenceItem) + return json.UnmarshalDecode(dec, o.VsReferenceItems) + default: + return errInvalidKind("VsReferenceItemsOrNull", dec.PeekKind()) + } +} + type RequestFailureTelemetryEventOrPerformanceStatsTelemetryEventOrProjectInfoTelemetryEventOrNull struct { RequestFailureTelemetryEvent *RequestFailureTelemetryEvent PerformanceStatsTelemetryEvent *PerformanceStatsTelemetryEvent diff --git a/pkg/lsp/server.go b/pkg/lsp/server.go index 6bd0d0a50..052cf2b0b 100644 --- a/pkg/lsp/server.go +++ b/pkg/lsp/server.go @@ -748,6 +748,7 @@ var handlers = sync.OnceValue(func() handlerMap { registerLanguageServiceDocumentRequestHandler(handlers, lsproto.TextDocumentVSOnAutoInsertInfo, (*Server).handleVsOnAutoInsert) registerMultiProjectReferenceRequestHandler(handlers, lsproto.TextDocumentReferencesInfo, (*ls.LanguageService).ProvideReferences) + registerMultiProjectReferenceRequestHandler(handlers, lsproto.TextDocumentVSReferencesInfo, (*ls.LanguageService).ProvideVsReferences) registerRequestHandler(handlers, lsproto.TextDocumentRenameInfo, (*Server).handleRename) registerMultiProjectReferenceRequestHandler(handlers, lsproto.TextDocumentImplementationInfo, (*ls.LanguageService).ProvideImplementations) @@ -1116,6 +1117,7 @@ func (s *Server) handleInitialize(ctx context.Context, params *lsproto.Initializ }, CustomSourceDefinitionProvider: new(true), CustomMultiDocumentHighlightProvider: new(true), + VSReferencesProvider: new(true), VSOnAutoInsertProvider: &lsproto.VsOnAutoInsertOptions{ VSTriggerCharacters: []string{">"}, }, diff --git a/pkg/printer/printer.go b/pkg/printer/printer.go index 83d9d7e21..2a14bbdf5 100644 --- a/pkg/printer/printer.go +++ b/pkg/printer/printer.go @@ -139,6 +139,7 @@ type Printer struct { makeFileLevelOptimisticUniqueName func(string) string commentStateArena core.Arena[commentState] sourceMapStateArena core.Arena[sourceMapState] + IdToSymbol map[*ast.IdentifierNode]*ast.Symbol } type detachedCommentsInfo struct { @@ -1092,13 +1093,13 @@ func (p *Printer) emitIdentifierText(node *ast.Identifier) { debug.Assert(f == nil || p.currentSourceFile == nil || f.FileName() == p.currentSourceFile.FileName()) text := p.getTextOfNode(node.AsNode(), false /*includeTrivia*/) - // !!! In the old emitter, an Identifier could have a Symbol associated with it. That - // doesn't seem to be the case in the new emitter. Do we need to get the symbol from somewhere else? - ////p.writeSymbol(text, node.Symbol()) + if p.IdToSymbol != nil { + if symbol, ok := p.IdToSymbol[node.AsNode()]; ok { + p.writeSymbol(text, symbol) + return + } + } p.write(text) - - // !!! In the old emitter, an Identifier could have type arguments for use with quickinfo: - ////p.emitList(node, getIdentifierTypeArguments(node), LFTypeParameters); // Call emitList directly since it could be an array of TypeParameterDeclarations _or_ type arguments } func (p *Printer) emitIdentifierName(node *ast.Identifier) { diff --git a/testdata/baselines/reference/compiler/cjsExportGenericTypes.symbols b/testdata/baselines/reference/compiler/cjsExportGenericTypes.symbols new file mode 100644 index 000000000..2e9ca751b --- /dev/null +++ b/testdata/baselines/reference/compiler/cjsExportGenericTypes.symbols @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/cjsExportGenericTypes.ts] //// + +=== index.js === +const Set = require("./set"); +>Set : Symbol(Set, Decl(index.js, 0, 5)) +>require : Symbol(require) +>"./set" : Symbol("./set", Decl(set.js, 0, 0)) + +/** @typedef {Set} MyDefinedType */ + +=== set.js === +/** + * @template D + * @typedef {(a: D, b: D) => number} SomeUnrelatedGeneric + */ + +/** + * @template T + */ +class SomeGenericClass { +>SomeGenericClass : Symbol(SomeGenericClass, Decl(set.js, 0, 0)) + + /** + * @param {Set} param + */ + constructor(param) {} +>param : Symbol(param, Decl(set.js, 12, 14)) +} + +module.exports = SomeGenericClass; +>module.exports : Symbol(exports, Decl(set.js, 0, 0)) +>module : Symbol(module, Decl(set.js, 0, 0)) +>exports : Symbol(exports, Decl(set.js, 0, 0)) +>SomeGenericClass : Symbol(SomeGenericClass, Decl(set.js, 0, 0)) + diff --git a/testdata/baselines/reference/compiler/cjsExportGenericTypes.types b/testdata/baselines/reference/compiler/cjsExportGenericTypes.types new file mode 100644 index 000000000..951a603c8 --- /dev/null +++ b/testdata/baselines/reference/compiler/cjsExportGenericTypes.types @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/cjsExportGenericTypes.ts] //// + +=== index.js === +const Set = require("./set"); +>Set : typeof SomeGenericClass +>require("./set") : typeof SomeGenericClass +>require : any +>"./set" : "./set" + +/** @typedef {Set} MyDefinedType */ + +=== set.js === +/** + * @template D + * @typedef {(a: D, b: D) => number} SomeUnrelatedGeneric + */ + +/** + * @template T + */ +class SomeGenericClass { +>SomeGenericClass : SomeGenericClass + + /** + * @param {Set} param + */ + constructor(param) {} +>param : Set +} + +module.exports = SomeGenericClass; +>module.exports = SomeGenericClass : typeof SomeGenericClass +>module.exports : typeof SomeGenericClass +>module : { exports: typeof SomeGenericClass; } +>exports : typeof SomeGenericClass +>SomeGenericClass : typeof SomeGenericClass + diff --git a/testdata/baselines/reference/fourslash/signatureHelp/jsDocDontBreakWithNamespacesVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/jsDocDontBreakWithNamespacesVS.baseline index de0cb0081..fe58a417d 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/jsDocDontBreakWithNamespacesVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/jsDocDontBreakWithNamespacesVS.baseline @@ -47,29 +47,31 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "foo" + "Text": "foo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "module" + "Text": "module", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -95,29 +97,31 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "bar" + "Text": "bar", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -143,29 +147,31 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "zee" + "Text": "zee", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures5VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures5VS.baseline index b45595499..7b80de054 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures5VS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures5VS.baseline @@ -73,125 +73,136 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "pathFilter" + "Text": "pathFilter", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "basePath" + "Text": "basePath", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "pattern" + "Text": "pattern", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "type" + "Text": "type", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "options" + "Text": "options", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "Object" + "Text": "Object", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures6VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures6VS.baseline index 8c0ca6efa..3bc216f1c 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures6VS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/jsDocFunctionSignatures6VS.baseline @@ -82,141 +82,156 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f1" + "Text": "f1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "p1" + "Text": "p1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "p2" + "Text": "p2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "|" + "Text": "|", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "null" + "Text": "null", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "p3" + "Text": "p3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "p4" + "Text": "p4", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -272,141 +287,156 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f1" + "Text": "f1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "p1" + "Text": "p1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "p2" + "Text": "p2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "|" + "Text": "|", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "null" + "Text": "null", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "p3" + "Text": "p3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "p4" + "Text": "p4", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -462,141 +492,156 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f1" + "Text": "f1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "p1" + "Text": "p1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "p2" + "Text": "p2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "|" + "Text": "|", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "null" + "Text": "null", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "p3" + "Text": "p3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "p4" + "Text": "p4", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -652,141 +697,156 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f1" + "Text": "f1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "p1" + "Text": "p1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "p2" + "Text": "p2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "|" + "Text": "|", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "null" + "Text": "null", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "p3" + "Text": "p3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "p4" + "Text": "p4", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/jsdocReturnsTagVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/jsdocReturnsTagVS.baseline index 4ad15c9ac..3eb5e4b1a 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/jsdocReturnsTagVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/jsdocReturnsTagVS.baseline @@ -47,77 +47,86 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "find" + "Text": "find", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "l" + "Text": "l", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "x" + "Text": "x", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTags13VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTags13VS.baseline index 2a8737abc..e84f3ed94 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTags13VS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTags13VS.baseline @@ -55,45 +55,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f" + "Text": "f", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -108,45 +114,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f" + "Text": "f", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -177,45 +189,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f" + "Text": "f", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -230,45 +248,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f" + "Text": "f", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTextFormatting1VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTextFormatting1VS.baseline index f750e66c7..80d0db3d2 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTextFormatting1VS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/quickInfoJsDocTextFormatting1VS.baseline @@ -107,69 +107,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f1" + "Text": "f1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "var1" + "Text": "var1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "var2" + "Text": "var2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -211,69 +218,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f2" + "Text": "f2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "var1" + "Text": "var1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "var2" + "Text": "var2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -315,69 +329,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f3" + "Text": "f3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "var1" + "Text": "var1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "var2" + "Text": "var2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -419,69 +440,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f4" + "Text": "f4", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "var1" + "Text": "var1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "var2" + "Text": "var2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -523,69 +551,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f5" + "Text": "f5", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "var1" + "Text": "var1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "var2" + "Text": "var2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAfterParameterVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAfterParameterVS.baseline index 02ebb0d85..2473a73c3 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAfterParameterVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAfterParameterVS.baseline @@ -83,93 +83,101 @@ "Runs": [ { "ClassificationTypeName": "identifier", - "Text": "Type" + "Text": "Type", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -206,93 +214,101 @@ "Runs": [ { "ClassificationTypeName": "identifier", - "Text": "Type" + "Text": "Type", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -329,93 +345,101 @@ "Runs": [ { "ClassificationTypeName": "identifier", - "Text": "Type" + "Text": "Type", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -452,93 +476,101 @@ "Runs": [ { "ClassificationTypeName": "identifier", - "Text": "Type" + "Text": "Type", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -575,93 +607,101 @@ "Runs": [ { "ClassificationTypeName": "identifier", - "Text": "Type" + "Text": "Type", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -698,93 +738,101 @@ "Runs": [ { "ClassificationTypeName": "identifier", - "Text": "Type" + "Text": "Type", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -821,93 +869,101 @@ "Runs": [ { "ClassificationTypeName": "identifier", - "Text": "Type" + "Text": "Type", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -944,93 +1000,101 @@ "Runs": [ { "ClassificationTypeName": "identifier", - "Text": "Type" + "Text": "Type", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1067,93 +1131,101 @@ "Runs": [ { "ClassificationTypeName": "identifier", - "Text": "Type" + "Text": "Type", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1190,93 +1262,101 @@ "Runs": [ { "ClassificationTypeName": "identifier", - "Text": "Type" + "Text": "Type", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1313,93 +1393,101 @@ "Runs": [ { "ClassificationTypeName": "identifier", - "Text": "Type" + "Text": "Type", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1436,93 +1524,101 @@ "Runs": [ { "ClassificationTypeName": "identifier", - "Text": "Type" + "Text": "Type", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAnonymousTypeVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAnonymousTypeVS.baseline index c53949589..fbd3d7844 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAnonymousTypeVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpAnonymousTypeVS.baseline @@ -35,69 +35,76 @@ "Runs": [ { "ClassificationTypeName": "text", - "Text": "�type" + "Text": "�type", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "boolean" + "Text": "boolean", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpBindingPatternVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpBindingPatternVS.baseline index 328538322..b8b61507c 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpBindingPatternVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpBindingPatternVS.baseline @@ -139,53 +139,61 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "emptyObj" + "Text": "emptyObj", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -220,85 +228,101 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "emptyArr" + "Text": "emptyArr", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "Iterable" + "Text": "Iterable", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "undefined" + "Text": "undefined", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -333,129 +357,156 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "nonEmptyObj" + "Text": "nonEmptyObj", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -490,85 +541,101 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "nonEmptyArr" + "Text": "nonEmptyArr", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "x" + "Text": "x", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "y" + "Text": "y", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -610,153 +677,181 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "idLeading" + "Text": "idLeading", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "first" + "Text": "first", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -798,153 +893,181 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "idLeading" + "Text": "idLeading", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "first" + "Text": "first", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -986,153 +1109,181 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "bindingLeading" + "Text": "bindingLeading", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "last" + "Text": "last", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1174,153 +1325,181 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "bindingLeading" + "Text": "bindingLeading", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "last" + "Text": "last", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1362,237 +1541,286 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "multipleBindings" + "Text": "multipleBindings", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1634,237 +1862,286 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "multipleBindings" + "Text": "multipleBindings", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "{" + "Text": "{", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "property name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ";" + "Text": ";", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "}" + "Text": "}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassMembersVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassMembersVS.baseline index 06551f397..84e8846d8 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassMembersVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassMembersVS.baseline @@ -249,45 +249,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "p2" + "Text": "p2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -326,45 +332,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "p2" + "Text": "p2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -403,45 +415,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "pp2" + "Text": "pp2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -480,45 +498,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "pp2" + "Text": "pp2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -557,45 +581,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "s2" + "Text": "s2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -634,45 +664,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "s2" + "Text": "s2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -703,45 +739,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "nc_p2" + "Text": "nc_p2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -772,45 +814,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "nc_p2" + "Text": "nc_p2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -841,45 +889,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "nc_pp2" + "Text": "nc_pp2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -910,45 +964,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "nc_pp2" + "Text": "nc_pp2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -979,45 +1039,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "nc_s2" + "Text": "nc_s2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1048,45 +1114,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "nc_s2" + "Text": "nc_s2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1116,29 +1188,31 @@ "Runs": [ { "ClassificationTypeName": "class name", - "Text": "c1" + "Text": "c1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "c1" + "Text": "c1", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1177,45 +1251,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "p2" + "Text": "p2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1246,45 +1326,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "nc_p2" + "Text": "nc_p2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1323,45 +1409,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "s2" + "Text": "s2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1392,45 +1484,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "nc_s2" + "Text": "nc_s2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassVS.baseline index 1aeea6540..37c99f798 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsClassVS.baseline @@ -107,29 +107,31 @@ "Runs": [ { "ClassificationTypeName": "class name", - "Text": "c2" + "Text": "c2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "c2" + "Text": "c2", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -159,29 +161,31 @@ "Runs": [ { "ClassificationTypeName": "class name", - "Text": "c3" + "Text": "c3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "c3" + "Text": "c3", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -211,29 +215,31 @@ "Runs": [ { "ClassificationTypeName": "class name", - "Text": "c4" + "Text": "c4", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "c4" + "Text": "c4", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -259,29 +265,31 @@ "Runs": [ { "ClassificationTypeName": "class name", - "Text": "c5" + "Text": "c5", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "c5" + "Text": "c5", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -311,29 +319,31 @@ "Runs": [ { "ClassificationTypeName": "class name", - "Text": "c6" + "Text": "c6", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "c6" + "Text": "c6", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -372,45 +382,51 @@ "Runs": [ { "ClassificationTypeName": "class name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsCommentParsingVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsCommentParsingVS.baseline index 7fb118be2..21c79b8bc 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsCommentParsingVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsCommentParsingVS.baseline @@ -488,29 +488,31 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "simple" + "Text": "simple", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -536,29 +538,31 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "multiLine" + "Text": "multiLine", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -588,29 +592,31 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocSingleLine" + "Text": "jsDocSingleLine", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -640,29 +646,31 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocMultiLine" + "Text": "jsDocMultiLine", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -692,29 +700,31 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocMultiLineMerge" + "Text": "jsDocMultiLineMerge", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -744,29 +754,31 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocMixedComments1" + "Text": "jsDocMixedComments1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -796,29 +808,31 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocMixedComments2" + "Text": "jsDocMixedComments2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -848,29 +862,31 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocMixedComments3" + "Text": "jsDocMixedComments3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -900,29 +916,31 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocMixedComments4" + "Text": "jsDocMixedComments4", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -952,29 +970,31 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocMixedComments5" + "Text": "jsDocMixedComments5", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1004,29 +1024,31 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocMixedComments6" + "Text": "jsDocMixedComments6", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1052,29 +1074,31 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "noHelpComment1" + "Text": "noHelpComment1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1100,29 +1124,31 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "noHelpComment2" + "Text": "noHelpComment2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1148,29 +1174,31 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "noHelpComment3" + "Text": "noHelpComment3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1216,69 +1244,76 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "sum" + "Text": "sum", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1324,69 +1359,76 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "sum" + "Text": "sum", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1441,153 +1483,166 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "multiply" + "Text": "multiply", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "e" + "Text": "e", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1642,153 +1697,166 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "multiply" + "Text": "multiply", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "e" + "Text": "e", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1843,153 +1911,166 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "multiply" + "Text": "multiply", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "e" + "Text": "e", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -2044,153 +2125,166 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "multiply" + "Text": "multiply", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "e" + "Text": "e", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -2245,153 +2339,166 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "multiply" + "Text": "multiply", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "e" + "Text": "e", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -2426,45 +2533,51 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f1" + "Text": "f1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -2487,45 +2600,51 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f1" + "Text": "f1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -2560,45 +2679,51 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f1" + "Text": "f1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -2621,45 +2746,51 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f1" + "Text": "f1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -2725,261 +2856,296 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "subtract" + "Text": "subtract", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "e" + "Text": "e", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "f" + "Text": "f", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -3045,261 +3211,296 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "subtract" + "Text": "subtract", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "e" + "Text": "e", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "f" + "Text": "f", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -3365,261 +3566,296 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "subtract" + "Text": "subtract", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "e" + "Text": "e", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "f" + "Text": "f", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -3685,261 +3921,296 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "subtract" + "Text": "subtract", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "e" + "Text": "e", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "f" + "Text": "f", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -4005,261 +4276,296 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "subtract" + "Text": "subtract", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "e" + "Text": "e", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "f" + "Text": "f", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -4325,261 +4631,296 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "subtract" + "Text": "subtract", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "e" + "Text": "e", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "f" + "Text": "f", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -4618,45 +4959,51 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "square" + "Text": "square", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -4702,69 +5049,76 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "divide" + "Text": "divide", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -4810,69 +5164,76 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "divide" + "Text": "divide", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -4918,69 +5279,76 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "fooBar" + "Text": "fooBar", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "foo" + "Text": "foo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "bar" + "Text": "bar", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -5026,69 +5394,76 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "fooBar" + "Text": "fooBar", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "foo" + "Text": "foo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "bar" + "Text": "bar", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -5156,117 +5531,126 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocParamTest" + "Text": "jsDocParamTest", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -5322,117 +5706,126 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocParamTest" + "Text": "jsDocParamTest", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -5488,117 +5881,126 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocParamTest" + "Text": "jsDocParamTest", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -5654,117 +6056,126 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocParamTest" + "Text": "jsDocParamTest", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "d" + "Text": "d", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -5794,29 +6205,31 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocCommentAlignmentTest1" + "Text": "jsDocCommentAlignmentTest1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -5846,29 +6259,31 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocCommentAlignmentTest2" + "Text": "jsDocCommentAlignmentTest2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -5921,93 +6336,101 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocCommentAlignmentTest3" + "Text": "jsDocCommentAlignmentTest3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -6060,93 +6483,101 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocCommentAlignmentTest3" + "Text": "jsDocCommentAlignmentTest3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -6199,93 +6630,101 @@ not aligned text about parameter will eat only one space "Runs": [ { "ClassificationTypeName": "method name", - "Text": "jsDocCommentAlignmentTest3" + "Text": "jsDocCommentAlignmentTest3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionDeclarationVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionDeclarationVS.baseline index 029497a00..351657ba0 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionDeclarationVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionDeclarationVS.baseline @@ -65,29 +65,31 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "foo" + "Text": "foo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -133,69 +135,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "fooWithParameters" + "Text": "fooWithParameters", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -241,69 +250,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "fooWithParameters" + "Text": "fooWithParameters", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -342,45 +358,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "fn" + "Text": "fn", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionExpressionVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionExpressionVS.baseline index 2b7d99a23..de0f26fc6 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionExpressionVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpCommentsFunctionExpressionVS.baseline @@ -84,69 +84,76 @@ "Runs": [ { "ClassificationTypeName": "local name", - "Text": "lambdaFoo" + "Text": "lambdaFoo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -192,69 +199,76 @@ "Runs": [ { "ClassificationTypeName": "local name", - "Text": "lambdaFoo" + "Text": "lambdaFoo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -293,45 +307,51 @@ "Runs": [ { "ClassificationTypeName": "local name", - "Text": "assigned" + "Text": "assigned", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "s" + "Text": "s", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpConstructorCallParamPropertiesVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpConstructorCallParamPropertiesVS.baseline index d9f716ebe..ae7ea2f22 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpConstructorCallParamPropertiesVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpConstructorCallParamPropertiesVS.baseline @@ -49,45 +49,51 @@ "Runs": [ { "ClassificationTypeName": "class name", - "Text": "Circle" + "Text": "Circle", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "radius" + "Text": "radius", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "Circle" + "Text": "Circle", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpExpandedRestTuplesLocalLabels1VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpExpandedRestTuplesLocalLabels1VS.baseline index 3fe608790..7ad5b9828 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpExpandedRestTuplesLocalLabels1VS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpExpandedRestTuplesLocalLabels1VS.baseline @@ -203,69 +203,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple1" + "Text": "logFruitTuple1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "info" + "Text": "info", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -283,69 +290,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple1" + "Text": "logFruitTuple1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "info" + "Text": "info", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -379,69 +393,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple2" + "Text": "logFruitTuple2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_0" + "Text": "arg_0", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "info" + "Text": "info", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -459,69 +480,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple2" + "Text": "logFruitTuple2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_0" + "Text": "arg_0", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "info" + "Text": "info", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -555,69 +583,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple2" + "Text": "logFruitTuple2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_0" + "Text": "arg_0", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "info" + "Text": "info", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -635,69 +670,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple2" + "Text": "logFruitTuple2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_0" + "Text": "arg_0", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "info" + "Text": "info", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -731,69 +773,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple3" + "Text": "logFruitTuple3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "rest_0" + "Text": "rest_0", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -811,69 +860,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple3" + "Text": "logFruitTuple3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "rest_0" + "Text": "rest_0", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -907,69 +963,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple3" + "Text": "logFruitTuple3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "rest_0" + "Text": "rest_0", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -987,69 +1050,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple3" + "Text": "logFruitTuple3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "rest_0" + "Text": "rest_0", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1083,69 +1153,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple4" + "Text": "logFruitTuple4", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "info" + "Text": "info", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -1163,69 +1240,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple4" + "Text": "logFruitTuple4", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "info" + "Text": "info", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1259,69 +1343,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple4" + "Text": "logFruitTuple4", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "info" + "Text": "info", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -1339,69 +1430,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple4" + "Text": "logFruitTuple4", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "info" + "Text": "info", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1435,81 +1533,91 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple5" + "Text": "logFruitTuple5", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "firstInfo_n" + "Text": "firstInfo_n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -1527,81 +1635,91 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple5" + "Text": "logFruitTuple5", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "firstInfo_n" + "Text": "firstInfo_n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1635,81 +1753,91 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple5" + "Text": "logFruitTuple5", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "firstInfo_n" + "Text": "firstInfo_n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -1727,81 +1855,91 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple5" + "Text": "logFruitTuple5", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "firstInfo_n" + "Text": "firstInfo_n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1835,81 +1973,91 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple6" + "Text": "logFruitTuple6", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruitInfo" + "Text": "fruitInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -1927,81 +2075,91 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple6" + "Text": "logFruitTuple6", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruitInfo" + "Text": "fruitInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -2035,81 +2193,91 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple6" + "Text": "logFruitTuple6", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruitInfo" + "Text": "fruitInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -2127,81 +2295,91 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple6" + "Text": "logFruitTuple6", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruitInfo" + "Text": "fruitInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -2238,105 +2416,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple7" + "Text": "logFruitTuple7", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruitInfoOrNumber_n" + "Text": "fruitInfoOrNumber_n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -2357,105 +2546,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple7" + "Text": "logFruitTuple7", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruitInfoOrNumber_n" + "Text": "fruitInfoOrNumber_n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -2492,105 +2692,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple7" + "Text": "logFruitTuple7", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruitInfoOrNumber_n" + "Text": "fruitInfoOrNumber_n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -2611,105 +2822,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple7" + "Text": "logFruitTuple7", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruitInfoOrNumber_n" + "Text": "fruitInfoOrNumber_n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -2746,105 +2968,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple7" + "Text": "logFruitTuple7", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruitInfoOrNumber_n" + "Text": "fruitInfoOrNumber_n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -2865,105 +3098,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple7" + "Text": "logFruitTuple7", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruitInfoOrNumber_n" + "Text": "fruitInfoOrNumber_n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -3000,105 +3244,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple8" + "Text": "logFruitTuple8", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -3119,105 +3374,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple8" + "Text": "logFruitTuple8", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -3254,105 +3520,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple8" + "Text": "logFruitTuple8", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -3373,105 +3650,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple8" + "Text": "logFruitTuple8", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -3508,105 +3796,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple8" + "Text": "logFruitTuple8", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -3627,105 +3926,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple8" + "Text": "logFruitTuple8", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -3762,105 +4072,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple9" + "Text": "logFruitTuple9", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruitInfoOrNumber_n" + "Text": "fruitInfoOrNumber_n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -3881,105 +4202,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple9" + "Text": "logFruitTuple9", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruitInfoOrNumber_n" + "Text": "fruitInfoOrNumber_n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -4016,105 +4348,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple9" + "Text": "logFruitTuple9", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruitInfoOrNumber_n" + "Text": "fruitInfoOrNumber_n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -4135,105 +4478,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple9" + "Text": "logFruitTuple9", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruitInfoOrNumber_n" + "Text": "fruitInfoOrNumber_n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -4270,105 +4624,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple9" + "Text": "logFruitTuple9", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruitInfoOrNumber_n" + "Text": "fruitInfoOrNumber_n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -4389,105 +4754,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple9" + "Text": "logFruitTuple9", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruitInfoOrNumber_n" + "Text": "fruitInfoOrNumber_n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -4524,105 +4900,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple10" + "Text": "logFruitTuple10", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -4643,105 +5030,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple10" + "Text": "logFruitTuple10", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -4778,105 +5176,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple10" + "Text": "logFruitTuple10", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -4897,105 +5306,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple10" + "Text": "logFruitTuple10", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -5032,105 +5452,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple10" + "Text": "logFruitTuple10", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -5151,105 +5582,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple10" + "Text": "logFruitTuple10", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fruit" + "Text": "fruit", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "secondFruitInfoOrNumber" + "Text": "secondFruitInfoOrNumber", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -5286,105 +5728,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple11" + "Text": "logFruitTuple11", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_0" + "Text": "arg_0", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_2" + "Text": "arg_2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -5405,105 +5858,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple11" + "Text": "logFruitTuple11", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_0" + "Text": "arg_0", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_2" + "Text": "arg_2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -5540,105 +6004,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple11" + "Text": "logFruitTuple11", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_0" + "Text": "arg_0", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_2" + "Text": "arg_2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -5659,105 +6134,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple11" + "Text": "logFruitTuple11", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_0" + "Text": "arg_0", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_2" + "Text": "arg_2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -5794,105 +6280,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple11" + "Text": "logFruitTuple11", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_0" + "Text": "arg_0", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"apple\"" + "Text": "\"apple\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "AppleInfo" + "Text": "AppleInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_2" + "Text": "arg_2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -5913,105 +6410,116 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "logFruitTuple11" + "Text": "logFruitTuple11", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_0" + "Text": "arg_0", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "\"banana\"" + "Text": "\"banana\"", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_1" + "Text": "arg_1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "BananaInfo" + "Text": "BananaInfo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "arg_2" + "Text": "arg_2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -6045,69 +6553,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "withPair" + "Text": "withPair", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "first" + "Text": "first", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "named" + "Text": "named", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -6141,69 +6656,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "withPair" + "Text": "withPair", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "first" + "Text": "first", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "named" + "Text": "named", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpInferenceJsDocImportTagVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpInferenceJsDocImportTagVS.baseline index 467d77b21..65fd4fc0a 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpInferenceJsDocImportTagVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpInferenceJsDocImportTagVS.baseline @@ -40,45 +40,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "foo" + "Text": "foo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "Foo" + "Text": "Foo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpIteratorNextVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpIteratorNextVS.baseline index a131f37aa..20a469a79 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpIteratorNextVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpIteratorNextVS.baseline @@ -71,53 +71,61 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "next" + "Text": "next", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "IteratorResult" + "Text": "IteratorResult", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -132,69 +140,81 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "next" + "Text": "next", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "value" + "Text": "value", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "IteratorResult" + "Text": "IteratorResult", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -220,53 +240,61 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "next" + "Text": "next", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "IteratorResult" + "Text": "IteratorResult", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -281,69 +309,81 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "next" + "Text": "next", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "value" + "Text": "value", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "IteratorResult" + "Text": "IteratorResult", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -369,53 +409,61 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "next" + "Text": "next", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "IteratorResult" + "Text": "IteratorResult", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -430,69 +478,81 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "next" + "Text": "next", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "value" + "Text": "value", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "IteratorResult" + "Text": "IteratorResult", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -518,53 +578,61 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "next" + "Text": "next", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "IteratorResult" + "Text": "IteratorResult", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -579,69 +647,81 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "next" + "Text": "next", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "value" + "Text": "value", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "IteratorResult" + "Text": "IteratorResult", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -667,65 +747,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "next" + "Text": "next", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "Promise" + "Text": "Promise", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "IteratorResult" + "Text": "IteratorResult", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -740,81 +831,96 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "next" + "Text": "next", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "value" + "Text": "value", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "Promise" + "Text": "Promise", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "IteratorResult" + "Text": "IteratorResult", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -840,65 +946,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "next" + "Text": "next", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "Promise" + "Text": "Promise", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "IteratorResult" + "Text": "IteratorResult", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -913,81 +1030,96 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "next" + "Text": "next", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "value" + "Text": "value", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "Promise" + "Text": "Promise", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "IteratorResult" + "Text": "IteratorResult", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1013,65 +1145,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "next" + "Text": "next", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "Promise" + "Text": "Promise", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "IteratorResult" + "Text": "IteratorResult", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -1086,81 +1229,96 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "next" + "Text": "next", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "value" + "Text": "value", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "Promise" + "Text": "Promise", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "IteratorResult" + "Text": "IteratorResult", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -1186,65 +1344,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "next" + "Text": "next", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "Promise" + "Text": "Promise", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "IteratorResult" + "Text": "IteratorResult", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -1259,81 +1428,96 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "next" + "Text": "next", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "value" + "Text": "value", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "Promise" + "Text": "Promise", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "IteratorResult" + "Text": "IteratorResult", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocCallbackTagVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocCallbackTagVS.baseline index 10921c06f..9f1e6f5d4 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocCallbackTagVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocCallbackTagVS.baseline @@ -83,109 +83,121 @@ "Runs": [ { "ClassificationTypeName": "local name", - "Text": "t" + "Text": "t", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "eventName" + "Text": "eventName", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "eventName2" + "Text": "eventName2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "|" + "Text": "|", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "eventName3" + "Text": "eventName3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -234,109 +246,121 @@ "Runs": [ { "ClassificationTypeName": "local name", - "Text": "t" + "Text": "t", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "eventName" + "Text": "eventName", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "eventName2" + "Text": "eventName2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "|" + "Text": "|", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "eventName3" + "Text": "eventName3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -385,109 +409,121 @@ "Runs": [ { "ClassificationTypeName": "local name", - "Text": "t" + "Text": "t", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "eventName" + "Text": "eventName", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "eventName2" + "Text": "eventName2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "|" + "Text": "|", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "eventName3" + "Text": "eventName3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocTagsVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocTagsVS.baseline index ba8e0a81e..06faf5181 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocTagsVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSDocTagsVS.baseline @@ -105,45 +105,51 @@ "Runs": [ { "ClassificationTypeName": "class name", - "Text": "Foo" + "Text": "Foo", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "value" + "Text": "value", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "Foo" + "Text": "Foo", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -173,29 +179,31 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "method1" + "Text": "method1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -221,29 +229,31 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "method2" + "Text": "method2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -269,29 +279,31 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "method3" + "Text": "method3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSMissingPropertyAccessVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSMissingPropertyAccessVS.baseline index d17d7dda1..fb4375749 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSMissingPropertyAccessVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpJSMissingPropertyAccessVS.baseline @@ -48,209 +48,251 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "ReadonlyArray.filter" + "Text": "ReadonlyArray.filter", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "S extends T" + "Text": "S extends T", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "predicate" + "Text": "predicate", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "value" + "Text": "value", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "T" + "Text": "T", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "index" + "Text": "index", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "array" + "Text": "array", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "readonly" + "Text": "readonly", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "T" + "Text": "T", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "value" + "Text": "value", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "is" + "Text": "is", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "S" + "Text": "S", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "thisArg" + "Text": "thisArg", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "S" + "Text": "S", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -280,181 +322,216 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "ReadonlyArray.filter" + "Text": "ReadonlyArray.filter", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "predicate" + "Text": "predicate", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "value" + "Text": "value", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "T" + "Text": "T", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "index" + "Text": "index", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," + "Text": ",", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "array" + "Text": "array", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "readonly" + "Text": "readonly", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "T" + "Text": "T", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "unknown" + "Text": "unknown", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "thisArg" + "Text": "thisArg", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "T" + "Text": "T", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs1VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs1VS.baseline index 0901ea16f..3763f5643 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs1VS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs1VS.baseline @@ -60,93 +60,101 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "fn" + "Text": "fn", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -183,93 +191,101 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "fn" + "Text": "fn", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -306,93 +322,101 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "fn" + "Text": "fn", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -429,93 +453,101 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "fn" + "Text": "fn", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -552,93 +584,101 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "fn" + "Text": "fn", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs2VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs2VS.baseline index 14f40157e..0594058ad 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs2VS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs2VS.baseline @@ -55,81 +55,91 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "Function.call" + "Text": "Function.call", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "thisArg" + "Text": "thisArg", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "argArray" + "Text": "argArray", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs3VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs3VS.baseline index fbf9b94fc..83d8ab068 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs3VS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpRestArgs3VS.baseline @@ -49,109 +49,121 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "assign" + "Text": "assign", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "T extends {}" + "Text": "T extends {}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "U" + "Text": "U", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "target" + "Text": "target", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "T" + "Text": "T", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "source" + "Text": "source", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "U" + "Text": "U", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "T" + "Text": "T", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "&" + "Text": "&", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "U" + "Text": "U", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -188,161 +200,176 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "assign" + "Text": "assign", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "T extends {}" + "Text": "T extends {}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "U" + "Text": "U", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "V" + "Text": "V", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "target" + "Text": "target", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "T" + "Text": "T", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "source1" + "Text": "source1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "U" + "Text": "U", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "source2" + "Text": "source2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "V" + "Text": "V", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "T" + "Text": "T", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "&" + "Text": "&", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "U" + "Text": "U", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "&" + "Text": "&", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "V" + "Text": "V", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -386,213 +413,231 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "assign" + "Text": "assign", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "T extends {}" + "Text": "T extends {}", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "U" + "Text": "U", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "V" + "Text": "V", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "W" + "Text": "W", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "target" + "Text": "target", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "T" + "Text": "T", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "source1" + "Text": "source1", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "U" + "Text": "U", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "source2" + "Text": "source2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "V" + "Text": "V", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "source3" + "Text": "source3", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "W" + "Text": "W", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "T" + "Text": "T", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "&" + "Text": "&", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "U" + "Text": "U", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "&" + "Text": "&", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "V" + "Text": "V", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "&" + "Text": "&", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "text", - "Text": "W" + "Text": "W", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -622,81 +667,91 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "assign" + "Text": "assign", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "target" + "Text": "target", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "object" + "Text": "object", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "..." + "Text": "...", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "sources" + "Text": "sources", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "[" + "Text": "[", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "]" + "Text": "]", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpSkippedArgs1VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpSkippedArgs1VS.baseline index 2a22bdf49..bd5074f75 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpSkippedArgs1VS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpSkippedArgs1VS.baseline @@ -53,93 +53,101 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "fn" + "Text": "fn", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -176,93 +184,101 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "fn" + "Text": "fn", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -299,93 +315,101 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "fn" + "Text": "fn", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -422,93 +446,101 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "fn" + "Text": "fn", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -545,93 +577,101 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "fn" + "Text": "fn", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpTypeArguments2VS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpTypeArguments2VS.baseline index a58563e5c..e8b199f35 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpTypeArguments2VS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpTypeArguments2VS.baseline @@ -70,141 +70,146 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f" + "Text": "f", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "T" + "Text": "T", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "U" + "Text": "U", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "V" + "Text": "V", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "W" + "Text": "W", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "boolean" + "Text": "boolean", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -248,141 +253,146 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f" + "Text": "f", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "T" + "Text": "T", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "U" + "Text": "U", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "V" + "Text": "V", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "W" + "Text": "W", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "boolean" + "Text": "boolean", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -426,141 +436,146 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f" + "Text": "f", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "T" + "Text": "T", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "U" + "Text": "U", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "V" + "Text": "V", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "W" + "Text": "W", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "boolean" + "Text": "boolean", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -604,141 +619,146 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f" + "Text": "f", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "<" + "Text": "<", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "T" + "Text": "T", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "U" + "Text": "U", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "V" + "Text": "V", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "type parameter name", - "Text": "W" + "Text": "W", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ">" + "Text": ">", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "c" + "Text": "c", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "boolean" + "Text": "boolean", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpWithUnknownVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpWithUnknownVS.baseline index 76356cce0..29eda3908 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpWithUnknownVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelpWithUnknownVS.baseline @@ -41,45 +41,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "eval" + "Text": "eval", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "x" + "Text": "x", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "any" + "Text": "any", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelp_unionTypeVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelp_unionTypeVS.baseline index 5a5a977a3..9d323032b 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/signatureHelp_unionTypeVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/signatureHelp_unionTypeVS.baseline @@ -53,153 +53,186 @@ "Runs": [ { "ClassificationTypeName": "local name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "fn" + "Text": "fn", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "?" + "Text": "?", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "x" + "Text": "x", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "|" + "Text": "|", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "y" + "Text": "y", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "=>" + "Text": "=>", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -230,61 +263,71 @@ "Runs": [ { "ClassificationTypeName": "local name", - "Text": "b" + "Text": "b", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "x" + "Text": "x", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "|" + "Text": "|", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "void" + "Text": "void", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -315,77 +358,91 @@ "Runs": [ { "ClassificationTypeName": "interface name", - "Text": "Callback" + "Text": "Callback", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "x" + "Text": "x", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "|" + "Text": "|", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "|" + "Text": "|", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/signatureHelp/trailingCommaSignatureHelpVS.baseline b/testdata/baselines/reference/fourslash/signatureHelp/trailingCommaSignatureHelpVS.baseline index 9fba82dc5..577d4f227 100644 --- a/testdata/baselines/reference/fourslash/signatureHelp/trailingCommaSignatureHelpVS.baseline +++ b/testdata/baselines/reference/fourslash/signatureHelp/trailingCommaSignatureHelpVS.baseline @@ -48,45 +48,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "str" + "Text": "str", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "n" + "Text": "n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } }, { @@ -112,69 +118,76 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "str" + "Text": "str", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "n" + "Text": "n", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "," - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ", ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "radix" + "Text": "radix", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "number" + "Text": "number", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "keyword", - "Text": "string" + "Text": "string", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], @@ -205,45 +218,51 @@ "Runs": [ { "ClassificationTypeName": "method name", - "Text": "f" + "Text": "f", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": "(" + "Text": "(", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "parameter name", - "Text": "a" + "Text": "a", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" + "Text": ":", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "whitespace", - "Text": " " + "Text": " ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "2" + "Text": "2", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ")" + "Text": ")", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "punctuation", - "Text": ":" - }, - { - "ClassificationTypeName": "whitespace", - "Text": " " + "Text": ": ", + "_vs_type": "ClassifiedTextRun" }, { "ClassificationTypeName": "string", - "Text": "2" + "Text": "2", + "_vs_type": "ClassifiedTextRun" } - ] + ], + "_vs_type": "ClassifiedTextElement" } } ], diff --git a/testdata/baselines/reference/fourslash/vsFindAllReferences/constructorFindAllReferences1VS.baseline b/testdata/baselines/reference/fourslash/vsFindAllReferences/constructorFindAllReferences1VS.baseline new file mode 100644 index 000000000..3cf1f00bf --- /dev/null +++ b/testdata/baselines/reference/fourslash/vsFindAllReferences/constructorFindAllReferences1VS.baseline @@ -0,0 +1,68 @@ +// === vsFindAllReferences === +// === /constructorFindAllReferences1VS.ts === +// export class [|C|] { +// /*FIND ALL REFS*/public constructor() { } +// public foo() { } +// } +// +// new [|C|]().foo(); + +[ + { + "_vs_id": 0, + "_vs_kind": [ + 17 + ], + "_vs_location": { + "uri": "file:///constructorFindAllReferences1VS.ts", + "range": { + "start": { + "line": 0, + "character": 13 + }, + "end": { + "line": 0, + "character": 14 + } + } + }, + "_vs_definitionText": { + "Runs": [ + { + "ClassificationTypeName": "keyword", + "Text": "class ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "class name", + "Text": "C", + "_vs_type": "ClassifiedTextRun" + } + ], + "_vs_type": "ClassifiedTextElement" + }, + "_vs_projectName": "/dev/null/inferred", + "_vs_containingType": "" + }, + { + "_vs_id": 1, + "_vs_definitionId": 0, + "_vs_kind": [ + 3 + ], + "_vs_location": { + "uri": "file:///constructorFindAllReferences1VS.ts", + "range": { + "start": { + "line": 5, + "character": 4 + }, + "end": { + "line": 5, + "character": 5 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/vsFindAllReferences/findAllRefsForDefaultExportVS.baseline b/testdata/baselines/reference/fourslash/vsFindAllReferences/findAllRefsForDefaultExportVS.baseline new file mode 100644 index 000000000..529cef847 --- /dev/null +++ b/testdata/baselines/reference/fourslash/vsFindAllReferences/findAllRefsForDefaultExportVS.baseline @@ -0,0 +1,290 @@ +// === vsFindAllReferences === +// === /a.ts === +// export default function /*FIND ALL REFS*/[|f|]() {} + +// === /b.ts === +// import [|g|] from "./a"; +// [|g|](); + +[ + { + "_vs_id": 0, + "_vs_kind": [ + 17 + ], + "_vs_location": { + "uri": "file:///a.ts", + "range": { + "start": { + "line": 0, + "character": 24 + }, + "end": { + "line": 0, + "character": 25 + } + } + }, + "_vs_definitionText": { + "Runs": [ + { + "ClassificationTypeName": "keyword", + "Text": "function ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "method name", + "Text": "f", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "void", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";", + "_vs_type": "ClassifiedTextRun" + } + ], + "_vs_type": "ClassifiedTextElement" + }, + "_vs_projectName": "/dev/null/inferred", + "_vs_containingType": "" + }, + { + "_vs_id": 1, + "_vs_kind": [ + 17 + ], + "_vs_location": { + "uri": "file:///b.ts", + "range": { + "start": { + "line": 0, + "character": 7 + }, + "end": { + "line": 0, + "character": 8 + } + } + }, + "_vs_definitionText": { + "Runs": [ + { + "ClassificationTypeName": "punctuation", + "Text": "(", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "text", + "Text": "alias", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ") ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "function ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "method name", + "Text": "f", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "void", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";", + "_vs_type": "ClassifiedTextRun" + } + ], + "_vs_type": "ClassifiedTextElement" + }, + "_vs_projectName": "/dev/null/inferred", + "_vs_containingType": "" + }, + { + "_vs_id": 2, + "_vs_definitionId": 1, + "_vs_kind": [ + 3 + ], + "_vs_location": { + "uri": "file:///b.ts", + "range": { + "start": { + "line": 1, + "character": 0 + }, + "end": { + "line": 1, + "character": 1 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + } +] + + + +// === vsFindAllReferences === +// === /b.ts === +// import /*FIND ALL REFS*/[|g|] from "./a"; +// [|g|](); + +[ + { + "_vs_id": 0, + "_vs_kind": [ + 17 + ], + "_vs_location": { + "uri": "file:///b.ts", + "range": { + "start": { + "line": 0, + "character": 7 + }, + "end": { + "line": 0, + "character": 8 + } + } + }, + "_vs_definitionText": { + "Runs": [ + { + "ClassificationTypeName": "punctuation", + "Text": "(", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "text", + "Text": "alias", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ") ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "function ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "method name", + "Text": "f", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "void", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";", + "_vs_type": "ClassifiedTextRun" + } + ], + "_vs_type": "ClassifiedTextElement" + }, + "_vs_projectName": "/dev/null/inferred", + "_vs_containingType": "" + }, + { + "_vs_id": 1, + "_vs_definitionId": 0, + "_vs_kind": [ + 3 + ], + "_vs_location": { + "uri": "file:///b.ts", + "range": { + "start": { + "line": 1, + "character": 0 + }, + "end": { + "line": 1, + "character": 1 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/vsFindAllReferences/findAllRefsInheritedProperties1VS.baseline b/testdata/baselines/reference/fourslash/vsFindAllReferences/findAllRefsInheritedProperties1VS.baseline new file mode 100644 index 000000000..2dea088a7 --- /dev/null +++ b/testdata/baselines/reference/fourslash/vsFindAllReferences/findAllRefsInheritedProperties1VS.baseline @@ -0,0 +1,409 @@ +// === vsFindAllReferences === +// === /findAllRefsInheritedProperties1VS.ts === +// class class1 extends class1 { +// /*FIND ALL REFS*/[|doStuff|]() { } +// propName: string; +// } +// +// var v: class1; +// v.[|doStuff|](); +// v.propName; + +[ + { + "_vs_id": 0, + "_vs_kind": [ + 17 + ], + "_vs_location": { + "uri": "file:///findAllRefsInheritedProperties1VS.ts", + "range": { + "start": { + "line": 1, + "character": 3 + }, + "end": { + "line": 1, + "character": 10 + } + } + }, + "_vs_definitionText": { + "Runs": [ + { + "ClassificationTypeName": "punctuation", + "Text": "(", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "text", + "Text": "method", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ") ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "method name", + "Text": "class1.doStuff", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "void", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";", + "_vs_type": "ClassifiedTextRun" + } + ], + "_vs_type": "ClassifiedTextElement" + }, + "_vs_projectName": "/dev/null/inferred", + "_vs_containingType": "" + }, + { + "_vs_id": 1, + "_vs_definitionId": 0, + "_vs_kind": [ + 3 + ], + "_vs_location": { + "uri": "file:///findAllRefsInheritedProperties1VS.ts", + "range": { + "start": { + "line": 6, + "character": 2 + }, + "end": { + "line": 6, + "character": 9 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + } +] + + + +// === vsFindAllReferences === +// === /findAllRefsInheritedProperties1VS.ts === +// class class1 extends class1 { +// doStuff() { } +// /*FIND ALL REFS*/[|propName|]: string; +// } +// +// var v: class1; +// v.doStuff(); +// v.[|propName|]; + +[ + { + "_vs_id": 0, + "_vs_kind": [ + 17 + ], + "_vs_location": { + "uri": "file:///findAllRefsInheritedProperties1VS.ts", + "range": { + "start": { + "line": 2, + "character": 3 + }, + "end": { + "line": 2, + "character": 11 + } + } + }, + "_vs_definitionText": { + "Runs": [ + { + "ClassificationTypeName": "punctuation", + "Text": "(", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "text", + "Text": "property", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ") ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "property name", + "Text": "class1.propName", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ": ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string", + "_vs_type": "ClassifiedTextRun" + } + ], + "_vs_type": "ClassifiedTextElement" + }, + "_vs_projectName": "/dev/null/inferred", + "_vs_containingType": "" + }, + { + "_vs_id": 1, + "_vs_definitionId": 0, + "_vs_kind": [ + 3 + ], + "_vs_location": { + "uri": "file:///findAllRefsInheritedProperties1VS.ts", + "range": { + "start": { + "line": 7, + "character": 2 + }, + "end": { + "line": 7, + "character": 10 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + } +] + + + +// === vsFindAllReferences === +// === /findAllRefsInheritedProperties1VS.ts === +// class class1 extends class1 { +// [|doStuff|]() { } +// propName: string; +// } +// +// var v: class1; +// v./*FIND ALL REFS*/[|doStuff|](); +// v.propName; + +[ + { + "_vs_id": 0, + "_vs_kind": [ + 17 + ], + "_vs_location": { + "uri": "file:///findAllRefsInheritedProperties1VS.ts", + "range": { + "start": { + "line": 1, + "character": 3 + }, + "end": { + "line": 1, + "character": 10 + } + } + }, + "_vs_definitionText": { + "Runs": [ + { + "ClassificationTypeName": "punctuation", + "Text": "(", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "text", + "Text": "method", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ") ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "method name", + "Text": "class1.doStuff", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "(", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ")", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "void", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";", + "_vs_type": "ClassifiedTextRun" + } + ], + "_vs_type": "ClassifiedTextElement" + }, + "_vs_projectName": "/dev/null/inferred", + "_vs_containingType": "" + }, + { + "_vs_id": 1, + "_vs_definitionId": 0, + "_vs_kind": [ + 3 + ], + "_vs_location": { + "uri": "file:///findAllRefsInheritedProperties1VS.ts", + "range": { + "start": { + "line": 6, + "character": 2 + }, + "end": { + "line": 6, + "character": 9 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + } +] + + + +// === vsFindAllReferences === +// === /findAllRefsInheritedProperties1VS.ts === +// class class1 extends class1 { +// doStuff() { } +// [|propName|]: string; +// } +// +// var v: class1; +// v.doStuff(); +// v./*FIND ALL REFS*/[|propName|]; + +[ + { + "_vs_id": 0, + "_vs_kind": [ + 17 + ], + "_vs_location": { + "uri": "file:///findAllRefsInheritedProperties1VS.ts", + "range": { + "start": { + "line": 2, + "character": 3 + }, + "end": { + "line": 2, + "character": 11 + } + } + }, + "_vs_definitionText": { + "Runs": [ + { + "ClassificationTypeName": "punctuation", + "Text": "(", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "text", + "Text": "property", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ") ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "property name", + "Text": "class1.propName", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ": ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string", + "_vs_type": "ClassifiedTextRun" + } + ], + "_vs_type": "ClassifiedTextElement" + }, + "_vs_projectName": "/dev/null/inferred", + "_vs_containingType": "" + }, + { + "_vs_id": 1, + "_vs_definitionId": 0, + "_vs_kind": [ + 3 + ], + "_vs_location": { + "uri": "file:///findAllRefsInheritedProperties1VS.ts", + "range": { + "start": { + "line": 7, + "character": 2 + }, + "end": { + "line": 7, + "character": 10 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/vsFindAllReferences/findReferencesAcrossMultipleProjectsVS.baseline b/testdata/baselines/reference/fourslash/vsFindAllReferences/findReferencesAcrossMultipleProjectsVS.baseline new file mode 100644 index 000000000..49765c951 --- /dev/null +++ b/testdata/baselines/reference/fourslash/vsFindAllReferences/findReferencesAcrossMultipleProjectsVS.baseline @@ -0,0 +1,417 @@ +// === vsFindAllReferences === +// === /a.ts === +// /*FIND ALL REFS*/var [|x|]: number; + +// === /b.ts === +// /// +// [|x|]++; + +// === /c.ts === +// /// +// [|x|]++; + +[ + { + "_vs_id": 0, + "_vs_kind": [ + 17 + ], + "_vs_location": { + "uri": "file:///a.ts", + "range": { + "start": { + "line": 0, + "character": 4 + }, + "end": { + "line": 0, + "character": 5 + } + } + }, + "_vs_definitionText": { + "Runs": [ + { + "ClassificationTypeName": "keyword", + "Text": "var ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "local name", + "Text": "x", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ": ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "number", + "_vs_type": "ClassifiedTextRun" + } + ], + "_vs_type": "ClassifiedTextElement" + }, + "_vs_projectName": "/dev/null/inferred", + "_vs_containingType": "" + }, + { + "_vs_id": 1, + "_vs_definitionId": 0, + "_vs_kind": [ + 4 + ], + "_vs_location": { + "uri": "file:///b.ts", + "range": { + "start": { + "line": 1, + "character": 0 + }, + "end": { + "line": 1, + "character": 1 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + }, + { + "_vs_id": 2, + "_vs_definitionId": 0, + "_vs_kind": [ + 4 + ], + "_vs_location": { + "uri": "file:///c.ts", + "range": { + "start": { + "line": 1, + "character": 0 + }, + "end": { + "line": 1, + "character": 1 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + } +] + + + +// === vsFindAllReferences === +// === /a.ts === +// var /*FIND ALL REFS*/[|x|]: number; + +// === /b.ts === +// /// +// [|x|]++; + +// === /c.ts === +// /// +// [|x|]++; + +[ + { + "_vs_id": 0, + "_vs_kind": [ + 17 + ], + "_vs_location": { + "uri": "file:///a.ts", + "range": { + "start": { + "line": 0, + "character": 4 + }, + "end": { + "line": 0, + "character": 5 + } + } + }, + "_vs_definitionText": { + "Runs": [ + { + "ClassificationTypeName": "keyword", + "Text": "var ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "local name", + "Text": "x", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ": ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "number", + "_vs_type": "ClassifiedTextRun" + } + ], + "_vs_type": "ClassifiedTextElement" + }, + "_vs_projectName": "/dev/null/inferred", + "_vs_containingType": "" + }, + { + "_vs_id": 1, + "_vs_definitionId": 0, + "_vs_kind": [ + 4 + ], + "_vs_location": { + "uri": "file:///b.ts", + "range": { + "start": { + "line": 1, + "character": 0 + }, + "end": { + "line": 1, + "character": 1 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + }, + { + "_vs_id": 2, + "_vs_definitionId": 0, + "_vs_kind": [ + 4 + ], + "_vs_location": { + "uri": "file:///c.ts", + "range": { + "start": { + "line": 1, + "character": 0 + }, + "end": { + "line": 1, + "character": 1 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + } +] + + + +// === vsFindAllReferences === +// === /a.ts === +// var [|x|]: number; + +// === /b.ts === +// /// +// /*FIND ALL REFS*/[|x|]++; + +// === /c.ts === +// /// +// [|x|]++; + +[ + { + "_vs_id": 0, + "_vs_kind": [ + 17 + ], + "_vs_location": { + "uri": "file:///a.ts", + "range": { + "start": { + "line": 0, + "character": 4 + }, + "end": { + "line": 0, + "character": 5 + } + } + }, + "_vs_definitionText": { + "Runs": [ + { + "ClassificationTypeName": "keyword", + "Text": "var ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "local name", + "Text": "x", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ": ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "number", + "_vs_type": "ClassifiedTextRun" + } + ], + "_vs_type": "ClassifiedTextElement" + }, + "_vs_projectName": "/dev/null/inferred", + "_vs_containingType": "" + }, + { + "_vs_id": 1, + "_vs_definitionId": 0, + "_vs_kind": [ + 4 + ], + "_vs_location": { + "uri": "file:///b.ts", + "range": { + "start": { + "line": 1, + "character": 0 + }, + "end": { + "line": 1, + "character": 1 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + }, + { + "_vs_id": 2, + "_vs_definitionId": 0, + "_vs_kind": [ + 4 + ], + "_vs_location": { + "uri": "file:///c.ts", + "range": { + "start": { + "line": 1, + "character": 0 + }, + "end": { + "line": 1, + "character": 1 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + } +] + + + +// === vsFindAllReferences === +// === /a.ts === +// var [|x|]: number; + +// === /b.ts === +// /// +// [|x|]++; + +// === /c.ts === +// /// +// /*FIND ALL REFS*/[|x|]++; + +[ + { + "_vs_id": 0, + "_vs_kind": [ + 17 + ], + "_vs_location": { + "uri": "file:///a.ts", + "range": { + "start": { + "line": 0, + "character": 4 + }, + "end": { + "line": 0, + "character": 5 + } + } + }, + "_vs_definitionText": { + "Runs": [ + { + "ClassificationTypeName": "keyword", + "Text": "var ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "local name", + "Text": "x", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ": ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "number", + "_vs_type": "ClassifiedTextRun" + } + ], + "_vs_type": "ClassifiedTextElement" + }, + "_vs_projectName": "/dev/null/inferred", + "_vs_containingType": "" + }, + { + "_vs_id": 1, + "_vs_definitionId": 0, + "_vs_kind": [ + 4 + ], + "_vs_location": { + "uri": "file:///b.ts", + "range": { + "start": { + "line": 1, + "character": 0 + }, + "end": { + "line": 1, + "character": 1 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + }, + { + "_vs_id": 2, + "_vs_definitionId": 0, + "_vs_kind": [ + 4 + ], + "_vs_location": { + "uri": "file:///c.ts", + "range": { + "start": { + "line": 1, + "character": 0 + }, + "end": { + "line": 1, + "character": 1 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + } +] \ No newline at end of file diff --git a/testdata/baselines/reference/fourslash/vsFindAllReferences/tsxFindAllReferences1VS.baseline b/testdata/baselines/reference/fourslash/vsFindAllReferences/tsxFindAllReferences1VS.baseline new file mode 100644 index 000000000..80b78fd09 --- /dev/null +++ b/testdata/baselines/reference/fourslash/vsFindAllReferences/tsxFindAllReferences1VS.baseline @@ -0,0 +1,361 @@ +// === vsFindAllReferences === +// === /file.tsx === +// declare namespace JSX { +// interface Element { } +// interface IntrinsicElements { +// /*FIND ALL REFS*/[|div|]: { +// name?: string; +// isOpen?: boolean; +// }; +// span: { n: string; }; +// } +// } +// var x = <[|div|] />; + +[ + { + "_vs_id": 0, + "_vs_kind": [ + 17 + ], + "_vs_location": { + "uri": "file:///file.tsx", + "range": { + "start": { + "line": 3, + "character": 8 + }, + "end": { + "line": 3, + "character": 11 + } + } + }, + "_vs_definitionText": { + "Runs": [ + { + "ClassificationTypeName": "punctuation", + "Text": "(", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "text", + "Text": "property", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ") ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "property name", + "Text": "IntrinsicElements.div", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ": ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "property name", + "Text": "name", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "property name", + "Text": "isOpen", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "boolean", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}", + "_vs_type": "ClassifiedTextRun" + } + ], + "_vs_type": "ClassifiedTextElement" + }, + "_vs_projectName": "/dev/null/inferred", + "_vs_containingType": "" + }, + { + "_vs_id": 1, + "_vs_definitionId": 0, + "_vs_kind": [ + 3 + ], + "_vs_location": { + "uri": "file:///file.tsx", + "range": { + "start": { + "line": 10, + "character": 9 + }, + "end": { + "line": 10, + "character": 12 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + } +] + + + +// === vsFindAllReferences === +// === /file.tsx === +// --- (line: 7) skipped --- +// span: { n: string; }; +// } +// } +// var x = /*FIND ALL REFS*/
; + +[] + + + +// === vsFindAllReferences === +// === /file.tsx === +// declare namespace JSX { +// interface Element { } +// interface IntrinsicElements { +// [|div|]: { +// name?: string; +// isOpen?: boolean; +// }; +// span: { n: string; }; +// } +// } +// var x = ; + +[ + { + "_vs_id": 0, + "_vs_kind": [ + 17 + ], + "_vs_location": { + "uri": "file:///file.tsx", + "range": { + "start": { + "line": 3, + "character": 8 + }, + "end": { + "line": 3, + "character": 11 + } + } + }, + "_vs_definitionText": { + "Runs": [ + { + "ClassificationTypeName": "punctuation", + "Text": "(", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "text", + "Text": "property", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ") ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "property name", + "Text": "JSX.IntrinsicElements.div", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ": ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "{", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "property name", + "Text": "name", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "string", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "property name", + "Text": "isOpen", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "?", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ":", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "keyword", + "Text": "boolean", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": ";", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "whitespace", + "Text": " ", + "_vs_type": "ClassifiedTextRun" + }, + { + "ClassificationTypeName": "punctuation", + "Text": "}", + "_vs_type": "ClassifiedTextRun" + } + ], + "_vs_type": "ClassifiedTextElement" + }, + "_vs_projectName": "/dev/null/inferred", + "_vs_containingType": "" + }, + { + "_vs_id": 1, + "_vs_definitionId": 0, + "_vs_kind": [ + 3 + ], + "_vs_location": { + "uri": "file:///file.tsx", + "range": { + "start": { + "line": 10, + "character": 9 + }, + "end": { + "line": 10, + "character": 12 + } + } + }, + "_vs_projectName": "/dev/null/inferred" + } +] \ No newline at end of file diff --git a/testdata/tests/cases/compiler/cjsExportGenericTypes.ts b/testdata/tests/cases/compiler/cjsExportGenericTypes.ts new file mode 100644 index 000000000..7c97483ef --- /dev/null +++ b/testdata/tests/cases/compiler/cjsExportGenericTypes.ts @@ -0,0 +1,25 @@ +// @checkJs: true +// @noEmit: true + +// @filename: set.js +/** + * @template D + * @typedef {(a: D, b: D) => number} SomeUnrelatedGeneric + */ + +/** + * @template T + */ +class SomeGenericClass { + /** + * @param {Set} param + */ + constructor(param) {} +} + +module.exports = SomeGenericClass; + +// @filename: index.js +const Set = require("./set"); + +/** @typedef {Set} MyDefinedType */