.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.1.1-0.20210319172145-bda8f5cee399/internal/lsp/command/command_gen.go

   1 // Copyright 2021 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // Don't include this file during code generation, or it will break the build
   6 // if existing interface methods have been modified.
   7 //go:build !generate
   8 // +build !generate
   9
  10 package command
  11
  12 // Code generated by generate.go. DO NOT EDIT.
  13
  14 import (
  15         "context"
  16         "fmt"
  17
  18         "golang.org/x/tools/internal/lsp/protocol"
  19 )
  20
  21 const (
  22         AddDependency     Command = "add_dependency"
  23         AddImport         Command = "add_import"
  24         ApplyFix          Command = "apply_fix"
  25         CheckUpgrades     Command = "check_upgrades"
  26         GCDetails         Command = "gc_details"
  27         Generate          Command = "generate"
  28         GenerateGoplsMod  Command = "generate_gopls_mod"
  29         GoGetPackage      Command = "go_get_package"
  30         ListKnownPackages Command = "list_known_packages"
  31         RegenerateCgo     Command = "regenerate_cgo"
  32         RemoveDependency  Command = "remove_dependency"
  33         RunTests          Command = "run_tests"
  34         Test              Command = "test"
  35         Tidy              Command = "tidy"
  36         ToggleGCDetails   Command = "toggle_gc_details"
  37         UpdateGoSum       Command = "update_go_sum"
  38         UpgradeDependency Command = "upgrade_dependency"
  39         Vendor            Command = "vendor"
  40 )
  41
  42 var Commands = []Command{
  43         AddDependency,
  44         AddImport,
  45         ApplyFix,
  46         CheckUpgrades,
  47         GCDetails,
  48         Generate,
  49         GenerateGoplsMod,
  50         GoGetPackage,
  51         ListKnownPackages,
  52         RegenerateCgo,
  53         RemoveDependency,
  54         RunTests,
  55         Test,
  56         Tidy,
  57         ToggleGCDetails,
  58         UpdateGoSum,
  59         UpgradeDependency,
  60         Vendor,
  61 }
  62
  63 func Dispatch(ctx context.Context, params *protocol.ExecuteCommandParams, s Interface) (interface{}, error) {
  64         switch params.Command {
  65         case "gopls.add_dependency":
  66                 var a0 DependencyArgs
  67                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
  68                         return nil, err
  69                 }
  70                 return nil, s.AddDependency(ctx, a0)
  71         case "gopls.add_import":
  72                 var a0 AddImportArgs
  73                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
  74                         return nil, err
  75                 }
  76                 return s.AddImport(ctx, a0)
  77         case "gopls.apply_fix":
  78                 var a0 ApplyFixArgs
  79                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
  80                         return nil, err
  81                 }
  82                 return nil, s.ApplyFix(ctx, a0)
  83         case "gopls.check_upgrades":
  84                 var a0 CheckUpgradesArgs
  85                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
  86                         return nil, err
  87                 }
  88                 return nil, s.CheckUpgrades(ctx, a0)
  89         case "gopls.gc_details":
  90                 var a0 protocol.DocumentURI
  91                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
  92                         return nil, err
  93                 }
  94                 return nil, s.GCDetails(ctx, a0)
  95         case "gopls.generate":
  96                 var a0 GenerateArgs
  97                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
  98                         return nil, err
  99                 }
 100                 return nil, s.Generate(ctx, a0)
 101         case "gopls.generate_gopls_mod":
 102                 var a0 URIArg
 103                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
 104                         return nil, err
 105                 }
 106                 return nil, s.GenerateGoplsMod(ctx, a0)
 107         case "gopls.go_get_package":
 108                 var a0 GoGetPackageArgs
 109                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
 110                         return nil, err
 111                 }
 112                 return nil, s.GoGetPackage(ctx, a0)
 113         case "gopls.list_known_packages":
 114                 var a0 URIArg
 115                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
 116                         return nil, err
 117                 }
 118                 return s.ListKnownPackages(ctx, a0)
 119         case "gopls.regenerate_cgo":
 120                 var a0 URIArg
 121                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
 122                         return nil, err
 123                 }
 124                 return nil, s.RegenerateCgo(ctx, a0)
 125         case "gopls.remove_dependency":
 126                 var a0 RemoveDependencyArgs
 127                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
 128                         return nil, err
 129                 }
 130                 return nil, s.RemoveDependency(ctx, a0)
 131         case "gopls.run_tests":
 132                 var a0 RunTestsArgs
 133                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
 134                         return nil, err
 135                 }
 136                 return nil, s.RunTests(ctx, a0)
 137         case "gopls.test":
 138                 var a0 protocol.DocumentURI
 139                 var a1 []string
 140                 var a2 []string
 141                 if err := UnmarshalArgs(params.Arguments, &a0, &a1, &a2); err != nil {
 142                         return nil, err
 143                 }
 144                 return nil, s.Test(ctx, a0, a1, a2)
 145         case "gopls.tidy":
 146                 var a0 URIArgs
 147                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
 148                         return nil, err
 149                 }
 150                 return nil, s.Tidy(ctx, a0)
 151         case "gopls.toggle_gc_details":
 152                 var a0 URIArg
 153                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
 154                         return nil, err
 155                 }
 156                 return nil, s.ToggleGCDetails(ctx, a0)
 157         case "gopls.update_go_sum":
 158                 var a0 URIArgs
 159                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
 160                         return nil, err
 161                 }
 162                 return nil, s.UpdateGoSum(ctx, a0)
 163         case "gopls.upgrade_dependency":
 164                 var a0 DependencyArgs
 165                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
 166                         return nil, err
 167                 }
 168                 return nil, s.UpgradeDependency(ctx, a0)
 169         case "gopls.vendor":
 170                 var a0 URIArg
 171                 if err := UnmarshalArgs(params.Arguments, &a0); err != nil {
 172                         return nil, err
 173                 }
 174                 return nil, s.Vendor(ctx, a0)
 175         }
 176         return nil, fmt.Errorf("unsupported command %q", params.Command)
 177 }
 178
 179 func NewAddDependencyCommand(title string, a0 DependencyArgs) (protocol.Command, error) {
 180         args, err := MarshalArgs(a0)
 181         if err != nil {
 182                 return protocol.Command{}, err
 183         }
 184         return protocol.Command{
 185                 Title:     title,
 186                 Command:   "gopls.add_dependency",
 187                 Arguments: args,
 188         }, nil
 189 }
 190
 191 func NewAddImportCommand(title string, a0 AddImportArgs) (protocol.Command, error) {
 192         args, err := MarshalArgs(a0)
 193         if err != nil {
 194                 return protocol.Command{}, err
 195         }
 196         return protocol.Command{
 197                 Title:     title,
 198                 Command:   "gopls.add_import",
 199                 Arguments: args,
 200         }, nil
 201 }
 202
 203 func NewApplyFixCommand(title string, a0 ApplyFixArgs) (protocol.Command, error) {
 204         args, err := MarshalArgs(a0)
 205         if err != nil {
 206                 return protocol.Command{}, err
 207         }
 208         return protocol.Command{
 209                 Title:     title,
 210                 Command:   "gopls.apply_fix",
 211                 Arguments: args,
 212         }, nil
 213 }
 214
 215 func NewCheckUpgradesCommand(title string, a0 CheckUpgradesArgs) (protocol.Command, error) {
 216         args, err := MarshalArgs(a0)
 217         if err != nil {
 218                 return protocol.Command{}, err
 219         }
 220         return protocol.Command{
 221                 Title:     title,
 222                 Command:   "gopls.check_upgrades",
 223                 Arguments: args,
 224         }, nil
 225 }
 226
 227 func NewGCDetailsCommand(title string, a0 protocol.DocumentURI) (protocol.Command, error) {
 228         args, err := MarshalArgs(a0)
 229         if err != nil {
 230                 return protocol.Command{}, err
 231         }
 232         return protocol.Command{
 233                 Title:     title,
 234                 Command:   "gopls.gc_details",
 235                 Arguments: args,
 236         }, nil
 237 }
 238
 239 func NewGenerateCommand(title string, a0 GenerateArgs) (protocol.Command, error) {
 240         args, err := MarshalArgs(a0)
 241         if err != nil {
 242                 return protocol.Command{}, err
 243         }
 244         return protocol.Command{
 245                 Title:     title,
 246                 Command:   "gopls.generate",
 247                 Arguments: args,
 248         }, nil
 249 }
 250
 251 func NewGenerateGoplsModCommand(title string, a0 URIArg) (protocol.Command, error) {
 252         args, err := MarshalArgs(a0)
 253         if err != nil {
 254                 return protocol.Command{}, err
 255         }
 256         return protocol.Command{
 257                 Title:     title,
 258                 Command:   "gopls.generate_gopls_mod",
 259                 Arguments: args,
 260         }, nil
 261 }
 262
 263 func NewGoGetPackageCommand(title string, a0 GoGetPackageArgs) (protocol.Command, error) {
 264         args, err := MarshalArgs(a0)
 265         if err != nil {
 266                 return protocol.Command{}, err
 267         }
 268         return protocol.Command{
 269                 Title:     title,
 270                 Command:   "gopls.go_get_package",
 271                 Arguments: args,
 272         }, nil
 273 }
 274
 275 func NewListKnownPackagesCommand(title string, a0 URIArg) (protocol.Command, error) {
 276         args, err := MarshalArgs(a0)
 277         if err != nil {
 278                 return protocol.Command{}, err
 279         }
 280         return protocol.Command{
 281                 Title:     title,
 282                 Command:   "gopls.list_known_packages",
 283                 Arguments: args,
 284         }, nil
 285 }
 286
 287 func NewRegenerateCgoCommand(title string, a0 URIArg) (protocol.Command, error) {
 288         args, err := MarshalArgs(a0)
 289         if err != nil {
 290                 return protocol.Command{}, err
 291         }
 292         return protocol.Command{
 293                 Title:     title,
 294                 Command:   "gopls.regenerate_cgo",
 295                 Arguments: args,
 296         }, nil
 297 }
 298
 299 func NewRemoveDependencyCommand(title string, a0 RemoveDependencyArgs) (protocol.Command, error) {
 300         args, err := MarshalArgs(a0)
 301         if err != nil {
 302                 return protocol.Command{}, err
 303         }
 304         return protocol.Command{
 305                 Title:     title,
 306                 Command:   "gopls.remove_dependency",
 307                 Arguments: args,
 308         }, nil
 309 }
 310
 311 func NewRunTestsCommand(title string, a0 RunTestsArgs) (protocol.Command, error) {
 312         args, err := MarshalArgs(a0)
 313         if err != nil {
 314                 return protocol.Command{}, err
 315         }
 316         return protocol.Command{
 317                 Title:     title,
 318                 Command:   "gopls.run_tests",
 319                 Arguments: args,
 320         }, nil
 321 }
 322
 323 func NewTestCommand(title string, a0 protocol.DocumentURI, a1 []string, a2 []string) (protocol.Command, error) {
 324         args, err := MarshalArgs(a0, a1, a2)
 325         if err != nil {
 326                 return protocol.Command{}, err
 327         }
 328         return protocol.Command{
 329                 Title:     title,
 330                 Command:   "gopls.test",
 331                 Arguments: args,
 332         }, nil
 333 }
 334
 335 func NewTidyCommand(title string, a0 URIArgs) (protocol.Command, error) {
 336         args, err := MarshalArgs(a0)
 337         if err != nil {
 338                 return protocol.Command{}, err
 339         }
 340         return protocol.Command{
 341                 Title:     title,
 342                 Command:   "gopls.tidy",
 343                 Arguments: args,
 344         }, nil
 345 }
 346
 347 func NewToggleGCDetailsCommand(title string, a0 URIArg) (protocol.Command, error) {
 348         args, err := MarshalArgs(a0)
 349         if err != nil {
 350                 return protocol.Command{}, err
 351         }
 352         return protocol.Command{
 353                 Title:     title,
 354                 Command:   "gopls.toggle_gc_details",
 355                 Arguments: args,
 356         }, nil
 357 }
 358
 359 func NewUpdateGoSumCommand(title string, a0 URIArgs) (protocol.Command, error) {
 360         args, err := MarshalArgs(a0)
 361         if err != nil {
 362                 return protocol.Command{}, err
 363         }
 364         return protocol.Command{
 365                 Title:     title,
 366                 Command:   "gopls.update_go_sum",
 367                 Arguments: args,
 368         }, nil
 369 }
 370
 371 func NewUpgradeDependencyCommand(title string, a0 DependencyArgs) (protocol.Command, error) {
 372         args, err := MarshalArgs(a0)
 373         if err != nil {
 374                 return protocol.Command{}, err
 375         }
 376         return protocol.Command{
 377                 Title:     title,
 378                 Command:   "gopls.upgrade_dependency",
 379                 Arguments: args,
 380         }, nil
 381 }
 382
 383 func NewVendorCommand(title string, a0 URIArg) (protocol.Command, error) {
 384         args, err := MarshalArgs(a0)
 385         if err != nil {
 386                 return protocol.Command{}, err
 387         }
 388         return protocol.Command{
 389                 Title:     title,
 390                 Command:   "gopls.vendor",
 391                 Arguments: args,
 392         }, nil
 393 }