1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package mod
import (
"context"
"fmt"
"os"
"path/filepath"
"golang.org/x/mod/modfile"
"golang.org/x/tools/gopls/internal/lsp/command"
"golang.org/x/tools/gopls/internal/lsp/protocol"
"golang.org/x/tools/gopls/internal/lsp/source"
)
// LensFuncs returns the supported lensFuncs for go.mod files.
func LensFuncs() map[command.Command]source.LensFunc {
return map[command.Command]source.LensFunc{
command.UpgradeDependency: upgradeLenses,
command.Tidy: tidyLens,
command.Vendor: vendorLens,
command.RunGovulncheck: vulncheckLenses,
}
}
func upgradeLenses(ctx context.Context, snapshot source.Snapshot, fh source.FileHandle) ([]protocol.CodeLens, error) {
pm, err := snapshot.ParseMod(ctx, fh)
if err != nil || pm.File == nil {
return nil, err
}
uri := protocol.URIFromSpanURI(fh.URI())
reset, err := command.NewResetGoModDiagnosticsCommand("Reset go.mod diagnostics", command.ResetGoModDiagnosticsArgs{URIArg: command.URIArg{URI: uri}})
if err != nil {
return nil, err
}
// Put the `Reset go.mod diagnostics` codelens on the module statement.
modrng, err := moduleStmtRange(fh, pm)
if err != nil {
return nil, err
}
lenses := []protocol.CodeLens{{Range: modrng, Command: reset}}
if len(pm.File.Require) == 0 {
// Nothing to upgrade.
return lenses, nil
}
var requires []string
for _, req := range pm.File.Require {
requires = append(requires, req.Mod.Path)
}
checkUpgrade, err := command.NewCheckUpgradesCommand("Check for upgrades", command.CheckUpgradesArgs{
URI: uri,
Modules: requires,
})
if err != nil {
return nil, err
}
upgradeTransitive, err := command.NewUpgradeDependencyCommand("Upgrade transitive dependencies", command.DependencyArgs{
URI: uri,
AddRequire: false,
GoCmdArgs: []string{"-d", "-u", "-t", "./..."},
})
if err != nil {
return nil, err
}
upgradeDirect, err := command.NewUpgradeDependencyCommand("Upgrade direct dependencies", command.DependencyArgs{
URI: uri,
AddRequire: false,
GoCmdArgs: append([]string{"-d"}, requires...),
})
if err != nil {
return nil, err
}
// Put the upgrade code lenses above the first require block or statement.
rng, err := firstRequireRange(fh, pm)
if err != nil {
return nil, err
}
return append(lenses, []protocol.CodeLens{
{Range: rng, Command: checkUpgrade},
{Range: rng, Command: upgradeTransitive},
{Range: rng, Command: upgradeDirect},
}...), nil
}
func tidyLens(ctx context.Context, snapshot source.Snapshot, fh source.FileHandle) ([]protocol.CodeLens, error) {
pm, err := snapshot.ParseMod(ctx, fh)
if err != nil || pm.File == nil {
return nil, err
}
uri := protocol.URIFromSpanURI(fh.URI())
cmd, err := command.NewTidyCommand("Run go mod tidy", command.URIArgs{URIs: []protocol.DocumentURI{uri}})
if err != nil {
return nil, err
}
rng, err := moduleStmtRange(fh, pm)
if err != nil {
return nil, err
}
return []protocol.CodeLens{{
Range: rng,
Command: cmd,
}}, nil
}
func vendorLens(ctx context.Context, snapshot source.Snapshot, fh source.FileHandle) ([]protocol.CodeLens, error) {
pm, err := snapshot.ParseMod(ctx, fh)
if err != nil || pm.File == nil {
return nil, err
}
if len(pm.File.Require) == 0 {
// Nothing to vendor.
return nil, nil
}
rng, err := moduleStmtRange(fh, pm)
if err != nil {
return nil, err
}
title := "Create vendor directory"
uri := protocol.URIFromSpanURI(fh.URI())
cmd, err := command.NewVendorCommand(title, command.URIArg{URI: uri})
if err != nil {
return nil, err
}
// Change the message depending on whether or not the module already has a
// vendor directory.
vendorDir := filepath.Join(filepath.Dir(fh.URI().Filename()), "vendor")
if info, _ := os.Stat(vendorDir); info != nil && info.IsDir() {
title = "Sync vendor directory"
}
return []protocol.CodeLens{{Range: rng, Command: cmd}}, nil
}
func moduleStmtRange(fh source.FileHandle, pm *source.ParsedModule) (protocol.Range, error) {
if pm.File == nil || pm.File.Module == nil || pm.File.Module.Syntax == nil {
return protocol.Range{}, fmt.Errorf("no module statement in %s", fh.URI())
}
syntax := pm.File.Module.Syntax
return pm.Mapper.OffsetRange(syntax.Start.Byte, syntax.End.Byte)
}
// firstRequireRange returns the range for the first "require" in the given
// go.mod file. This is either a require block or an individual require line.
func firstRequireRange(fh source.FileHandle, pm *source.ParsedModule) (protocol.Range, error) {
if len(pm.File.Require) == 0 {
return protocol.Range{}, fmt.Errorf("no requires in the file %s", fh.URI())
}
var start, end modfile.Position
for _, stmt := range pm.File.Syntax.Stmt {
if b, ok := stmt.(*modfile.LineBlock); ok && len(b.Token) == 1 && b.Token[0] == "require" {
start, end = b.Span()
break
}
}
firstRequire := pm.File.Require[0].Syntax
if start.Byte == 0 || firstRequire.Start.Byte < start.Byte {
start, end = firstRequire.Start, firstRequire.End
}
return pm.Mapper.OffsetRange(start.Byte, end.Byte)
}
func vulncheckLenses(ctx context.Context, snapshot source.Snapshot, fh source.FileHandle) ([]protocol.CodeLens, error) {
pm, err := snapshot.ParseMod(ctx, fh)
if err != nil || pm.File == nil {
return nil, err
}
// Place the codelenses near the module statement.
// A module may not have the require block,
// but vulnerabilities can exist in standard libraries.
uri := protocol.URIFromSpanURI(fh.URI())
rng, err := moduleStmtRange(fh, pm)
if err != nil {
return nil, err
}
vulncheck, err := command.NewRunGovulncheckCommand("Run govulncheck", command.VulncheckArgs{
URI: uri,
Pattern: "./...",
})
if err != nil {
return nil, err
}
return []protocol.CodeLens{
{Range: rng, Command: vulncheck},
}, nil
}
|
