.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201105173854-bc9fc8d8c4bc/go/internal/packagesdriver/sizes.go

   1 // Copyright 2018 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 // Package packagesdriver fetches type sizes for go/packages and go/analysis.
   6 package packagesdriver
   7
   8 import (
   9         "bytes"
  10         "context"
  11         "encoding/json"
  12         "fmt"
  13         "go/types"
  14         "os/exec"
  15         "strings"
  16
  17         "golang.org/x/tools/internal/gocommand"
  18 )
  19
  20 var debug = false
  21
  22 func GetSizes(ctx context.Context, buildFlags, env []string, gocmdRunner *gocommand.Runner, dir string) (types.Sizes, error) {
  23         // TODO(matloob): Clean this up. This code is mostly a copy of packages.findExternalDriver.
  24         const toolPrefix = "GOPACKAGESDRIVER="
  25         tool := ""
  26         for _, env := range env {
  27                 if val := strings.TrimPrefix(env, toolPrefix); val != env {
  28                         tool = val
  29                 }
  30         }
  31
  32         if tool == "" {
  33                 var err error
  34                 tool, err = exec.LookPath("gopackagesdriver")
  35                 if err != nil {
  36                         // We did not find the driver, so use "go list".
  37                         tool = "off"
  38                 }
  39         }
  40
  41         if tool == "off" {
  42                 inv := gocommand.Invocation{
  43                         BuildFlags: buildFlags,
  44                         Env:        env,
  45                         WorkingDir: dir,
  46                 }
  47                 return GetSizesGolist(ctx, inv, gocmdRunner)
  48         }
  49
  50         req, err := json.Marshal(struct {
  51                 Command    string   `json:"command"`
  52                 Env        []string `json:"env"`
  53                 BuildFlags []string `json:"build_flags"`
  54         }{
  55                 Command:    "sizes",
  56                 Env:        env,
  57                 BuildFlags: buildFlags,
  58         })
  59         if err != nil {
  60                 return nil, fmt.Errorf("failed to encode message to driver tool: %v", err)
  61         }
  62
  63         buf := new(bytes.Buffer)
  64         cmd := exec.CommandContext(ctx, tool)
  65         cmd.Dir = dir
  66         cmd.Env = env
  67         cmd.Stdin = bytes.NewReader(req)
  68         cmd.Stdout = buf
  69         cmd.Stderr = new(bytes.Buffer)
  70         if err := cmd.Run(); err != nil {
  71                 return nil, fmt.Errorf("%v: %v: %s", tool, err, cmd.Stderr)
  72         }
  73         var response struct {
  74                 // Sizes, if not nil, is the types.Sizes to use when type checking.
  75                 Sizes *types.StdSizes
  76         }
  77         if err := json.Unmarshal(buf.Bytes(), &response); err != nil {
  78                 return nil, err
  79         }
  80         return response.Sizes, nil
  81 }
  82
  83 func GetSizesGolist(ctx context.Context, inv gocommand.Invocation, gocmdRunner *gocommand.Runner) (types.Sizes, error) {
  84         inv.Verb = "list"
  85         inv.Args = []string{"-f", "{{context.GOARCH}} {{context.Compiler}}", "--", "unsafe"}
  86         stdout, stderr, friendlyErr, rawErr := gocmdRunner.RunRaw(ctx, inv)
  87         var goarch, compiler string
  88         if rawErr != nil {
  89                 if strings.Contains(rawErr.Error(), "cannot find main module") {
  90                         // User's running outside of a module. All bets are off. Get GOARCH and guess compiler is gc.
  91                         // TODO(matloob): Is this a problem in practice?
  92                         inv.Verb = "env"
  93                         inv.Args = []string{"GOARCH"}
  94                         envout, enverr := gocmdRunner.Run(ctx, inv)
  95                         if enverr != nil {
  96                                 return nil, enverr
  97                         }
  98                         goarch = strings.TrimSpace(envout.String())
  99                         compiler = "gc"
 100                 } else {
 101                         return nil, friendlyErr
 102                 }
 103         } else {
 104                 fields := strings.Fields(stdout.String())
 105                 if len(fields) < 2 {
 106                         return nil, fmt.Errorf("could not parse GOARCH and Go compiler in format \"<GOARCH> <compiler>\":\nstdout: <<%s>>\nstderr: <<%s>>",
 107                                 stdout.String(), stderr.String())
 108                 }
 109                 goarch = fields[0]
 110                 compiler = fields[1]
 111         }
 112         return types.SizesFor(compiler, goarch), nil
 113 }