+4 -5

cmd/cue/cmd/add.go

reviewed

··· 20 20 "fmt" 21 21 "html/template" 22 22 "io" 23 23 - "io/ioutil" 24 23 "os" 25 24 "path/filepath" 26 25 "strings" ··· 126 125 } 127 126 128 127 // Read text to be appended. 129 129 - text, err := ioutil.ReadAll(cmd.InOrStdin()) 128 128 + text, err := io.ReadAll(cmd.InOrStdin()) 130 129 if err != nil { 131 130 return err 132 131 } ··· 204 203 if len(fo.contents) == 0 { 205 204 return os.Remove(fo.filename) 206 205 } 207 207 - return ioutil.WriteFile(fo.filename, fo.contents, 0644) 206 206 + return os.WriteFile(fo.filename, fo.contents, 0644) 208 207 } 209 208 210 209 type fileInfo struct { ··· 271 270 272 271 func (fi *fileInfo) appendAndCheck() (fo originalFile, err error) { 273 272 // Read original file 274 274 - b, err := ioutil.ReadFile(fi.filename) 273 273 + b, err := os.ReadFile(fi.filename) 275 274 if err == nil { 276 275 fo.filename = fi.filename 277 276 fo.contents = b ··· 289 288 return originalFile{}, err 290 289 } 291 290 292 292 - if err = ioutil.WriteFile(fi.filename, b, 0644); err != nil { 291 291 + if err = os.WriteFile(fi.filename, b, 0644); err != nil { 293 292 // Just in case, attempt to restore original file. 294 293 _ = fo.restore() 295 294 return originalFile{}, err

+2 -2

cmd/cue/cmd/custom.go

reviewed

