github.com/undoio/delve@v1.9.0/pkg/terminal/starbind/starlark_mapping.go (about)

     1  // DO NOT EDIT: auto-generated using _scripts/gen-starlark-bindings.go
     2  
     3  package starbind
     4  
     5  import (
     6  	"fmt"
     7  	"github.com/undoio/delve/service/api"
     8  	"github.com/undoio/delve/service/rpc2"
     9  	"go.starlark.net/starlark"
    10  )
    11  
    12  func (env *Env) starlarkPredeclare() starlark.StringDict {
    13  	r := starlark.StringDict{}
    14  
    15  	r["amend_breakpoint"] = starlark.NewBuiltin("amend_breakpoint", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    16  		if err := isCancelled(thread); err != nil {
    17  			return starlark.None, decorateError(thread, err)
    18  		}
    19  		var rpcArgs rpc2.AmendBreakpointIn
    20  		var rpcRet rpc2.AmendBreakpointOut
    21  		if len(args) > 0 && args[0] != starlark.None {
    22  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Breakpoint, "Breakpoint")
    23  			if err != nil {
    24  				return starlark.None, decorateError(thread, err)
    25  			}
    26  		}
    27  		for _, kv := range kwargs {
    28  			var err error
    29  			switch kv[0].(starlark.String) {
    30  			case "Breakpoint":
    31  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Breakpoint, "Breakpoint")
    32  			default:
    33  				err = fmt.Errorf("unknown argument %q", kv[0])
    34  			}
    35  			if err != nil {
    36  				return starlark.None, decorateError(thread, err)
    37  			}
    38  		}
    39  		err := env.ctx.Client().CallAPI("AmendBreakpoint", &rpcArgs, &rpcRet)
    40  		if err != nil {
    41  			return starlark.None, err
    42  		}
    43  		return env.interfaceToStarlarkValue(rpcRet), nil
    44  	})
    45  	r["ancestors"] = starlark.NewBuiltin("ancestors", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    46  		if err := isCancelled(thread); err != nil {
    47  			return starlark.None, decorateError(thread, err)
    48  		}
    49  		var rpcArgs rpc2.AncestorsIn
    50  		var rpcRet rpc2.AncestorsOut
    51  		if len(args) > 0 && args[0] != starlark.None {
    52  			err := unmarshalStarlarkValue(args[0], &rpcArgs.GoroutineID, "GoroutineID")
    53  			if err != nil {
    54  				return starlark.None, decorateError(thread, err)
    55  			}
    56  		}
    57  		if len(args) > 1 && args[1] != starlark.None {
    58  			err := unmarshalStarlarkValue(args[1], &rpcArgs.NumAncestors, "NumAncestors")
    59  			if err != nil {
    60  				return starlark.None, decorateError(thread, err)
    61  			}
    62  		}
    63  		if len(args) > 2 && args[2] != starlark.None {
    64  			err := unmarshalStarlarkValue(args[2], &rpcArgs.Depth, "Depth")
    65  			if err != nil {
    66  				return starlark.None, decorateError(thread, err)
    67  			}
    68  		}
    69  		for _, kv := range kwargs {
    70  			var err error
    71  			switch kv[0].(starlark.String) {
    72  			case "GoroutineID":
    73  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.GoroutineID, "GoroutineID")
    74  			case "NumAncestors":
    75  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.NumAncestors, "NumAncestors")
    76  			case "Depth":
    77  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Depth, "Depth")
    78  			default:
    79  				err = fmt.Errorf("unknown argument %q", kv[0])
    80  			}
    81  			if err != nil {
    82  				return starlark.None, decorateError(thread, err)
    83  			}
    84  		}
    85  		err := env.ctx.Client().CallAPI("Ancestors", &rpcArgs, &rpcRet)
    86  		if err != nil {
    87  			return starlark.None, err
    88  		}
    89  		return env.interfaceToStarlarkValue(rpcRet), nil
    90  	})
    91  	r["attached_to_existing_process"] = starlark.NewBuiltin("attached_to_existing_process", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    92  		if err := isCancelled(thread); err != nil {
    93  			return starlark.None, decorateError(thread, err)
    94  		}
    95  		var rpcArgs rpc2.AttachedToExistingProcessIn
    96  		var rpcRet rpc2.AttachedToExistingProcessOut
    97  		err := env.ctx.Client().CallAPI("AttachedToExistingProcess", &rpcArgs, &rpcRet)
    98  		if err != nil {
    99  			return starlark.None, err
   100  		}
   101  		return env.interfaceToStarlarkValue(rpcRet), nil
   102  	})
   103  	r["build_id"] = starlark.NewBuiltin("build_id", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   104  		if err := isCancelled(thread); err != nil {
   105  			return starlark.None, decorateError(thread, err)
   106  		}
   107  		var rpcArgs rpc2.BuildIDIn
   108  		var rpcRet rpc2.BuildIDOut
   109  		err := env.ctx.Client().CallAPI("BuildID", &rpcArgs, &rpcRet)
   110  		if err != nil {
   111  			return starlark.None, err
   112  		}
   113  		return env.interfaceToStarlarkValue(rpcRet), nil
   114  	})
   115  	r["cancel_next"] = starlark.NewBuiltin("cancel_next", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   116  		if err := isCancelled(thread); err != nil {
   117  			return starlark.None, decorateError(thread, err)
   118  		}
   119  		var rpcArgs rpc2.CancelNextIn
   120  		var rpcRet rpc2.CancelNextOut
   121  		err := env.ctx.Client().CallAPI("CancelNext", &rpcArgs, &rpcRet)
   122  		if err != nil {
   123  			return starlark.None, err
   124  		}
   125  		return env.interfaceToStarlarkValue(rpcRet), nil
   126  	})
   127  	r["checkpoint"] = starlark.NewBuiltin("checkpoint", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   128  		if err := isCancelled(thread); err != nil {
   129  			return starlark.None, decorateError(thread, err)
   130  		}
   131  		var rpcArgs rpc2.CheckpointIn
   132  		var rpcRet rpc2.CheckpointOut
   133  		if len(args) > 0 && args[0] != starlark.None {
   134  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Where, "Where")
   135  			if err != nil {
   136  				return starlark.None, decorateError(thread, err)
   137  			}
   138  		}
   139  		for _, kv := range kwargs {
   140  			var err error
   141  			switch kv[0].(starlark.String) {
   142  			case "Where":
   143  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Where, "Where")
   144  			default:
   145  				err = fmt.Errorf("unknown argument %q", kv[0])
   146  			}
   147  			if err != nil {
   148  				return starlark.None, decorateError(thread, err)
   149  			}
   150  		}
   151  		err := env.ctx.Client().CallAPI("Checkpoint", &rpcArgs, &rpcRet)
   152  		if err != nil {
   153  			return starlark.None, err
   154  		}
   155  		return env.interfaceToStarlarkValue(rpcRet), nil
   156  	})
   157  	r["clear_breakpoint"] = starlark.NewBuiltin("clear_breakpoint", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   158  		if err := isCancelled(thread); err != nil {
   159  			return starlark.None, decorateError(thread, err)
   160  		}
   161  		var rpcArgs rpc2.ClearBreakpointIn
   162  		var rpcRet rpc2.ClearBreakpointOut
   163  		if len(args) > 0 && args[0] != starlark.None {
   164  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Id, "Id")
   165  			if err != nil {
   166  				return starlark.None, decorateError(thread, err)
   167  			}
   168  		}
   169  		if len(args) > 1 && args[1] != starlark.None {
   170  			err := unmarshalStarlarkValue(args[1], &rpcArgs.Name, "Name")
   171  			if err != nil {
   172  				return starlark.None, decorateError(thread, err)
   173  			}
   174  		}
   175  		for _, kv := range kwargs {
   176  			var err error
   177  			switch kv[0].(starlark.String) {
   178  			case "Id":
   179  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Id, "Id")
   180  			case "Name":
   181  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Name, "Name")
   182  			default:
   183  				err = fmt.Errorf("unknown argument %q", kv[0])
   184  			}
   185  			if err != nil {
   186  				return starlark.None, decorateError(thread, err)
   187  			}
   188  		}
   189  		err := env.ctx.Client().CallAPI("ClearBreakpoint", &rpcArgs, &rpcRet)
   190  		if err != nil {
   191  			return starlark.None, err
   192  		}
   193  		return env.interfaceToStarlarkValue(rpcRet), nil
   194  	})
   195  	r["clear_checkpoint"] = starlark.NewBuiltin("clear_checkpoint", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   196  		if err := isCancelled(thread); err != nil {
   197  			return starlark.None, decorateError(thread, err)
   198  		}
   199  		var rpcArgs rpc2.ClearCheckpointIn
   200  		var rpcRet rpc2.ClearCheckpointOut
   201  		if len(args) > 0 && args[0] != starlark.None {
   202  			err := unmarshalStarlarkValue(args[0], &rpcArgs.ID, "ID")
   203  			if err != nil {
   204  				return starlark.None, decorateError(thread, err)
   205  			}
   206  		}
   207  		for _, kv := range kwargs {
   208  			var err error
   209  			switch kv[0].(starlark.String) {
   210  			case "ID":
   211  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.ID, "ID")
   212  			default:
   213  				err = fmt.Errorf("unknown argument %q", kv[0])
   214  			}
   215  			if err != nil {
   216  				return starlark.None, decorateError(thread, err)
   217  			}
   218  		}
   219  		err := env.ctx.Client().CallAPI("ClearCheckpoint", &rpcArgs, &rpcRet)
   220  		if err != nil {
   221  			return starlark.None, err
   222  		}
   223  		return env.interfaceToStarlarkValue(rpcRet), nil
   224  	})
   225  	r["raw_command"] = starlark.NewBuiltin("raw_command", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   226  		if err := isCancelled(thread); err != nil {
   227  			return starlark.None, decorateError(thread, err)
   228  		}
   229  		var rpcArgs api.DebuggerCommand
   230  		var rpcRet rpc2.CommandOut
   231  		if len(args) > 0 && args[0] != starlark.None {
   232  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Name, "Name")
   233  			if err != nil {
   234  				return starlark.None, decorateError(thread, err)
   235  			}
   236  		}
   237  		if len(args) > 1 && args[1] != starlark.None {
   238  			err := unmarshalStarlarkValue(args[1], &rpcArgs.ThreadID, "ThreadID")
   239  			if err != nil {
   240  				return starlark.None, decorateError(thread, err)
   241  			}
   242  		}
   243  		if len(args) > 2 && args[2] != starlark.None {
   244  			err := unmarshalStarlarkValue(args[2], &rpcArgs.GoroutineID, "GoroutineID")
   245  			if err != nil {
   246  				return starlark.None, decorateError(thread, err)
   247  			}
   248  		}
   249  		if len(args) > 3 && args[3] != starlark.None {
   250  			err := unmarshalStarlarkValue(args[3], &rpcArgs.ReturnInfoLoadConfig, "ReturnInfoLoadConfig")
   251  			if err != nil {
   252  				return starlark.None, decorateError(thread, err)
   253  			}
   254  		} else {
   255  			cfg := env.ctx.LoadConfig()
   256  			rpcArgs.ReturnInfoLoadConfig = &cfg
   257  		}
   258  		if len(args) > 4 && args[4] != starlark.None {
   259  			err := unmarshalStarlarkValue(args[4], &rpcArgs.Expr, "Expr")
   260  			if err != nil {
   261  				return starlark.None, decorateError(thread, err)
   262  			}
   263  		}
   264  		if len(args) > 5 && args[5] != starlark.None {
   265  			err := unmarshalStarlarkValue(args[5], &rpcArgs.UnsafeCall, "UnsafeCall")
   266  			if err != nil {
   267  				return starlark.None, decorateError(thread, err)
   268  			}
   269  		}
   270  		for _, kv := range kwargs {
   271  			var err error
   272  			switch kv[0].(starlark.String) {
   273  			case "Name":
   274  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Name, "Name")
   275  			case "ThreadID":
   276  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.ThreadID, "ThreadID")
   277  			case "GoroutineID":
   278  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.GoroutineID, "GoroutineID")
   279  			case "ReturnInfoLoadConfig":
   280  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.ReturnInfoLoadConfig, "ReturnInfoLoadConfig")
   281  			case "Expr":
   282  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Expr, "Expr")
   283  			case "UnsafeCall":
   284  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.UnsafeCall, "UnsafeCall")
   285  			default:
   286  				err = fmt.Errorf("unknown argument %q", kv[0])
   287  			}
   288  			if err != nil {
   289  				return starlark.None, decorateError(thread, err)
   290  			}
   291  		}
   292  		err := env.ctx.Client().CallAPI("Command", &rpcArgs, &rpcRet)
   293  		if err != nil {
   294  			return starlark.None, err
   295  		}
   296  		return env.interfaceToStarlarkValue(rpcRet), nil
   297  	})
   298  	r["create_breakpoint"] = starlark.NewBuiltin("create_breakpoint", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   299  		if err := isCancelled(thread); err != nil {
   300  			return starlark.None, decorateError(thread, err)
   301  		}
   302  		var rpcArgs rpc2.CreateBreakpointIn
   303  		var rpcRet rpc2.CreateBreakpointOut
   304  		if len(args) > 0 && args[0] != starlark.None {
   305  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Breakpoint, "Breakpoint")
   306  			if err != nil {
   307  				return starlark.None, decorateError(thread, err)
   308  			}
   309  		}
   310  		for _, kv := range kwargs {
   311  			var err error
   312  			switch kv[0].(starlark.String) {
   313  			case "Breakpoint":
   314  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Breakpoint, "Breakpoint")
   315  			default:
   316  				err = fmt.Errorf("unknown argument %q", kv[0])
   317  			}
   318  			if err != nil {
   319  				return starlark.None, decorateError(thread, err)
   320  			}
   321  		}
   322  		err := env.ctx.Client().CallAPI("CreateBreakpoint", &rpcArgs, &rpcRet)
   323  		if err != nil {
   324  			return starlark.None, err
   325  		}
   326  		return env.interfaceToStarlarkValue(rpcRet), nil
   327  	})
   328  	r["create_ebpf_tracepoint"] = starlark.NewBuiltin("create_ebpf_tracepoint", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   329  		if err := isCancelled(thread); err != nil {
   330  			return starlark.None, decorateError(thread, err)
   331  		}
   332  		var rpcArgs rpc2.CreateEBPFTracepointIn
   333  		var rpcRet rpc2.CreateEBPFTracepointOut
   334  		if len(args) > 0 && args[0] != starlark.None {
   335  			err := unmarshalStarlarkValue(args[0], &rpcArgs.FunctionName, "FunctionName")
   336  			if err != nil {
   337  				return starlark.None, decorateError(thread, err)
   338  			}
   339  		}
   340  		for _, kv := range kwargs {
   341  			var err error
   342  			switch kv[0].(starlark.String) {
   343  			case "FunctionName":
   344  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.FunctionName, "FunctionName")
   345  			default:
   346  				err = fmt.Errorf("unknown argument %q", kv[0])
   347  			}
   348  			if err != nil {
   349  				return starlark.None, decorateError(thread, err)
   350  			}
   351  		}
   352  		err := env.ctx.Client().CallAPI("CreateEBPFTracepoint", &rpcArgs, &rpcRet)
   353  		if err != nil {
   354  			return starlark.None, err
   355  		}
   356  		return env.interfaceToStarlarkValue(rpcRet), nil
   357  	})
   358  	r["create_watchpoint"] = starlark.NewBuiltin("create_watchpoint", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   359  		if err := isCancelled(thread); err != nil {
   360  			return starlark.None, decorateError(thread, err)
   361  		}
   362  		var rpcArgs rpc2.CreateWatchpointIn
   363  		var rpcRet rpc2.CreateWatchpointOut
   364  		if len(args) > 0 && args[0] != starlark.None {
   365  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Scope, "Scope")
   366  			if err != nil {
   367  				return starlark.None, decorateError(thread, err)
   368  			}
   369  		} else {
   370  			rpcArgs.Scope = env.ctx.Scope()
   371  		}
   372  		if len(args) > 1 && args[1] != starlark.None {
   373  			err := unmarshalStarlarkValue(args[1], &rpcArgs.Expr, "Expr")
   374  			if err != nil {
   375  				return starlark.None, decorateError(thread, err)
   376  			}
   377  		}
   378  		if len(args) > 2 && args[2] != starlark.None {
   379  			err := unmarshalStarlarkValue(args[2], &rpcArgs.Type, "Type")
   380  			if err != nil {
   381  				return starlark.None, decorateError(thread, err)
   382  			}
   383  		}
   384  		for _, kv := range kwargs {
   385  			var err error
   386  			switch kv[0].(starlark.String) {
   387  			case "Scope":
   388  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Scope, "Scope")
   389  			case "Expr":
   390  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Expr, "Expr")
   391  			case "Type":
   392  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Type, "Type")
   393  			default:
   394  				err = fmt.Errorf("unknown argument %q", kv[0])
   395  			}
   396  			if err != nil {
   397  				return starlark.None, decorateError(thread, err)
   398  			}
   399  		}
   400  		err := env.ctx.Client().CallAPI("CreateWatchpoint", &rpcArgs, &rpcRet)
   401  		if err != nil {
   402  			return starlark.None, err
   403  		}
   404  		return env.interfaceToStarlarkValue(rpcRet), nil
   405  	})
   406  	r["detach"] = starlark.NewBuiltin("detach", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   407  		if err := isCancelled(thread); err != nil {
   408  			return starlark.None, decorateError(thread, err)
   409  		}
   410  		var rpcArgs rpc2.DetachIn
   411  		var rpcRet rpc2.DetachOut
   412  		if len(args) > 0 && args[0] != starlark.None {
   413  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Kill, "Kill")
   414  			if err != nil {
   415  				return starlark.None, decorateError(thread, err)
   416  			}
   417  		}
   418  		for _, kv := range kwargs {
   419  			var err error
   420  			switch kv[0].(starlark.String) {
   421  			case "Kill":
   422  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Kill, "Kill")
   423  			default:
   424  				err = fmt.Errorf("unknown argument %q", kv[0])
   425  			}
   426  			if err != nil {
   427  				return starlark.None, decorateError(thread, err)
   428  			}
   429  		}
   430  		err := env.ctx.Client().CallAPI("Detach", &rpcArgs, &rpcRet)
   431  		if err != nil {
   432  			return starlark.None, err
   433  		}
   434  		return env.interfaceToStarlarkValue(rpcRet), nil
   435  	})
   436  	r["disassemble"] = starlark.NewBuiltin("disassemble", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   437  		if err := isCancelled(thread); err != nil {
   438  			return starlark.None, decorateError(thread, err)
   439  		}
   440  		var rpcArgs rpc2.DisassembleIn
   441  		var rpcRet rpc2.DisassembleOut
   442  		if len(args) > 0 && args[0] != starlark.None {
   443  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Scope, "Scope")
   444  			if err != nil {
   445  				return starlark.None, decorateError(thread, err)
   446  			}
   447  		} else {
   448  			rpcArgs.Scope = env.ctx.Scope()
   449  		}
   450  		if len(args) > 1 && args[1] != starlark.None {
   451  			err := unmarshalStarlarkValue(args[1], &rpcArgs.StartPC, "StartPC")
   452  			if err != nil {
   453  				return starlark.None, decorateError(thread, err)
   454  			}
   455  		}
   456  		if len(args) > 2 && args[2] != starlark.None {
   457  			err := unmarshalStarlarkValue(args[2], &rpcArgs.EndPC, "EndPC")
   458  			if err != nil {
   459  				return starlark.None, decorateError(thread, err)
   460  			}
   461  		}
   462  		if len(args) > 3 && args[3] != starlark.None {
   463  			err := unmarshalStarlarkValue(args[3], &rpcArgs.Flavour, "Flavour")
   464  			if err != nil {
   465  				return starlark.None, decorateError(thread, err)
   466  			}
   467  		}
   468  		for _, kv := range kwargs {
   469  			var err error
   470  			switch kv[0].(starlark.String) {
   471  			case "Scope":
   472  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Scope, "Scope")
   473  			case "StartPC":
   474  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.StartPC, "StartPC")
   475  			case "EndPC":
   476  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.EndPC, "EndPC")
   477  			case "Flavour":
   478  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Flavour, "Flavour")
   479  			default:
   480  				err = fmt.Errorf("unknown argument %q", kv[0])
   481  			}
   482  			if err != nil {
   483  				return starlark.None, decorateError(thread, err)
   484  			}
   485  		}
   486  		err := env.ctx.Client().CallAPI("Disassemble", &rpcArgs, &rpcRet)
   487  		if err != nil {
   488  			return starlark.None, err
   489  		}
   490  		return env.interfaceToStarlarkValue(rpcRet), nil
   491  	})
   492  	r["dump_cancel"] = starlark.NewBuiltin("dump_cancel", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   493  		if err := isCancelled(thread); err != nil {
   494  			return starlark.None, decorateError(thread, err)
   495  		}
   496  		var rpcArgs rpc2.DumpCancelIn
   497  		var rpcRet rpc2.DumpCancelOut
   498  		err := env.ctx.Client().CallAPI("DumpCancel", &rpcArgs, &rpcRet)
   499  		if err != nil {
   500  			return starlark.None, err
   501  		}
   502  		return env.interfaceToStarlarkValue(rpcRet), nil
   503  	})
   504  	r["dump_start"] = starlark.NewBuiltin("dump_start", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   505  		if err := isCancelled(thread); err != nil {
   506  			return starlark.None, decorateError(thread, err)
   507  		}
   508  		var rpcArgs rpc2.DumpStartIn
   509  		var rpcRet rpc2.DumpStartOut
   510  		if len(args) > 0 && args[0] != starlark.None {
   511  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Destination, "Destination")
   512  			if err != nil {
   513  				return starlark.None, decorateError(thread, err)
   514  			}
   515  		}
   516  		for _, kv := range kwargs {
   517  			var err error
   518  			switch kv[0].(starlark.String) {
   519  			case "Destination":
   520  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Destination, "Destination")
   521  			default:
   522  				err = fmt.Errorf("unknown argument %q", kv[0])
   523  			}
   524  			if err != nil {
   525  				return starlark.None, decorateError(thread, err)
   526  			}
   527  		}
   528  		err := env.ctx.Client().CallAPI("DumpStart", &rpcArgs, &rpcRet)
   529  		if err != nil {
   530  			return starlark.None, err
   531  		}
   532  		return env.interfaceToStarlarkValue(rpcRet), nil
   533  	})
   534  	r["dump_wait"] = starlark.NewBuiltin("dump_wait", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   535  		if err := isCancelled(thread); err != nil {
   536  			return starlark.None, decorateError(thread, err)
   537  		}
   538  		var rpcArgs rpc2.DumpWaitIn
   539  		var rpcRet rpc2.DumpWaitOut
   540  		if len(args) > 0 && args[0] != starlark.None {
   541  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Wait, "Wait")
   542  			if err != nil {
   543  				return starlark.None, decorateError(thread, err)
   544  			}
   545  		}
   546  		for _, kv := range kwargs {
   547  			var err error
   548  			switch kv[0].(starlark.String) {
   549  			case "Wait":
   550  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Wait, "Wait")
   551  			default:
   552  				err = fmt.Errorf("unknown argument %q", kv[0])
   553  			}
   554  			if err != nil {
   555  				return starlark.None, decorateError(thread, err)
   556  			}
   557  		}
   558  		err := env.ctx.Client().CallAPI("DumpWait", &rpcArgs, &rpcRet)
   559  		if err != nil {
   560  			return starlark.None, err
   561  		}
   562  		return env.interfaceToStarlarkValue(rpcRet), nil
   563  	})
   564  	r["eval"] = starlark.NewBuiltin("eval", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   565  		if err := isCancelled(thread); err != nil {
   566  			return starlark.None, decorateError(thread, err)
   567  		}
   568  		var rpcArgs rpc2.EvalIn
   569  		var rpcRet rpc2.EvalOut
   570  		if len(args) > 0 && args[0] != starlark.None {
   571  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Scope, "Scope")
   572  			if err != nil {
   573  				return starlark.None, decorateError(thread, err)
   574  			}
   575  		} else {
   576  			rpcArgs.Scope = env.ctx.Scope()
   577  		}
   578  		if len(args) > 1 && args[1] != starlark.None {
   579  			err := unmarshalStarlarkValue(args[1], &rpcArgs.Expr, "Expr")
   580  			if err != nil {
   581  				return starlark.None, decorateError(thread, err)
   582  			}
   583  		}
   584  		if len(args) > 2 && args[2] != starlark.None {
   585  			err := unmarshalStarlarkValue(args[2], &rpcArgs.Cfg, "Cfg")
   586  			if err != nil {
   587  				return starlark.None, decorateError(thread, err)
   588  			}
   589  		} else {
   590  			cfg := env.ctx.LoadConfig()
   591  			rpcArgs.Cfg = &cfg
   592  		}
   593  		for _, kv := range kwargs {
   594  			var err error
   595  			switch kv[0].(starlark.String) {
   596  			case "Scope":
   597  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Scope, "Scope")
   598  			case "Expr":
   599  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Expr, "Expr")
   600  			case "Cfg":
   601  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Cfg, "Cfg")
   602  			default:
   603  				err = fmt.Errorf("unknown argument %q", kv[0])
   604  			}
   605  			if err != nil {
   606  				return starlark.None, decorateError(thread, err)
   607  			}
   608  		}
   609  		err := env.ctx.Client().CallAPI("Eval", &rpcArgs, &rpcRet)
   610  		if err != nil {
   611  			return starlark.None, err
   612  		}
   613  		return env.interfaceToStarlarkValue(rpcRet), nil
   614  	})
   615  	r["examine_memory"] = starlark.NewBuiltin("examine_memory", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   616  		if err := isCancelled(thread); err != nil {
   617  			return starlark.None, decorateError(thread, err)
   618  		}
   619  		var rpcArgs rpc2.ExamineMemoryIn
   620  		var rpcRet rpc2.ExaminedMemoryOut
   621  		if len(args) > 0 && args[0] != starlark.None {
   622  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Address, "Address")
   623  			if err != nil {
   624  				return starlark.None, decorateError(thread, err)
   625  			}
   626  		}
   627  		if len(args) > 1 && args[1] != starlark.None {
   628  			err := unmarshalStarlarkValue(args[1], &rpcArgs.Length, "Length")
   629  			if err != nil {
   630  				return starlark.None, decorateError(thread, err)
   631  			}
   632  		}
   633  		for _, kv := range kwargs {
   634  			var err error
   635  			switch kv[0].(starlark.String) {
   636  			case "Address":
   637  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Address, "Address")
   638  			case "Length":
   639  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Length, "Length")
   640  			default:
   641  				err = fmt.Errorf("unknown argument %q", kv[0])
   642  			}
   643  			if err != nil {
   644  				return starlark.None, decorateError(thread, err)
   645  			}
   646  		}
   647  		err := env.ctx.Client().CallAPI("ExamineMemory", &rpcArgs, &rpcRet)
   648  		if err != nil {
   649  			return starlark.None, err
   650  		}
   651  		return env.interfaceToStarlarkValue(rpcRet), nil
   652  	})
   653  	r["find_location"] = starlark.NewBuiltin("find_location", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   654  		if err := isCancelled(thread); err != nil {
   655  			return starlark.None, decorateError(thread, err)
   656  		}
   657  		var rpcArgs rpc2.FindLocationIn
   658  		var rpcRet rpc2.FindLocationOut
   659  		if len(args) > 0 && args[0] != starlark.None {
   660  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Scope, "Scope")
   661  			if err != nil {
   662  				return starlark.None, decorateError(thread, err)
   663  			}
   664  		} else {
   665  			rpcArgs.Scope = env.ctx.Scope()
   666  		}
   667  		if len(args) > 1 && args[1] != starlark.None {
   668  			err := unmarshalStarlarkValue(args[1], &rpcArgs.Loc, "Loc")
   669  			if err != nil {
   670  				return starlark.None, decorateError(thread, err)
   671  			}
   672  		}
   673  		if len(args) > 2 && args[2] != starlark.None {
   674  			err := unmarshalStarlarkValue(args[2], &rpcArgs.IncludeNonExecutableLines, "IncludeNonExecutableLines")
   675  			if err != nil {
   676  				return starlark.None, decorateError(thread, err)
   677  			}
   678  		}
   679  		if len(args) > 3 && args[3] != starlark.None {
   680  			err := unmarshalStarlarkValue(args[3], &rpcArgs.SubstitutePathRules, "SubstitutePathRules")
   681  			if err != nil {
   682  				return starlark.None, decorateError(thread, err)
   683  			}
   684  		}
   685  		for _, kv := range kwargs {
   686  			var err error
   687  			switch kv[0].(starlark.String) {
   688  			case "Scope":
   689  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Scope, "Scope")
   690  			case "Loc":
   691  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Loc, "Loc")
   692  			case "IncludeNonExecutableLines":
   693  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.IncludeNonExecutableLines, "IncludeNonExecutableLines")
   694  			case "SubstitutePathRules":
   695  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.SubstitutePathRules, "SubstitutePathRules")
   696  			default:
   697  				err = fmt.Errorf("unknown argument %q", kv[0])
   698  			}
   699  			if err != nil {
   700  				return starlark.None, decorateError(thread, err)
   701  			}
   702  		}
   703  		err := env.ctx.Client().CallAPI("FindLocation", &rpcArgs, &rpcRet)
   704  		if err != nil {
   705  			return starlark.None, err
   706  		}
   707  		return env.interfaceToStarlarkValue(rpcRet), nil
   708  	})
   709  	r["function_return_locations"] = starlark.NewBuiltin("function_return_locations", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   710  		if err := isCancelled(thread); err != nil {
   711  			return starlark.None, decorateError(thread, err)
   712  		}
   713  		var rpcArgs rpc2.FunctionReturnLocationsIn
   714  		var rpcRet rpc2.FunctionReturnLocationsOut
   715  		if len(args) > 0 && args[0] != starlark.None {
   716  			err := unmarshalStarlarkValue(args[0], &rpcArgs.FnName, "FnName")
   717  			if err != nil {
   718  				return starlark.None, decorateError(thread, err)
   719  			}
   720  		}
   721  		for _, kv := range kwargs {
   722  			var err error
   723  			switch kv[0].(starlark.String) {
   724  			case "FnName":
   725  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.FnName, "FnName")
   726  			default:
   727  				err = fmt.Errorf("unknown argument %q", kv[0])
   728  			}
   729  			if err != nil {
   730  				return starlark.None, decorateError(thread, err)
   731  			}
   732  		}
   733  		err := env.ctx.Client().CallAPI("FunctionReturnLocations", &rpcArgs, &rpcRet)
   734  		if err != nil {
   735  			return starlark.None, err
   736  		}
   737  		return env.interfaceToStarlarkValue(rpcRet), nil
   738  	})
   739  	r["get_breakpoint"] = starlark.NewBuiltin("get_breakpoint", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   740  		if err := isCancelled(thread); err != nil {
   741  			return starlark.None, decorateError(thread, err)
   742  		}
   743  		var rpcArgs rpc2.GetBreakpointIn
   744  		var rpcRet rpc2.GetBreakpointOut
   745  		if len(args) > 0 && args[0] != starlark.None {
   746  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Id, "Id")
   747  			if err != nil {
   748  				return starlark.None, decorateError(thread, err)
   749  			}
   750  		}
   751  		if len(args) > 1 && args[1] != starlark.None {
   752  			err := unmarshalStarlarkValue(args[1], &rpcArgs.Name, "Name")
   753  			if err != nil {
   754  				return starlark.None, decorateError(thread, err)
   755  			}
   756  		}
   757  		for _, kv := range kwargs {
   758  			var err error
   759  			switch kv[0].(starlark.String) {
   760  			case "Id":
   761  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Id, "Id")
   762  			case "Name":
   763  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Name, "Name")
   764  			default:
   765  				err = fmt.Errorf("unknown argument %q", kv[0])
   766  			}
   767  			if err != nil {
   768  				return starlark.None, decorateError(thread, err)
   769  			}
   770  		}
   771  		err := env.ctx.Client().CallAPI("GetBreakpoint", &rpcArgs, &rpcRet)
   772  		if err != nil {
   773  			return starlark.None, err
   774  		}
   775  		return env.interfaceToStarlarkValue(rpcRet), nil
   776  	})
   777  	r["get_buffered_tracepoints"] = starlark.NewBuiltin("get_buffered_tracepoints", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   778  		if err := isCancelled(thread); err != nil {
   779  			return starlark.None, decorateError(thread, err)
   780  		}
   781  		var rpcArgs rpc2.GetBufferedTracepointsIn
   782  		var rpcRet rpc2.GetBufferedTracepointsOut
   783  		err := env.ctx.Client().CallAPI("GetBufferedTracepoints", &rpcArgs, &rpcRet)
   784  		if err != nil {
   785  			return starlark.None, err
   786  		}
   787  		return env.interfaceToStarlarkValue(rpcRet), nil
   788  	})
   789  	r["get_thread"] = starlark.NewBuiltin("get_thread", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   790  		if err := isCancelled(thread); err != nil {
   791  			return starlark.None, decorateError(thread, err)
   792  		}
   793  		var rpcArgs rpc2.GetThreadIn
   794  		var rpcRet rpc2.GetThreadOut
   795  		if len(args) > 0 && args[0] != starlark.None {
   796  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Id, "Id")
   797  			if err != nil {
   798  				return starlark.None, decorateError(thread, err)
   799  			}
   800  		}
   801  		for _, kv := range kwargs {
   802  			var err error
   803  			switch kv[0].(starlark.String) {
   804  			case "Id":
   805  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Id, "Id")
   806  			default:
   807  				err = fmt.Errorf("unknown argument %q", kv[0])
   808  			}
   809  			if err != nil {
   810  				return starlark.None, decorateError(thread, err)
   811  			}
   812  		}
   813  		err := env.ctx.Client().CallAPI("GetThread", &rpcArgs, &rpcRet)
   814  		if err != nil {
   815  			return starlark.None, err
   816  		}
   817  		return env.interfaceToStarlarkValue(rpcRet), nil
   818  	})
   819  	r["is_multiclient"] = starlark.NewBuiltin("is_multiclient", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   820  		if err := isCancelled(thread); err != nil {
   821  			return starlark.None, decorateError(thread, err)
   822  		}
   823  		var rpcArgs rpc2.IsMulticlientIn
   824  		var rpcRet rpc2.IsMulticlientOut
   825  		err := env.ctx.Client().CallAPI("IsMulticlient", &rpcArgs, &rpcRet)
   826  		if err != nil {
   827  			return starlark.None, err
   828  		}
   829  		return env.interfaceToStarlarkValue(rpcRet), nil
   830  	})
   831  	r["last_modified"] = starlark.NewBuiltin("last_modified", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   832  		if err := isCancelled(thread); err != nil {
   833  			return starlark.None, decorateError(thread, err)
   834  		}
   835  		var rpcArgs rpc2.LastModifiedIn
   836  		var rpcRet rpc2.LastModifiedOut
   837  		err := env.ctx.Client().CallAPI("LastModified", &rpcArgs, &rpcRet)
   838  		if err != nil {
   839  			return starlark.None, err
   840  		}
   841  		return env.interfaceToStarlarkValue(rpcRet), nil
   842  	})
   843  	r["breakpoints"] = starlark.NewBuiltin("breakpoints", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   844  		if err := isCancelled(thread); err != nil {
   845  			return starlark.None, decorateError(thread, err)
   846  		}
   847  		var rpcArgs rpc2.ListBreakpointsIn
   848  		var rpcRet rpc2.ListBreakpointsOut
   849  		if len(args) > 0 && args[0] != starlark.None {
   850  			err := unmarshalStarlarkValue(args[0], &rpcArgs.All, "All")
   851  			if err != nil {
   852  				return starlark.None, decorateError(thread, err)
   853  			}
   854  		}
   855  		for _, kv := range kwargs {
   856  			var err error
   857  			switch kv[0].(starlark.String) {
   858  			case "All":
   859  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.All, "All")
   860  			default:
   861  				err = fmt.Errorf("unknown argument %q", kv[0])
   862  			}
   863  			if err != nil {
   864  				return starlark.None, decorateError(thread, err)
   865  			}
   866  		}
   867  		err := env.ctx.Client().CallAPI("ListBreakpoints", &rpcArgs, &rpcRet)
   868  		if err != nil {
   869  			return starlark.None, err
   870  		}
   871  		return env.interfaceToStarlarkValue(rpcRet), nil
   872  	})
   873  	r["checkpoints"] = starlark.NewBuiltin("checkpoints", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   874  		if err := isCancelled(thread); err != nil {
   875  			return starlark.None, decorateError(thread, err)
   876  		}
   877  		var rpcArgs rpc2.ListCheckpointsIn
   878  		var rpcRet rpc2.ListCheckpointsOut
   879  		err := env.ctx.Client().CallAPI("ListCheckpoints", &rpcArgs, &rpcRet)
   880  		if err != nil {
   881  			return starlark.None, err
   882  		}
   883  		return env.interfaceToStarlarkValue(rpcRet), nil
   884  	})
   885  	r["dynamic_libraries"] = starlark.NewBuiltin("dynamic_libraries", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   886  		if err := isCancelled(thread); err != nil {
   887  			return starlark.None, decorateError(thread, err)
   888  		}
   889  		var rpcArgs rpc2.ListDynamicLibrariesIn
   890  		var rpcRet rpc2.ListDynamicLibrariesOut
   891  		err := env.ctx.Client().CallAPI("ListDynamicLibraries", &rpcArgs, &rpcRet)
   892  		if err != nil {
   893  			return starlark.None, err
   894  		}
   895  		return env.interfaceToStarlarkValue(rpcRet), nil
   896  	})
   897  	r["function_args"] = starlark.NewBuiltin("function_args", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   898  		if err := isCancelled(thread); err != nil {
   899  			return starlark.None, decorateError(thread, err)
   900  		}
   901  		var rpcArgs rpc2.ListFunctionArgsIn
   902  		var rpcRet rpc2.ListFunctionArgsOut
   903  		if len(args) > 0 && args[0] != starlark.None {
   904  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Scope, "Scope")
   905  			if err != nil {
   906  				return starlark.None, decorateError(thread, err)
   907  			}
   908  		} else {
   909  			rpcArgs.Scope = env.ctx.Scope()
   910  		}
   911  		if len(args) > 1 && args[1] != starlark.None {
   912  			err := unmarshalStarlarkValue(args[1], &rpcArgs.Cfg, "Cfg")
   913  			if err != nil {
   914  				return starlark.None, decorateError(thread, err)
   915  			}
   916  		} else {
   917  			rpcArgs.Cfg = env.ctx.LoadConfig()
   918  		}
   919  		for _, kv := range kwargs {
   920  			var err error
   921  			switch kv[0].(starlark.String) {
   922  			case "Scope":
   923  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Scope, "Scope")
   924  			case "Cfg":
   925  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Cfg, "Cfg")
   926  			default:
   927  				err = fmt.Errorf("unknown argument %q", kv[0])
   928  			}
   929  			if err != nil {
   930  				return starlark.None, decorateError(thread, err)
   931  			}
   932  		}
   933  		err := env.ctx.Client().CallAPI("ListFunctionArgs", &rpcArgs, &rpcRet)
   934  		if err != nil {
   935  			return starlark.None, err
   936  		}
   937  		return env.interfaceToStarlarkValue(rpcRet), nil
   938  	})
   939  	r["functions"] = starlark.NewBuiltin("functions", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   940  		if err := isCancelled(thread); err != nil {
   941  			return starlark.None, decorateError(thread, err)
   942  		}
   943  		var rpcArgs rpc2.ListFunctionsIn
   944  		var rpcRet rpc2.ListFunctionsOut
   945  		if len(args) > 0 && args[0] != starlark.None {
   946  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Filter, "Filter")
   947  			if err != nil {
   948  				return starlark.None, decorateError(thread, err)
   949  			}
   950  		}
   951  		for _, kv := range kwargs {
   952  			var err error
   953  			switch kv[0].(starlark.String) {
   954  			case "Filter":
   955  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Filter, "Filter")
   956  			default:
   957  				err = fmt.Errorf("unknown argument %q", kv[0])
   958  			}
   959  			if err != nil {
   960  				return starlark.None, decorateError(thread, err)
   961  			}
   962  		}
   963  		err := env.ctx.Client().CallAPI("ListFunctions", &rpcArgs, &rpcRet)
   964  		if err != nil {
   965  			return starlark.None, err
   966  		}
   967  		return env.interfaceToStarlarkValue(rpcRet), nil
   968  	})
   969  	r["goroutines"] = starlark.NewBuiltin("goroutines", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   970  		if err := isCancelled(thread); err != nil {
   971  			return starlark.None, decorateError(thread, err)
   972  		}
   973  		var rpcArgs rpc2.ListGoroutinesIn
   974  		var rpcRet rpc2.ListGoroutinesOut
   975  		if len(args) > 0 && args[0] != starlark.None {
   976  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Start, "Start")
   977  			if err != nil {
   978  				return starlark.None, decorateError(thread, err)
   979  			}
   980  		}
   981  		if len(args) > 1 && args[1] != starlark.None {
   982  			err := unmarshalStarlarkValue(args[1], &rpcArgs.Count, "Count")
   983  			if err != nil {
   984  				return starlark.None, decorateError(thread, err)
   985  			}
   986  		}
   987  		if len(args) > 2 && args[2] != starlark.None {
   988  			err := unmarshalStarlarkValue(args[2], &rpcArgs.Filters, "Filters")
   989  			if err != nil {
   990  				return starlark.None, decorateError(thread, err)
   991  			}
   992  		}
   993  		if len(args) > 3 && args[3] != starlark.None {
   994  			err := unmarshalStarlarkValue(args[3], &rpcArgs.GoroutineGroupingOptions, "GoroutineGroupingOptions")
   995  			if err != nil {
   996  				return starlark.None, decorateError(thread, err)
   997  			}
   998  		}
   999  		for _, kv := range kwargs {
  1000  			var err error
  1001  			switch kv[0].(starlark.String) {
  1002  			case "Start":
  1003  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Start, "Start")
  1004  			case "Count":
  1005  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Count, "Count")
  1006  			case "Filters":
  1007  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Filters, "Filters")
  1008  			case "GoroutineGroupingOptions":
  1009  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.GoroutineGroupingOptions, "GoroutineGroupingOptions")
  1010  			default:
  1011  				err = fmt.Errorf("unknown argument %q", kv[0])
  1012  			}
  1013  			if err != nil {
  1014  				return starlark.None, decorateError(thread, err)
  1015  			}
  1016  		}
  1017  		err := env.ctx.Client().CallAPI("ListGoroutines", &rpcArgs, &rpcRet)
  1018  		if err != nil {
  1019  			return starlark.None, err
  1020  		}
  1021  		return env.interfaceToStarlarkValue(rpcRet), nil
  1022  	})
  1023  	r["local_vars"] = starlark.NewBuiltin("local_vars", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1024  		if err := isCancelled(thread); err != nil {
  1025  			return starlark.None, decorateError(thread, err)
  1026  		}
  1027  		var rpcArgs rpc2.ListLocalVarsIn
  1028  		var rpcRet rpc2.ListLocalVarsOut
  1029  		if len(args) > 0 && args[0] != starlark.None {
  1030  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Scope, "Scope")
  1031  			if err != nil {
  1032  				return starlark.None, decorateError(thread, err)
  1033  			}
  1034  		} else {
  1035  			rpcArgs.Scope = env.ctx.Scope()
  1036  		}
  1037  		if len(args) > 1 && args[1] != starlark.None {
  1038  			err := unmarshalStarlarkValue(args[1], &rpcArgs.Cfg, "Cfg")
  1039  			if err != nil {
  1040  				return starlark.None, decorateError(thread, err)
  1041  			}
  1042  		} else {
  1043  			rpcArgs.Cfg = env.ctx.LoadConfig()
  1044  		}
  1045  		for _, kv := range kwargs {
  1046  			var err error
  1047  			switch kv[0].(starlark.String) {
  1048  			case "Scope":
  1049  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Scope, "Scope")
  1050  			case "Cfg":
  1051  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Cfg, "Cfg")
  1052  			default:
  1053  				err = fmt.Errorf("unknown argument %q", kv[0])
  1054  			}
  1055  			if err != nil {
  1056  				return starlark.None, decorateError(thread, err)
  1057  			}
  1058  		}
  1059  		err := env.ctx.Client().CallAPI("ListLocalVars", &rpcArgs, &rpcRet)
  1060  		if err != nil {
  1061  			return starlark.None, err
  1062  		}
  1063  		return env.interfaceToStarlarkValue(rpcRet), nil
  1064  	})
  1065  	r["package_vars"] = starlark.NewBuiltin("package_vars", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1066  		if err := isCancelled(thread); err != nil {
  1067  			return starlark.None, decorateError(thread, err)
  1068  		}
  1069  		var rpcArgs rpc2.ListPackageVarsIn
  1070  		var rpcRet rpc2.ListPackageVarsOut
  1071  		if len(args) > 0 && args[0] != starlark.None {
  1072  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Filter, "Filter")
  1073  			if err != nil {
  1074  				return starlark.None, decorateError(thread, err)
  1075  			}
  1076  		}
  1077  		if len(args) > 1 && args[1] != starlark.None {
  1078  			err := unmarshalStarlarkValue(args[1], &rpcArgs.Cfg, "Cfg")
  1079  			if err != nil {
  1080  				return starlark.None, decorateError(thread, err)
  1081  			}
  1082  		} else {
  1083  			rpcArgs.Cfg = env.ctx.LoadConfig()
  1084  		}
  1085  		for _, kv := range kwargs {
  1086  			var err error
  1087  			switch kv[0].(starlark.String) {
  1088  			case "Filter":
  1089  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Filter, "Filter")
  1090  			case "Cfg":
  1091  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Cfg, "Cfg")
  1092  			default:
  1093  				err = fmt.Errorf("unknown argument %q", kv[0])
  1094  			}
  1095  			if err != nil {
  1096  				return starlark.None, decorateError(thread, err)
  1097  			}
  1098  		}
  1099  		err := env.ctx.Client().CallAPI("ListPackageVars", &rpcArgs, &rpcRet)
  1100  		if err != nil {
  1101  			return starlark.None, err
  1102  		}
  1103  		return env.interfaceToStarlarkValue(rpcRet), nil
  1104  	})
  1105  	r["packages_build_info"] = starlark.NewBuiltin("packages_build_info", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1106  		if err := isCancelled(thread); err != nil {
  1107  			return starlark.None, decorateError(thread, err)
  1108  		}
  1109  		var rpcArgs rpc2.ListPackagesBuildInfoIn
  1110  		var rpcRet rpc2.ListPackagesBuildInfoOut
  1111  		if len(args) > 0 && args[0] != starlark.None {
  1112  			err := unmarshalStarlarkValue(args[0], &rpcArgs.IncludeFiles, "IncludeFiles")
  1113  			if err != nil {
  1114  				return starlark.None, decorateError(thread, err)
  1115  			}
  1116  		}
  1117  		for _, kv := range kwargs {
  1118  			var err error
  1119  			switch kv[0].(starlark.String) {
  1120  			case "IncludeFiles":
  1121  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.IncludeFiles, "IncludeFiles")
  1122  			default:
  1123  				err = fmt.Errorf("unknown argument %q", kv[0])
  1124  			}
  1125  			if err != nil {
  1126  				return starlark.None, decorateError(thread, err)
  1127  			}
  1128  		}
  1129  		err := env.ctx.Client().CallAPI("ListPackagesBuildInfo", &rpcArgs, &rpcRet)
  1130  		if err != nil {
  1131  			return starlark.None, err
  1132  		}
  1133  		return env.interfaceToStarlarkValue(rpcRet), nil
  1134  	})
  1135  	r["registers"] = starlark.NewBuiltin("registers", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1136  		if err := isCancelled(thread); err != nil {
  1137  			return starlark.None, decorateError(thread, err)
  1138  		}
  1139  		var rpcArgs rpc2.ListRegistersIn
  1140  		var rpcRet rpc2.ListRegistersOut
  1141  		if len(args) > 0 && args[0] != starlark.None {
  1142  			err := unmarshalStarlarkValue(args[0], &rpcArgs.ThreadID, "ThreadID")
  1143  			if err != nil {
  1144  				return starlark.None, decorateError(thread, err)
  1145  			}
  1146  		}
  1147  		if len(args) > 1 && args[1] != starlark.None {
  1148  			err := unmarshalStarlarkValue(args[1], &rpcArgs.IncludeFp, "IncludeFp")
  1149  			if err != nil {
  1150  				return starlark.None, decorateError(thread, err)
  1151  			}
  1152  		}
  1153  		if len(args) > 2 && args[2] != starlark.None {
  1154  			err := unmarshalStarlarkValue(args[2], &rpcArgs.Scope, "Scope")
  1155  			if err != nil {
  1156  				return starlark.None, decorateError(thread, err)
  1157  			}
  1158  		} else {
  1159  			scope := env.ctx.Scope()
  1160  			rpcArgs.Scope = &scope
  1161  		}
  1162  		for _, kv := range kwargs {
  1163  			var err error
  1164  			switch kv[0].(starlark.String) {
  1165  			case "ThreadID":
  1166  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.ThreadID, "ThreadID")
  1167  			case "IncludeFp":
  1168  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.IncludeFp, "IncludeFp")
  1169  			case "Scope":
  1170  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Scope, "Scope")
  1171  			default:
  1172  				err = fmt.Errorf("unknown argument %q", kv[0])
  1173  			}
  1174  			if err != nil {
  1175  				return starlark.None, decorateError(thread, err)
  1176  			}
  1177  		}
  1178  		err := env.ctx.Client().CallAPI("ListRegisters", &rpcArgs, &rpcRet)
  1179  		if err != nil {
  1180  			return starlark.None, err
  1181  		}
  1182  		return env.interfaceToStarlarkValue(rpcRet), nil
  1183  	})
  1184  	r["sources"] = starlark.NewBuiltin("sources", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1185  		if err := isCancelled(thread); err != nil {
  1186  			return starlark.None, decorateError(thread, err)
  1187  		}
  1188  		var rpcArgs rpc2.ListSourcesIn
  1189  		var rpcRet rpc2.ListSourcesOut
  1190  		if len(args) > 0 && args[0] != starlark.None {
  1191  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Filter, "Filter")
  1192  			if err != nil {
  1193  				return starlark.None, decorateError(thread, err)
  1194  			}
  1195  		}
  1196  		for _, kv := range kwargs {
  1197  			var err error
  1198  			switch kv[0].(starlark.String) {
  1199  			case "Filter":
  1200  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Filter, "Filter")
  1201  			default:
  1202  				err = fmt.Errorf("unknown argument %q", kv[0])
  1203  			}
  1204  			if err != nil {
  1205  				return starlark.None, decorateError(thread, err)
  1206  			}
  1207  		}
  1208  		err := env.ctx.Client().CallAPI("ListSources", &rpcArgs, &rpcRet)
  1209  		if err != nil {
  1210  			return starlark.None, err
  1211  		}
  1212  		return env.interfaceToStarlarkValue(rpcRet), nil
  1213  	})
  1214  	r["threads"] = starlark.NewBuiltin("threads", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1215  		if err := isCancelled(thread); err != nil {
  1216  			return starlark.None, decorateError(thread, err)
  1217  		}
  1218  		var rpcArgs rpc2.ListThreadsIn
  1219  		var rpcRet rpc2.ListThreadsOut
  1220  		err := env.ctx.Client().CallAPI("ListThreads", &rpcArgs, &rpcRet)
  1221  		if err != nil {
  1222  			return starlark.None, err
  1223  		}
  1224  		return env.interfaceToStarlarkValue(rpcRet), nil
  1225  	})
  1226  	r["types"] = starlark.NewBuiltin("types", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1227  		if err := isCancelled(thread); err != nil {
  1228  			return starlark.None, decorateError(thread, err)
  1229  		}
  1230  		var rpcArgs rpc2.ListTypesIn
  1231  		var rpcRet rpc2.ListTypesOut
  1232  		if len(args) > 0 && args[0] != starlark.None {
  1233  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Filter, "Filter")
  1234  			if err != nil {
  1235  				return starlark.None, decorateError(thread, err)
  1236  			}
  1237  		}
  1238  		for _, kv := range kwargs {
  1239  			var err error
  1240  			switch kv[0].(starlark.String) {
  1241  			case "Filter":
  1242  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Filter, "Filter")
  1243  			default:
  1244  				err = fmt.Errorf("unknown argument %q", kv[0])
  1245  			}
  1246  			if err != nil {
  1247  				return starlark.None, decorateError(thread, err)
  1248  			}
  1249  		}
  1250  		err := env.ctx.Client().CallAPI("ListTypes", &rpcArgs, &rpcRet)
  1251  		if err != nil {
  1252  			return starlark.None, err
  1253  		}
  1254  		return env.interfaceToStarlarkValue(rpcRet), nil
  1255  	})
  1256  	r["process_pid"] = starlark.NewBuiltin("process_pid", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1257  		if err := isCancelled(thread); err != nil {
  1258  			return starlark.None, decorateError(thread, err)
  1259  		}
  1260  		var rpcArgs rpc2.ProcessPidIn
  1261  		var rpcRet rpc2.ProcessPidOut
  1262  		err := env.ctx.Client().CallAPI("ProcessPid", &rpcArgs, &rpcRet)
  1263  		if err != nil {
  1264  			return starlark.None, err
  1265  		}
  1266  		return env.interfaceToStarlarkValue(rpcRet), nil
  1267  	})
  1268  	r["recorded"] = starlark.NewBuiltin("recorded", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1269  		if err := isCancelled(thread); err != nil {
  1270  			return starlark.None, decorateError(thread, err)
  1271  		}
  1272  		var rpcArgs rpc2.RecordedIn
  1273  		var rpcRet rpc2.RecordedOut
  1274  		err := env.ctx.Client().CallAPI("Recorded", &rpcArgs, &rpcRet)
  1275  		if err != nil {
  1276  			return starlark.None, err
  1277  		}
  1278  		return env.interfaceToStarlarkValue(rpcRet), nil
  1279  	})
  1280  	r["restart"] = starlark.NewBuiltin("restart", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1281  		if err := isCancelled(thread); err != nil {
  1282  			return starlark.None, decorateError(thread, err)
  1283  		}
  1284  		var rpcArgs rpc2.RestartIn
  1285  		var rpcRet rpc2.RestartOut
  1286  		if len(args) > 0 && args[0] != starlark.None {
  1287  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Position, "Position")
  1288  			if err != nil {
  1289  				return starlark.None, decorateError(thread, err)
  1290  			}
  1291  		}
  1292  		if len(args) > 1 && args[1] != starlark.None {
  1293  			err := unmarshalStarlarkValue(args[1], &rpcArgs.ResetArgs, "ResetArgs")
  1294  			if err != nil {
  1295  				return starlark.None, decorateError(thread, err)
  1296  			}
  1297  		}
  1298  		if len(args) > 2 && args[2] != starlark.None {
  1299  			err := unmarshalStarlarkValue(args[2], &rpcArgs.NewArgs, "NewArgs")
  1300  			if err != nil {
  1301  				return starlark.None, decorateError(thread, err)
  1302  			}
  1303  		}
  1304  		if len(args) > 3 && args[3] != starlark.None {
  1305  			err := unmarshalStarlarkValue(args[3], &rpcArgs.Rerecord, "Rerecord")
  1306  			if err != nil {
  1307  				return starlark.None, decorateError(thread, err)
  1308  			}
  1309  		}
  1310  		if len(args) > 4 && args[4] != starlark.None {
  1311  			err := unmarshalStarlarkValue(args[4], &rpcArgs.Rebuild, "Rebuild")
  1312  			if err != nil {
  1313  				return starlark.None, decorateError(thread, err)
  1314  			}
  1315  		}
  1316  		if len(args) > 5 && args[5] != starlark.None {
  1317  			err := unmarshalStarlarkValue(args[5], &rpcArgs.NewRedirects, "NewRedirects")
  1318  			if err != nil {
  1319  				return starlark.None, decorateError(thread, err)
  1320  			}
  1321  		}
  1322  		for _, kv := range kwargs {
  1323  			var err error
  1324  			switch kv[0].(starlark.String) {
  1325  			case "Position":
  1326  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Position, "Position")
  1327  			case "ResetArgs":
  1328  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.ResetArgs, "ResetArgs")
  1329  			case "NewArgs":
  1330  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.NewArgs, "NewArgs")
  1331  			case "Rerecord":
  1332  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Rerecord, "Rerecord")
  1333  			case "Rebuild":
  1334  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Rebuild, "Rebuild")
  1335  			case "NewRedirects":
  1336  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.NewRedirects, "NewRedirects")
  1337  			default:
  1338  				err = fmt.Errorf("unknown argument %q", kv[0])
  1339  			}
  1340  			if err != nil {
  1341  				return starlark.None, decorateError(thread, err)
  1342  			}
  1343  		}
  1344  		err := env.ctx.Client().CallAPI("Restart", &rpcArgs, &rpcRet)
  1345  		if err != nil {
  1346  			return starlark.None, err
  1347  		}
  1348  		return env.interfaceToStarlarkValue(rpcRet), nil
  1349  	})
  1350  	r["set_expr"] = starlark.NewBuiltin("set_expr", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1351  		if err := isCancelled(thread); err != nil {
  1352  			return starlark.None, decorateError(thread, err)
  1353  		}
  1354  		var rpcArgs rpc2.SetIn
  1355  		var rpcRet rpc2.SetOut
  1356  		if len(args) > 0 && args[0] != starlark.None {
  1357  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Scope, "Scope")
  1358  			if err != nil {
  1359  				return starlark.None, decorateError(thread, err)
  1360  			}
  1361  		} else {
  1362  			rpcArgs.Scope = env.ctx.Scope()
  1363  		}
  1364  		if len(args) > 1 && args[1] != starlark.None {
  1365  			err := unmarshalStarlarkValue(args[1], &rpcArgs.Symbol, "Symbol")
  1366  			if err != nil {
  1367  				return starlark.None, decorateError(thread, err)
  1368  			}
  1369  		}
  1370  		if len(args) > 2 && args[2] != starlark.None {
  1371  			err := unmarshalStarlarkValue(args[2], &rpcArgs.Value, "Value")
  1372  			if err != nil {
  1373  				return starlark.None, decorateError(thread, err)
  1374  			}
  1375  		}
  1376  		for _, kv := range kwargs {
  1377  			var err error
  1378  			switch kv[0].(starlark.String) {
  1379  			case "Scope":
  1380  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Scope, "Scope")
  1381  			case "Symbol":
  1382  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Symbol, "Symbol")
  1383  			case "Value":
  1384  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Value, "Value")
  1385  			default:
  1386  				err = fmt.Errorf("unknown argument %q", kv[0])
  1387  			}
  1388  			if err != nil {
  1389  				return starlark.None, decorateError(thread, err)
  1390  			}
  1391  		}
  1392  		err := env.ctx.Client().CallAPI("Set", &rpcArgs, &rpcRet)
  1393  		if err != nil {
  1394  			return starlark.None, err
  1395  		}
  1396  		return env.interfaceToStarlarkValue(rpcRet), nil
  1397  	})
  1398  	r["stacktrace"] = starlark.NewBuiltin("stacktrace", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1399  		if err := isCancelled(thread); err != nil {
  1400  			return starlark.None, decorateError(thread, err)
  1401  		}
  1402  		var rpcArgs rpc2.StacktraceIn
  1403  		var rpcRet rpc2.StacktraceOut
  1404  		if len(args) > 0 && args[0] != starlark.None {
  1405  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Id, "Id")
  1406  			if err != nil {
  1407  				return starlark.None, decorateError(thread, err)
  1408  			}
  1409  		}
  1410  		if len(args) > 1 && args[1] != starlark.None {
  1411  			err := unmarshalStarlarkValue(args[1], &rpcArgs.Depth, "Depth")
  1412  			if err != nil {
  1413  				return starlark.None, decorateError(thread, err)
  1414  			}
  1415  		}
  1416  		if len(args) > 2 && args[2] != starlark.None {
  1417  			err := unmarshalStarlarkValue(args[2], &rpcArgs.Full, "Full")
  1418  			if err != nil {
  1419  				return starlark.None, decorateError(thread, err)
  1420  			}
  1421  		}
  1422  		if len(args) > 3 && args[3] != starlark.None {
  1423  			err := unmarshalStarlarkValue(args[3], &rpcArgs.Defers, "Defers")
  1424  			if err != nil {
  1425  				return starlark.None, decorateError(thread, err)
  1426  			}
  1427  		}
  1428  		if len(args) > 4 && args[4] != starlark.None {
  1429  			err := unmarshalStarlarkValue(args[4], &rpcArgs.Opts, "Opts")
  1430  			if err != nil {
  1431  				return starlark.None, decorateError(thread, err)
  1432  			}
  1433  		}
  1434  		if len(args) > 5 && args[5] != starlark.None {
  1435  			err := unmarshalStarlarkValue(args[5], &rpcArgs.Cfg, "Cfg")
  1436  			if err != nil {
  1437  				return starlark.None, decorateError(thread, err)
  1438  			}
  1439  		}
  1440  		for _, kv := range kwargs {
  1441  			var err error
  1442  			switch kv[0].(starlark.String) {
  1443  			case "Id":
  1444  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Id, "Id")
  1445  			case "Depth":
  1446  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Depth, "Depth")
  1447  			case "Full":
  1448  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Full, "Full")
  1449  			case "Defers":
  1450  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Defers, "Defers")
  1451  			case "Opts":
  1452  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Opts, "Opts")
  1453  			case "Cfg":
  1454  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Cfg, "Cfg")
  1455  			default:
  1456  				err = fmt.Errorf("unknown argument %q", kv[0])
  1457  			}
  1458  			if err != nil {
  1459  				return starlark.None, decorateError(thread, err)
  1460  			}
  1461  		}
  1462  		err := env.ctx.Client().CallAPI("Stacktrace", &rpcArgs, &rpcRet)
  1463  		if err != nil {
  1464  			return starlark.None, err
  1465  		}
  1466  		return env.interfaceToStarlarkValue(rpcRet), nil
  1467  	})
  1468  	r["state"] = starlark.NewBuiltin("state", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1469  		if err := isCancelled(thread); err != nil {
  1470  			return starlark.None, decorateError(thread, err)
  1471  		}
  1472  		var rpcArgs rpc2.StateIn
  1473  		var rpcRet rpc2.StateOut
  1474  		if len(args) > 0 && args[0] != starlark.None {
  1475  			err := unmarshalStarlarkValue(args[0], &rpcArgs.NonBlocking, "NonBlocking")
  1476  			if err != nil {
  1477  				return starlark.None, decorateError(thread, err)
  1478  			}
  1479  		}
  1480  		for _, kv := range kwargs {
  1481  			var err error
  1482  			switch kv[0].(starlark.String) {
  1483  			case "NonBlocking":
  1484  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.NonBlocking, "NonBlocking")
  1485  			default:
  1486  				err = fmt.Errorf("unknown argument %q", kv[0])
  1487  			}
  1488  			if err != nil {
  1489  				return starlark.None, decorateError(thread, err)
  1490  			}
  1491  		}
  1492  		err := env.ctx.Client().CallAPI("State", &rpcArgs, &rpcRet)
  1493  		if err != nil {
  1494  			return starlark.None, err
  1495  		}
  1496  		return env.interfaceToStarlarkValue(rpcRet), nil
  1497  	})
  1498  	r["toggle_breakpoint"] = starlark.NewBuiltin("toggle_breakpoint", func(thread *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1499  		if err := isCancelled(thread); err != nil {
  1500  			return starlark.None, decorateError(thread, err)
  1501  		}
  1502  		var rpcArgs rpc2.ToggleBreakpointIn
  1503  		var rpcRet rpc2.ToggleBreakpointOut
  1504  		if len(args) > 0 && args[0] != starlark.None {
  1505  			err := unmarshalStarlarkValue(args[0], &rpcArgs.Id, "Id")
  1506  			if err != nil {
  1507  				return starlark.None, decorateError(thread, err)
  1508  			}
  1509  		}
  1510  		if len(args) > 1 && args[1] != starlark.None {
  1511  			err := unmarshalStarlarkValue(args[1], &rpcArgs.Name, "Name")
  1512  			if err != nil {
  1513  				return starlark.None, decorateError(thread, err)
  1514  			}
  1515  		}
  1516  		for _, kv := range kwargs {
  1517  			var err error
  1518  			switch kv[0].(starlark.String) {
  1519  			case "Id":
  1520  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Id, "Id")
  1521  			case "Name":
  1522  				err = unmarshalStarlarkValue(kv[1], &rpcArgs.Name, "Name")
  1523  			default:
  1524  				err = fmt.Errorf("unknown argument %q", kv[0])
  1525  			}
  1526  			if err != nil {
  1527  				return starlark.None, decorateError(thread, err)
  1528  			}
  1529  		}
  1530  		err := env.ctx.Client().CallAPI("ToggleBreakpoint", &rpcArgs, &rpcRet)
  1531  		if err != nil {
  1532  			return starlark.None, err
  1533  		}
  1534  		return env.interfaceToStarlarkValue(rpcRet), nil
  1535  	})
  1536  	return r
  1537  }