golang源码分析 ：gopls（7）

func (v *version) Run(ctx context.Context, args ...string) error {
    var mode = debug.PlainText
    if v.JSON {
        mode = debug.JSON
    }
    return debug.PrintVersionInfo(ctx, os.Stdout, v.app.verbose(), mode)
}

func (b *bug) Run(ctx context.Context, args ...string) error {
    // This undocumented environment variable allows
    // the cmd integration test (and maintainers) to
    // trigger a call to bug.Report.
    if msg := os.Getenv("TEST_GOPLS_BUG"); msg != "" {
        filecache.Start() // register bug handler
        goplsbug.Report(msg)
        return nil
    }
    // Enumerate bug reports, grouped and sorted.
    _, reports := filecache.BugReports()
    sort.Slice(reports, func(i, j int) bool {
        x, y := reports[i], reports[i]
        if x.Key != y.Key {
            return x.Key < y.Key // ascending key order
        }
        return y.AtTime.Before(x.AtTime) // most recent first
    })
    keyDenom := make(map[string]int) // key is "file:line"
    for _, report := range reports {
        keyDenom[report.Key]++
    }
    // Privacy: the content of 'public' will be posted to GitHub
    // to populate an issue textarea. Even though the user must
    // submit the form to share the information with the world,
    // merely populating the form causes us to share the
    // information with GitHub itself.
    //
    // For that reason, we cannot write private information to
    // public, such as bug reports, which may quote source code.
    public := &bytes.Buffer{}
    fmt.Fprint(public, goplsBugHeader)
    if len(reports) > 0 {
        fmt.Fprintf(public, "#### Internal errors\n\n")
        fmt.Fprintf(public, "Gopls detected %d internal errors, %d distinct:\n",
            len(reports), len(keyDenom))
        for key, denom := range keyDenom {
            fmt.Fprintf(public, "- %s (%d)\n", key, denom)
        }
        fmt.Fprintf(public, "\nPlease copy the full information printed by `gopls bug` here, if you are comfortable sharing it.\n\n")
    }
    debug.PrintVersionInfo(ctx, public, true, debug.Markdown)
    body := public.String()
    title := strings.Join(args, " ")
    if !strings.HasPrefix(title, goplsBugPrefix) {
        title = goplsBugPrefix + title
    }
    if !browser.Open("https://github.com/golang/go/issues/new?title=" + url.QueryEscape(title) + "&body=" + url.QueryEscape(body)) {
        fmt.Print("Please file a new issue at golang.org/issue/new using this template:\n\n")
        fmt.Print(body)
    }
    // Print bug reports to stdout (not GitHub).
    keyNum := make(map[string]int)
    for _, report := range reports {
        fmt.Printf("-- %v -- \n", report.AtTime)
        // Append seq number (e.g. " (1/2)") for repeated keys.
        var seq string
        if denom := keyDenom[report.Key]; denom > 1 {
            keyNum[report.Key]++
            seq = fmt.Sprintf(" (%d/%d)", keyNum[report.Key], denom)
        }
        // Privacy:
        // - File and Stack may contain the name of the user that built gopls.
        // - Description may contain names of the user's packages/files/symbols.
        fmt.Printf("%s:%d: %s%s\n\n", report.File, report.Line, report.Description, seq)
        fmt.Printf("%s\n\n", report.Stack)
    }
    if len(reports) > 0 {
        fmt.Printf("Please copy the above information into the GitHub issue, if you are comfortable sharing it.\n")
    }
    return nil
}

func (h *help) Run(ctx context.Context, args ...string) error {
    find := func(cmds []tool.Application, name string) tool.Application {
        for _, cmd := range cmds {
            if cmd.Name() == name {
                return cmd
            }
        }
        return nil
    }
    // Find the subcommand denoted by args (empty => h.app).
    var cmd tool.Application = h.app
    for i, arg := range args {
        cmd = find(getSubcommands(cmd), arg)
        if cmd == nil {
            return tool.CommandLineErrorf(
                "no such subcommand: %s", strings.Join(args[:i+1], " "))
        }
    }
    // 'gopls help cmd subcmd' is equivalent to 'gopls cmd subcmd -h'.
    // The flag package prints the usage information (defined by tool.Run)
    // when it sees the -h flag.
    fs := flag.NewFlagSet(cmd.Name(), flag.ExitOnError)
    return tool.Run(ctx, fs, h.app, append(args[:len(args):len(args)], "-h"))
}

func (j *apiJSON) Run(ctx context.Context, args ...string) error {
    os.Stdout.WriteString(doc.JSON)
    fmt.Println()
    return nil
}

func (l *licenses) Run(ctx context.Context, args ...string) error {
    txt := licensePreamble
    if licensespkg.Text == "" {
        txt += "(development gopls, license information not available)"
    } else {
        txt += licensespkg.Text
    }
    fmt.Fprint(os.Stdout, txt)
    return nil
}