··· 19 19 import ( 20 20 "context" 21 21 "encoding/json" 22 22 - "io/ioutil" 22 22 + "io" 23 23 "net/http" 24 24 "net/http/httptest" 25 25 "strings" ··· 268 268 testOnce.Do(func() { 269 269 s := httptest.NewServer(http.HandlerFunc( 270 270 func(w http.ResponseWriter, req *http.Request) { 271 271 - data, _ := ioutil.ReadAll(req.Body) 271 271 + data, _ := io.ReadAll(req.Body) 272 272 d := map[string]interface{}{ 273 273 "data": string(data), 274 274 "when": "now",

+1 -2

cmd/cue/cmd/fix.go

reviewed

··· 16 16 17 17 import ( 18 18 "io/fs" 19 19 - "io/ioutil" 20 19 "os" 21 20 "path/filepath" 22 21 "strings" ··· 107 106 errs = errors.Append(errs, errors.Promote(err, "format")) 108 107 } 109 108 110 110 - err = ioutil.WriteFile(f.Filename, b, 0644) 109 109 + err = os.WriteFile(f.Filename, b, 0644) 111 110 if err != nil { 112 111 errs = errors.Append(errs, errors.Promote(err, "write")) 113 112 }

+3 -4

cmd/cue/cmd/get_go.go

reviewed

··· 22 22 "go/types" 23 23 "io" 24 24 "io/fs" 25 25 - "io/ioutil" 26 25 "os" 27 26 "path" 28 27 "path/filepath" ··· 535 534 if err != nil { 536 535 return err 537 536 } 538 538 - err = ioutil.WriteFile(filepath.Join(dir, file), b, 0666) 537 537 + err = os.WriteFile(filepath.Join(dir, file), b, 0666) 539 538 if err != nil { 540 539 return err 541 540 } ··· 589 588 fmt.Fprintln(w, "//cue:generate cue get go", args) 590 589 fmt.Fprintln(w) 591 590 592 592 - b, err := ioutil.ReadFile(path) 591 591 + b, err := os.ReadFile(path) 593 592 if err != nil { 594 593 return err 595 594 } 596 595 w.Write(b) 597 596 598 597 dst := filepath.Join(dir, file) 599 599 - if err := ioutil.WriteFile(dst, w.Bytes(), 0666); err != nil { 598 598 + if err := os.WriteFile(dst, w.Bytes(), 0666); err != nil { 600 599 return err 601 600 } 602 601 }

+1 -2

cmd/cue/cmd/import.go

reviewed

··· 17 17 import ( 18 18 "bytes" 19 19 "fmt" 20 20 - "io/ioutil" 21 20 "os" 22 21 "path/filepath" 23 22 "strings" ··· 492 491 return err 493 492 } 494 493 _ = os.MkdirAll(filepath.Dir(cueFile), 0755) 495 495 - return ioutil.WriteFile(cueFile, b, 0644) 494 494 + return os.WriteFile(cueFile, b, 0644) 496 495 } 497 496 498 497 type hoister struct {

+1 -2

cmd/cue/cmd/script_test.go

reviewed

··· 20 20 "context" 21 21 "fmt" 22 22 "io/fs" 23 23 - "io/ioutil" 24 23 "os" 25 24 "path" 26 25 "path/filepath" ··· 142 141 for _, f := range a.Files { 143 142 name := filepath.Join(tmpdir, f.Name) 144 143 check(os.MkdirAll(filepath.Dir(name), 0777)) 145 145 - check(ioutil.WriteFile(name, f.Data, 0666)) 144 144 + check(os.WriteFile(name, f.Data, 0666)) 146 145 } 147 146 148 147 cwd, err := os.Getwd()

+1 -2

cmd/cue/cmd/trim.go

reviewed

··· 17 17 import ( 18 18 "errors" 19 19 "fmt" 20 20 - "io/ioutil" 21 20 "os" 22 21 23 22 "github.com/spf13/cobra" ··· 171 170 filename = dst 172 171 } 173 172 174 174 - err = ioutil.WriteFile(filename, b, 0644) 173 173 + err = os.WriteFile(filename, b, 0644) 175 174 if err != nil { 176 175 return err 177 176 }

+4 -4

cue/format/format_test.go

reviewed

··· 19 19 import ( 20 20 "bytes" 21 21 "fmt" 22 22 - "io/ioutil" 22 22 + "os" 23 23 "path/filepath" 24 24 "testing" 25 25 "time" ··· 119 119 } 120 120 121 121 func runcheck(t *testing.T, source, golden string, mode checkMode) { 122 122 - src, err := ioutil.ReadFile(source) 122 122 + src, err := os.ReadFile(source) 123 123 if err != nil { 124 124 t.Error(err) 125 125 return ··· 135 135 136 136 // update golden files if necessary 137 137 if cuetest.UpdateGoldenFiles { 138 138 - if err := ioutil.WriteFile(golden, res, 0644); err != nil { 138 138 + if err := os.WriteFile(golden, res, 0644); err != nil { 139 139 t.Error(err) 140 140 } 141 141 return 142 142 } 143 143 144 144 // get golden 145 145 - gld, err := ioutil.ReadFile(golden) 145 145 + gld, err := os.ReadFile(golden) 146 146 if err != nil { 147 147 t.Error(err) 148 148 return

+2 -2

cue/load/match.go

reviewed

··· 15 15 package load 16 16 17 17 import ( 18 18 - "io/ioutil" 18 18 + "io" 19 19 "path/filepath" 20 20 "regexp" 21 21 "strings" ··· 64 64 } 65 65 66 66 if file.Filename == "-" { 67 67 - b, err2 := ioutil.ReadAll(cfg.stdin()) 67 67 + b, err2 := io.ReadAll(cfg.stdin()) 68 68 if err2 != nil { 69 69 err = errors.Newf(token.NoPos, "read stdin: %v", err) 70 70 return

+2 -2

cue/load/read.go

reviewed

··· 208 208 r.readString(imports) 209 209 } 210 210 211 211 - // readComments is like ioutil.ReadAll, except that it only reads the leading 211 211 + // readComments is like io.ReadAll, except that it only reads the leading 212 212 // block of comments in the file. 213 213 func readComments(f io.Reader) ([]byte, errors.Error) { 214 214 r := &importReader{b: bufio.NewReader(f)} ··· 220 220 return r.buf, r.err 221 221 } 222 222 223 223 - // readImports is like ioutil.ReadAll, except that it expects a CUE file as 223 223 + // readImports is like io.ReadAll, except that it expects a CUE file as 224 224 // input and stops reading the input once the imports have completed. 225 225 func readImports(f io.Reader, reportSyntaxError bool, imports *[]string) ([]byte, errors.Error) { 226 226 r := &importReader{b: bufio.NewReader(f)}

+2 -3

cue/load/registry.go

reviewed

··· 3 3 import ( 4 4 "fmt" 5 5 "io" 6 6 - "io/ioutil" 7 6 "net/http" 8 7 "os" 9 8 "path" ··· 61 60 return nil, err 62 61 } 63 62 defer resp.Body.Close() 64 64 - body, err := ioutil.ReadAll(resp.Body) 63 63 + body, err := io.ReadAll(resp.Body) 65 64 if err != nil { 66 65 return nil, fmt.Errorf("cannot get HTTP response body: %v", err) 67 66 } ··· 85 84 } 86 85 defer resp.Body.Close() 87 86 if resp.StatusCode != http.StatusOK { 88 88 - body, _ := ioutil.ReadAll(resp.Body) 87 87 + body, _ := io.ReadAll(resp.Body) 89 88 return "", fmt.Errorf("module.cue HTTP GET request failed: %s", body) 90 89 } 91 90 zipfile := filepath.Join(c.cacheDir, m.String()+".zip")

+2 -2

cue/parser/performance_test.go

reviewed

··· 15 15 package parser 16 16 17 17 import ( 18 18 - "io/ioutil" 18 18 + "os" 19 19 "testing" 20 20 ) 21 21 22 22 var src = readFile("testdata/commas.src") 23 23 24 24 func readFile(filename string) []byte { 25 25 - data, err := ioutil.ReadFile(filename) 25 25 + data, err := os.ReadFile(filename) 26 26 if err != nil { 27 27 panic(err) 28 28 }

+1 -2

cue/scanner/scanner_test.go

reviewed

··· 16 16 17 17 import ( 18 18 "fmt" 19 19 - "io/ioutil" 20 19 "os" 21 20 "path/filepath" 22 21 "runtime" ··· 894 893 func BenchmarkScanFile(b *testing.B) { 895 894 b.StopTimer() 896 895 const filename = "go" 897 897 - src, err := ioutil.ReadFile(filename) 896 896 + src, err := os.ReadFile(filename) 898 897 if err != nil { 899 898 panic(err) 900 899 }

+2 -1

cue/testdata/benchmarks/bench_test.go

reviewed

··· 16 16 17 17 import ( 18 18 "io/ioutil" 19 19 + "os" 19 20 "path/filepath" 20 21 "testing" 21 22 ··· 79 80 80 81 a.Files[statsPos].Data = []byte(ctx.Stats().String() + "\n\n") 81 82 82 82 - ioutil.WriteFile(name, txtar.Format(a), fi.Mode()) 83 83 + os.WriteFile(name, txtar.Format(a), fi.Mode()) 83 84 } 84 85 85 86 b.Run(name, func(b *testing.B) {

+1 -2

cue/testdata/gen.go

reviewed

··· 21 21 "go/ast" 22 22 "go/constant" 23 23 "go/format" 24 24 - "io/ioutil" 25 24 "log" 26 25 "os" 27 26 "path/filepath" ··· 269 268 name = strings.ReplaceAll(name, " ", "_") 270 269 name = strings.ReplaceAll(name, ":", "_") 271 270 filename := filepath.Join(e.dir, name+".txtar") 272 272 - err := ioutil.WriteFile(filename, txtar.Format(e.a), 0644) 271 271 + err := os.WriteFile(filename, txtar.Format(e.a), 0644) 273 272 if err != nil { 274 273 e.fatalf("Could not write file: %v", err) 275 274 }

+2 -2

cue/types_test.go

reviewed

··· 17 17 import ( 18 18 "bytes" 19 19 "fmt" 20 20 - "io/ioutil" 20 20 + "io" 21 21 "math" 22 22 "math/big" 23 23 "reflect" ··· 610 610 611 611 r, err := getInstance(t, tc.value).Value().Reader() 612 612 checkFatal(t, err, tc.err, "init") 613 613 - b, _ = ioutil.ReadAll(r) 613 613 + b, _ = io.ReadAll(r) 614 614 if got := string(b); got != tc.str { 615 615 t.Errorf("Reader: got %q; want %q", got, tc.str) 616 616 }

+8 -8

doc/tutorial/kubernetes/tut_test.go

reviewed

··· 53 53 } 54 54 55 55 // Read the tutorial. 56 56 - b, err := ioutil.ReadFile("README.md") 56 56 + b, err := os.ReadFile("README.md") 57 57 if err != nil { 58 58 t.Fatal(err) 59 59 } ··· 175 175 repl := c.Bytes() 176 176 c.Next(" ", ".cue") 177 177 file := c.Text() + ".cue" 178 178 - b, err := ioutil.ReadFile(file) 178 178 + b, err := os.ReadFile(file) 179 179 if err != nil { 180 180 t.Fatal(err) 181 181 } 182 182 b = re.ReplaceAll(b, repl) 183 183 - err = ioutil.WriteFile(file, b, 0644) 183 183 + err = os.WriteFile(file, b, 0644) 184 184 if err != nil { 185 185 t.Fatal(err) 186 186 } ··· 188 188 case strings.HasPrefix(cmd, "touch "): 189 189 logf(t, "$ %s", cmd) 190 190 file := strings.TrimSpace(cmd[len("touch "):]) 191 191 - err := ioutil.WriteFile(file, []byte(""), 0644) 191 191 + err := os.WriteFile(file, []byte(""), 0644) 192 192 if err != nil { 193 193 t.Fatal(err) 194 194 } ··· 247 247 if filepath.Ext(path) != ".cue" { 248 248 return nil 249 249 } 250 250 - b1, err := ioutil.ReadFile(path) 250 250 + b1, err := os.ReadFile(path) 251 251 if err != nil { 252 252 t.Fatal(err) 253 253 } 254 254 - b2, err := ioutil.ReadFile(path[len(dir)+1:]) 254 254 + b2, err := os.ReadFile(path[len(dir)+1:]) 255 255 if err != nil { 256 256 t.Fatal(err) 257 257 } ··· 295 295 testfile := filepath.Join("testdata", dir+".out") 296 296 297 297 if cuetest.UpdateGoldenFiles { 298 298 - err := ioutil.WriteFile(testfile, got, 0644) 298 298 + err := os.WriteFile(testfile, got, 0644) 299 299 if err != nil { 300 300 t.Fatal(err) 301 301 } 302 302 return 303 303 } 304 304 305 305 - b, err := ioutil.ReadFile(testfile) 305 305 + b, err := os.ReadFile(testfile) 306 306 if err != nil { 307 307 t.Fatal(err) 308 308 }

+2 -2

encoding/gocode/generator_test.go

reviewed

··· 66 66 67 67 goFile := filepath.Join("testdata", d.Name(), "cue_gen.go") 68 68 if cuetest.UpdateGoldenFiles { 69 69 - _ = ioutil.WriteFile(goFile, b, 0644) 69 69 + _ = os.WriteFile(goFile, b, 0644) 70 70 return 71 71 } 72 72 73 73 - want, err := ioutil.ReadFile(goFile) 73 73 + want, err := os.ReadFile(goFile) 74 74 if err != nil { 75 75 t.Fatal(err) 76 76 }

+2 -2

encoding/jsonschema/decode_test.go

reviewed

··· 17 17 import ( 18 18 "bytes" 19 19 "io/fs" 20 20 - "io/ioutil" 20 20 + "os" 21 21 "path" 22 22 "path/filepath" 23 23 "strings" ··· 141 141 142 142 if updated { 143 143 b := txtar.Format(a) 144 144 - err = ioutil.WriteFile(fullpath, b, 0644) 144 144 + err = os.WriteFile(fullpath, b, 0644) 145 145 if err != nil { 146 146 t.Fatal(err) 147 147 }

+2 -2

encoding/openapi/decode_test.go

reviewed

··· 17 17 import ( 18 18 "bytes" 19 19 "io/fs" 20 20 - "io/ioutil" 20 20 + "os" 21 21 "path" 22 22 "path/filepath" 23 23 "strings" ··· 110 110 if cuetest.UpdateGoldenFiles { 111 111 a.Files[outIndex].Data = b 112 112 b = txtar.Format(a) 113 113 - err = ioutil.WriteFile(fullpath, b, 0644) 113 113 + err = os.WriteFile(fullpath, b, 0644) 114 114 if err != nil { 115 115 t.Fatal(err) 116 116 }

+3 -3

encoding/openapi/openapi_test.go

reviewed

··· 17 17 import ( 18 18 "bytes" 19 19 "encoding/json" 20 20 - "io/ioutil" 20 20 + "os" 21 21 "path/filepath" 22 22 "strings" 23 23 "testing" ··· 251 251 252 252 wantFile := filepath.Join("testdata", tc.out) 253 253 if cuetest.UpdateGoldenFiles { 254 254 - _ = ioutil.WriteFile(wantFile, out.Bytes(), 0644) 254 254 + _ = os.WriteFile(wantFile, out.Bytes(), 0644) 255 255 return 256 256 } 257 257 258 258 - b, err = ioutil.ReadFile(wantFile) 258 258 + b, err = os.ReadFile(wantFile) 259 259 if err != nil { 260 260 t.Fatal(err) 261 261 }

+4 -5

encoding/protobuf/protobuf_test.go

reviewed

··· 18 18 "bytes" 19 19 "fmt" 20 20 "io/fs" 21 21 - "io/ioutil" 22 21 "os" 23 22 "path/filepath" 24 23 "strings" ··· 58 57 59 58 wantFile := filepath.Join("testdata", filepath.Base(file)+".out.cue") 60 59 if cuetest.UpdateGoldenFiles { 61 61 - _ = ioutil.WriteFile(wantFile, out.Bytes(), 0644) 60 60 + _ = os.WriteFile(wantFile, out.Bytes(), 0644) 62 61 return 63 62 } 64 63 65 65 - b, err := ioutil.ReadFile(wantFile) 64 64 + b, err := os.ReadFile(wantFile) 66 65 if err != nil { 67 66 t.Fatal(err) 68 67 } ··· 104 103 t.Fatal(err) 105 104 } 106 105 _ = os.MkdirAll(filepath.Dir(f.Filename), 0755) 107 107 - err = ioutil.WriteFile(f.Filename, b, 0644) 106 106 + err = os.WriteFile(f.Filename, b, 0644) 108 107 if err != nil { 109 108 t.Fatal(err) 110 109 } ··· 139 138 t.Fatal(err) 140 139 } 141 140 142 142 - want, err := ioutil.ReadFile(path) 141 141 + want, err := os.ReadFile(path) 143 142 if err != nil { 144 143 t.Fatal(err) 145 144 }

+1 -2

internal/cuetxtar/txtar.go

reviewed

··· 20 20 "fmt" 21 21 "io" 22 22 "io/fs" 23 23 - "io/ioutil" 24 23 "os" 25 24 "path" 26 25 "path/filepath" ··· 418 417 a.Files = files 419 418 420 419 if update { 421 421 - err = ioutil.WriteFile(fullpath, txtar.Format(a), 0644) 420 420 + err = os.WriteFile(fullpath, txtar.Format(a), 0644) 422 421 if err != nil { 423 422 t.Fatal(err) 424 423 }

+1 -2

internal/encoding/encoder.go

reviewed

··· 19 19 "encoding/json" 20 20 "fmt" 21 21 "io" 22 22 - "io/ioutil" 23 22 "os" 24 23 "path/filepath" 25 24 ··· 311 310 // prevent clobbering the file in case of a crash. 312 311 b := &bytes.Buffer{} 313 312 fn := func() error { 314 314 - return ioutil.WriteFile(path, b.Bytes(), 0644) 313 313 + return os.WriteFile(path, b.Bytes(), 0644) 315 314 } 316 315 return b, fn, nil 317 316 }

+8 -9

internal/encoding/encoding.go

reviewed

··· 21 21 "bytes" 22 22 "fmt" 23 23 "io" 24 24 - "io/ioutil" 25 24 "net/url" 26 25 "os" 27 26 "strings" ··· 182 181 183 182 if file, ok := f.Source.(*ast.File); ok { 184 183 i.file = file 185 185 - i.closer = ioutil.NopCloser(strings.NewReader("")) 184 184 + i.closer = io.NopCloser(strings.NewReader("")) 186 185 i.validate(file, f) 187 186 return i 188 187 } ··· 250 249 i.next = d.Decode 251 250 i.Next() 252 251 case build.Text: 253 253 - b, err := ioutil.ReadAll(r) 252 252 + b, err := io.ReadAll(r) 254 253 i.err = err 255 254 i.expr = ast.NewString(string(b)) 256 255 case build.Binary: 257 257 - b, err := ioutil.ReadAll(r) 256 256 + b, err := io.ReadAll(r) 258 257 i.err = err 259 258 s := literal.Bytes.WithTabIndent(1).Quote(string(b)) 260 259 i.expr = ast.NewLit(token.STRING, s) ··· 265 264 } 266 265 i.file, i.err = protobuf.Extract(path, r, paths) 267 266 case build.TextProto: 268 268 - b, err := ioutil.ReadAll(r) 267 267 + b, err := io.ReadAll(r) 269 268 i.err = err 270 269 if err == nil { 271 270 d := textproto.NewDecoder() ··· 330 329 case nil: 331 330 // Use the file name. 332 331 case string: 333 333 - return ioutil.NopCloser(strings.NewReader(s)), nil 332 332 + return io.NopCloser(strings.NewReader(s)), nil 334 333 case []byte: 335 335 - return ioutil.NopCloser(bytes.NewReader(s)), nil 334 334 + return io.NopCloser(bytes.NewReader(s)), nil 336 335 case *bytes.Buffer: 337 336 // is io.Reader, but it needs to be readable repeatedly 338 337 if s != nil { 339 339 - return ioutil.NopCloser(bytes.NewReader(s.Bytes())), nil 338 338 + return io.NopCloser(bytes.NewReader(s.Bytes())), nil 340 339 } 341 340 default: 342 341 return nil, fmt.Errorf("invalid source type %T", f.Source) 343 342 } 344 343 // TODO: should we allow this? 345 344 if f.Filename == "-" { 346 346 - return ioutil.NopCloser(stdin), nil 345 345 + return io.NopCloser(stdin), nil 347 346 } 348 347 return os.Open(f.Filename) 349 348 }

+1 -2

internal/filetypes/gen.go

reviewed

··· 17 17 package main 18 18 19 19 import ( 20 20 - "io/ioutil" 21 20 "log" 22 21 "os" 23 22 ··· 46 45 log.Fatal(err) 47 46 } 48 47 49 49 - if err := ioutil.WriteFile("types.go", b, 0644); err != nil { 48 48 + if err := os.WriteFile("types.go", b, 0644); err != nil { 50 49 log.Fatal(err) 51 50 } 52 51 }

+2 -2

internal/source/source.go

reviewed

··· 20 20 "bytes" 21 21 "fmt" 22 22 "io" 23 23 - "io/ioutil" 23 23 + "os" 24 24 ) 25 25 26 26 // Read loads the source bytes for the given arguments. If src != nil, ··· 48 48 } 49 49 return nil, fmt.Errorf("invalid source type %T", src) 50 50 } 51 51 - return ioutil.ReadFile(filename) 51 51 + return os.ReadFile(filename) 52 52 }

+2 -2

internal/third_party/yaml/decode.go

reviewed

··· 6 6 "errors" 7 7 "fmt" 8 8 "io" 9 9 - "io/ioutil" 10 9 "math" 10 10 + "os" 11 11 "reflect" 12 12 "strconv" 13 13 "strings" ··· 73 73 } 74 74 return nil, errors.New("invalid source") 75 75 } 76 76 - return ioutil.ReadFile(filename) 76 76 + return os.ReadFile(filename) 77 77 } 78 78 79 79 func newParser(filename string, src interface{}) (*parser, error) {

+5 -5

internal/third_party/yaml/decode_test.go

reviewed

··· 4 4 "errors" 5 5 "fmt" 6 6 "io" 7 7 - "io/ioutil" 7 7 + "os" 8 8 "strconv" 9 9 "strings" 10 10 "testing" ··· 916 916 t.Run(test, func(t *testing.T) { 917 917 testname := fmt.Sprintf("testdata/%s.test", test) 918 918 filename := fmt.Sprintf("testdata/%s.out", test) 919 919 - mergeTests, err := ioutil.ReadFile(testname) 919 919 + mergeTests, err := os.ReadFile(testname) 920 920 if err != nil { 921 921 t.Fatal(err) 922 922 } ··· 926 926 } 927 927 got := cueStr(expr) 928 928 if cuetest.UpdateGoldenFiles { 929 929 - ioutil.WriteFile(filename, []byte(got), 0644) 929 929 + os.WriteFile(filename, []byte(got), 0644) 930 930 return 931 931 } 932 932 - b, err := ioutil.ReadFile(filename) 932 932 + b, err := os.ReadFile(filename) 933 933 if err != nil { 934 934 t.Fatal(err) 935 935 } ··· 971 971 //var data []byte 972 972 //func init() { 973 973 // var err error 974 974 - // data, err = ioutil.ReadFile("/tmp/file.yaml") 974 974 + // data, err = os.ReadFile("/tmp/file.yaml") 975 975 // if err != nil { 976 976 // panic(err) 977 977 // }

+1 -2

pkg/gen.go

reviewed

··· 35 35 "go/parser" 36 36 "go/printer" 37 37 "go/token" 38 38 - "io/ioutil" 39 38 "log" 40 39 "math/big" 41 40 "os" ··· 181 180 182 181 filename := filepath.Join(pkg.Dir, genFile) 183 182 184 184 - if err := ioutil.WriteFile(filename, b, 0666); err != nil { 183 183 + if err := os.WriteFile(filename, b, 0666); err != nil { 185 184 return err 186 185 } 187 186 return nil

+1 -2

pkg/path/path_windows_test.go

reviewed

··· 21 21 import ( 22 22 "flag" 23 23 "fmt" 24 24 - "io/ioutil" 25 24 goos "os" 26 25 "os/exec" 27 26 "reflect" ··· 69 68 return 70 69 } 71 70 fn, data := Join([]string{dd, cmdfile}, Windows), []byte("@echo "+d+"\r\n") 72 72 - if err := ioutil.WriteFile(fn, data, perm); err != nil { 71 71 + if err := goos.WriteFile(fn, data, perm); err != nil { 73 72 t.Errorf("%d,%d: WriteFile(%#q) failed: %v", ti, i, fn, err) 74 73 return 75 74 }

+1 -2

pkg/qgo.go

reviewed

··· 28 28 "go/token" 29 29 "go/types" 30 30 "io" 31 31 - "io/ioutil" 32 31 "log" 33 32 "os" 34 33 "path/filepath" ··· 156 155 if err != nil { 157 156 log.Fatal(err) 158 157 } 159 159 - err = ioutil.WriteFile(lastPkg+".go", b, 0644) 158 158 + err = os.WriteFile(lastPkg+".go", b, 0644) 160 159 if err != nil { 161 160 log.Fatal(err) 162 161 }

+2 -3

pkg/tool/file/file.go

reviewed

··· 15 15 package file 16 16 17 17 import ( 18 18 - "io/ioutil" 19 18 "os" 20 19 "path/filepath" 21 20 ··· 56 55 return nil, ctx.Err 57 56 } 58 57 59 59 - b, err := ioutil.ReadFile(filename) 58 58 + b, err := os.ReadFile(filename) 60 59 if err != nil { 61 60 return nil, err 62 61 } ··· 103 102 return nil, ctx.Err 104 103 } 105 104 106 106 - return nil, ioutil.WriteFile(filename, b, os.FileMode(mode)) 105 105 + return nil, os.WriteFile(filename, b, os.FileMode(mode)) 107 106 } 108 107 109 108 func (c *cmdGlob) Run(ctx *task.Context) (res interface{}, err error) {

+2 -2

pkg/tool/file/file_test.go

reviewed

··· 87 87 t.Fatal(err) 88 88 } 89 89 90 90 - b, err := ioutil.ReadFile(name) 90 90 + b, err := os.ReadFile(name) 91 91 if err != nil { 92 92 t.Fatal(err) 93 93 } ··· 116 116 t.Fatal(err) 117 117 } 118 118 119 119 - b, err := ioutil.ReadFile(name) 119 119 + b, err := os.ReadFile(name) 120 120 if err != nil { 121 121 t.Fatal(err) 122 122 }

+1 -2

pkg/tool/http/http.go

reviewed

··· 20 20 "crypto/x509" 21 21 "encoding/pem" 22 22 "io" 23 23 - "io/ioutil" 24 23 "net/http" 25 24 26 25 "cuelang.org/go/cue" ··· 130 129 return nil, err 131 130 } 132 131 defer resp.Body.Close() 133 133 - b, err := ioutil.ReadAll(resp.Body) 132 132 + b, err := io.ReadAll(resp.Body) 134 133 // parse response body and headers 135 134 return map[string]interface{}{ 136 135 "response": map[string]interface{}{