Merge branch 'master' into v3

Add global "method:" option to allow setting a default for all tasks. Change default from "timestamp" to "checksum"

.editorconfig

@@ -7,6 +7,7 @@ insert_final_newline = true
 charset = utf-8
 trim_trailing_whitespace = true
 indent_style = tab
+indent_size = 8
 
 [*.{md,yml,yaml,json,toml,htm,html}]
 indent_style = space

.github/FUNDING.yml

@@ -1,2 +1 @@
 open_collective: task
-patreon: andreynering

.github/workflows/test.yml

@@ -1,30 +1,59 @@
 name: Test
-on: [push, pull_request]
+on: [push]
 jobs:
-  test:
-    name: Test
-    strategy:
-      matrix:
-        go-version: [1.12.x, 1.13.x]
-        platform: [ubuntu-latest, macos-latest, windows-latest]
-    runs-on: ${{matrix.platform}}
+  linux:
+    name: Linux
+    runs-on: ubuntu-latest
     steps:
-      - name: Set up Go ${{matrix.go-version}}
+      - name: Set up Go 1.13
         uses: actions/setup-go@v1
         with:
-          go-version: ${{matrix.go-version}}
+          go-version: 1.13
         id: go
 
       - name: Check out code into the Go module directory
         uses: actions/checkout@v1
 
-      - name: Download Go modules
-        run: go mod download
-        env:
-          GOPROXY: https://proxy.golang.org
-
       - name: Build
-        run: go build -o ./bin/task -v ./cmd/task
+        run: go build -o ./task -v ./cmd/task
 
       - name: Test
-        run: ./bin/task test
+        run: ./task test
+
+  windows:
+    name: Windows
+    runs-on: windows-latest
+    steps:
+      - name: Set up Go 1.13
+        uses: actions/setup-go@v1
+        with:
+          go-version: 1.13
+        id: go
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v1
+
+      - name: Build
+        run: go install -v ./cmd/task
+
+      - name: Test
+        run: go test -v ./...
+
+  macos:
+    name: MacOS
+    runs-on: macOS-latest
+    steps:
+      - name: Set up Go 1.13
+        uses: actions/setup-go@v1
+        with:
+          go-version: 1.13
+        id: go
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v1
+
+      - name: Build
+        run: go build -o ./task -v ./cmd/task
+
+      - name: Test
+        run: ./task test

.gitignore

@@ -26,3 +26,4 @@ dist/
 tags
 
 /bin
+/testdata/vars/v1

.travis.yml

@@ -4,9 +4,6 @@ go:
   - 1.12.x
   - 1.13.x
 
-env:
-  - GO111MODULE=on
-
 addons:
   apt:
     packages:
@@ -15,3 +12,11 @@ addons:
 script:
   - go install -v ./cmd/task
   - task ci
+
+deploy:
+  - provider: script
+    skip_cleanup: true
+    script: curl -sL http://git.io/goreleaser | bash
+    on:
+      tags: true
+      condition: $TRAVIS_OS_NAME = linux

CHANGELOG.md

@@ -1,19 +1,31 @@
 # Changelog
 
-## v2.8.0 - 2019-12-07
+# v3.0.0 - Preview 2
 
-- Add `--parallel` flag (alias `-p`) to run tasks given by the command line in
-  parallel
-  ([#266](https://github.com/go-task/task/pull/266)).
-- Fixed bug where calling the `task` CLI only informing global vars would not
-  execute the `default` task.
-- Add hability to silent all tasks by adding `silent: true` a the root of the
-  Taskfile.
+- Taskfiles in version 1 are not supported anymore
+  ([#237](https://github.com/go-task/task/pull/237)).
+- Added global `method:` option. With this option, you can set a default
+  method to all tasks in a Taskfile
+  ([#246](https://github.com/go-task/task/issues/246)).
+- Changed default method from `timestamp` to `checksum`
+  ([#246](https://github.com/go-task/task/issues/246)).
+- New magic variables are now available when using `status:`:
+  `.TIMESTAMP` which contains the greatest modification date
+  from the files listed in `sources:`, and `.CHECKSUM`, which
+  contains a checksum of all files listed in `status:`.
+  This is useful for manual checking when using external, or even remote,
+  artifacts when using `status:`
+  ([#216](https://github.com/go-task/task/pull/216)).
 
-## v2.7.1 - 2019-11-10
+## v3.0.0 - Preview 1
 
-- Fix error being raised when `exit 0` was called
-  ([#251](https://github.com/go-task/task/issues/251)).
+- We're now using [slim-sprig](https://github.com/go-task/slim-sprig) instead of
+  [sprig](https://github.com/Masterminds/sprig), which allowed a file size
+  reduction of about 22%
+  ([#219](https://github.com/go-task/task/pull/219)).
+- We now use some colors on Task output to better distinguish message types -
+  commands are green, errors are red, etc
+  ([#207](https://github.com/go-task/task/pull/207)).
 
 ## v2.7.0 - 2019-09-22
 

Taskfile.yml

@@ -1,6 +1,4 @@
-version: '2'
-
-# silent: true
+version: '3'
 
 includes:
   docs: ./docs

cmd/task/task.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/go-task/task/v2"
 	"github.com/go-task/task/v2/internal/args"
+	"github.com/go-task/task/v2/internal/logger"
 
 	"github.com/spf13/pflag"
 )
@@ -27,12 +28,14 @@ Example: 'task hello' with the following 'Taskfile.yml' file will generate an
 'output.txt' file with the content "hello".
 
 '''
-hello:
-  cmds:
-    - echo "I am going to write a file named 'output.txt' now."
-    - echo "hello" > output.txt
-  generates:
-    - output.txt
+version: '3'
+tasks:
+  hello:
+    cmds:
+      - echo "I am going to write a file named 'output.txt' now."
+      - echo "hello" > output.txt
+    generates:
+      - output.txt
 '''
 
 Options:
@@ -58,10 +61,10 @@ func main() {
 		silent      bool
 		dry         bool
 		summary     bool
-		parallel    bool
 		dir         string
 		entrypoint  string
 		output      string
+		color       bool
 	)
 
 	pflag.BoolVar(&versionFlag, "version", false, "show Task version")
@@ -72,12 +75,12 @@ func main() {
 	pflag.BoolVarP(&watch, "watch", "w", false, "enables watch of the given task")
 	pflag.BoolVarP(&verbose, "verbose", "v", false, "enables verbose mode")
 	pflag.BoolVarP(&silent, "silent", "s", false, "disables echoing")
-	pflag.BoolVarP(&parallel, "parallel", "p", false, "executes tasks provided on command line in parallel")
 	pflag.BoolVar(&dry, "dry", false, "compiles and prints tasks in the order that they would be run, without executing them")
 	pflag.BoolVar(&summary, "summary", false, "show summary about a task")
 	pflag.StringVarP(&dir, "dir", "d", "", "sets directory of execution")
 	pflag.StringVarP(&entrypoint, "taskfile", "t", "", `choose which Taskfile to run. Defaults to "Taskfile.yml"`)
 	pflag.StringVarP(&output, "output", "o", "", "sets output style: [interleaved|group|prefixed]")
+	pflag.BoolVarP(&color, "color", "c", true, "colored output")
 	pflag.Parse()
 
 	if versionFlag {
@@ -116,7 +119,7 @@ func main() {
 		Dry:        dry,
 		Entrypoint: entrypoint,
 		Summary:    summary,
-		Parallel:   parallel,
+		Color:      color,
 
 		Stdin:  os.Stdin,
 		Stdout: os.Stdout,
@@ -133,7 +136,13 @@ func main() {
 		return
 	}
 
-	calls, globals := args.Parse(pflag.Args()...)
+	arguments := pflag.Args()
+	if len(arguments) == 0 {
+		e.Logger.Errf(logger.Yellow, "task: No argument given, trying default task")
+		arguments = []string{"default"}
+	}
+
+	calls, globals := args.Parse(arguments...)
 	for name, value := range globals {
 		e.Taskfile.Vars[name] = value
 	}
@@ -151,7 +160,8 @@ func main() {
 	}
 
 	if err := e.Run(ctx, calls...); err != nil {
-		log.Fatal(err)
+		e.Logger.Errf(logger.Red, "%v", err)
+		os.Exit(1)
 	}
 }
 

completion/bash/task.bash

@@ -1,21 +0,0 @@
-_task_completion()
-{
-  local scripts;
-  local curr_arg;
-
-  # Remove colon from word breaks
-  COMP_WORDBREAKS=${COMP_WORDBREAKS//:}
-
-  scripts=$(task -l | sed '1d' | sed 's/^\* //' | awk '{ print $1 }');
-
-  curr_arg="${COMP_WORDS[COMP_CWORD]:-"."}"
-
-  # Do not accept more than 1 argument
-  if [ "${#COMP_WORDS[@]}" != "2" ]; then
-    return
-  fi
-
-  COMPREPLY=($(compgen -c | echo "$scripts" | grep $curr_arg));
-}
-
-complete -F _task_completion task

docs/Taskfile.yml

@@ -1,4 +1,4 @@
-version: '2'
+version: '3'
 
 tasks:
   install:

docs/_sidebar.md

@@ -1,6 +1,5 @@
 - [Installation](installation.md)
 - [Usage](usage.md)
-- [Styleguide](styleguide.md)
 - [Taskfile Versions](taskfile_versions.md)
 - [Examples](examples.md)
 - [Releasing Task](releasing_task.md)

docs/installation.md

@@ -43,13 +43,18 @@ may take some time until it's available on Scoop.
 ## Go
 
 Task now uses [Go Modules](https://github.com/golang/go/wiki/Modules), which
-means you may have trouble compiling it on older Go versions or using
-`$GOPATH`.
+means you may have trouble compiling it on older Go versions.
 
 For CI environments we recommend using the [Install Script](#install-script)
 instead, which is faster and more stable, since it'll just download the latest
 released binary, instead of compiling the edge (master branch) version.
 
+Installing in your `$GOPATH`:
+
+```bash
+go get -u -v github.com/go-task/task/cmd/task
+```
+
 Installing in another directory:
 
 ```bash
@@ -57,7 +62,7 @@ git clone https://github.com/go-task/task
 cd task
 
 # compiling binary to $GOPATH/bin
-go install -v ./cmd/task
+go install -v
 
 # compiling it to another location
 # use -o ./task.exe on Windows
@@ -78,19 +83,6 @@ curl -sL https://taskfile.dev/install.sh | sh
 
 > This method will download the binary on the local `./bin` directory by default.
 
-## GitHub Actions
-
-If you want to install Task in GitHub Actions you can try using
-[this action](https://github.com/arduino/actions/tree/master/setup-taskfile)
-by the Arduino team:
-
-```yaml
-- name: Install Task
-  uses: Arduino/actions/setup-taskfile@master
-```
-
-This installation method is community owned.
-
 [go]: https://golang.org/
 [snapcraft]: https://snapcraft.io/
 [homebrew]: https://brew.sh/

docs/styleguide.md

@@ -1,213 +0,0 @@
-# Styleguide
-
-This is the official Task styleguide for `Taskfile.yml` files. This guide
-contains some basic instructions to keep your Taskfile clean and familiar to
-other users.
-
-This contains general guidelines, but don't necessarely need to be strictly
-followed. Feel free to disagree and proceed differently in some point if you
-need or want to. Also, feel free to open issues or pull requests with
-improvements to this guide.
-
-## Use `Taskfile.yml` and not `taskfile.yml`
-
-```yaml
-# bad
-taskfile.yml
-
-
-# good
-Taskfile.yml
-```
-
-This is important especially for Linux users. Windows and macOS have case
-insensitive filesystems, so `taskfile.yml` will end up working, even that not
-officially supported. On Linux, only `Taskfile.yml` will work, though.
-
-## Use the correct order of keywords
-
-- `version:`
-- `includes:`
-- Configuration ones, like `output:`, `expansions:` or `silent:`
-- `vars:`
-- `env:`
-- `tasks:`
-
-## Use 2 spaces for indentation
-
-This is the most common convention for YAML files, and Task follows it.
-
-```yaml
-# bad
-tasks:
-    foo:
-        cmds:
-            - echo 'foo'
-
-
-# good
-tasks:
-  foo:
-    cmds:
-      - echo 'foo'
-```
-
-## Separate with spaces the mains sections
-
-```yaml
-# bad
-version: 2
-includes:
-  docker: ./docker/Taskfile.yml
-output: prefixed
-expansions: 3
-vars:
-  FOO: bar
-env:
-  BAR: baz
-tasks:
-  # ...
-
-
-# good
-version: 2
-
-includes:
-  docker: ./docker/Taskfile.yml
-
-output: prefixed
-expansions: 3
-
-vars:
-  FOO: bar
-
-env:
-  BAR: baz
-
-tasks:
-  # ...
-```
-
-## Add spaces between tasks
-
-```yaml
-# bad
-version: 2
-
-tasks:
-  foo:
-    cmds:
-      - echo 'foo'
-  bar:
-    cmds:
-      - echo 'bar'
-  baz:
-    cmds:
-      - echo 'baz'
-
-
-# good
-version: 2
-
-tasks:
-  foo:
-    cmds:
-      - echo 'foo'
-
-  bar:
-    cmds:
-      - echo 'bar'
-
-  baz:
-    cmds:
-      - echo 'baz'
-```
-
-## Use upper-case variable names
-
-```yaml
-# bad
-version: 2
-
-vars:
-  binary_name: myapp
-
-tasks:
-  build:
-    cmds:
-      - go build -o {{.binary_name}} .
-
-
-# good
-version: 2
-
-vars:
-  BINARY_NAME: myapp
-
-tasks:
-  build:
-    cmds:
-      - go build -o {{.BINARY_NAME}} .
-```
-
-## Don't wrap vars in spaces when templating
-
-```yaml
-# bad
-version: 2
-
-tasks:
-  greet:
-    cmds:
-      - echo '{{ .MESSAGE }}'
-
-
-# good
-version: 2
-
-tasks:
-  greet:
-    cmds:
-      - echo '{{.MESSAGE}}'
-```
-
-This convention is also used by most people for any Go templating.
-
-## Separate task name words with a dash
-
-```yaml
-# bad
-version: 2
-
-tasks:
-  do_something_fancy:
-    cmds:
-      - echo 'Do something'
-
-
-# good
-version: 2
-
-tasks:
-  do-something-fancy:
-    cmds:
-      - echo 'Do something'
-```
-
-## Use colon for task namespacing
-
-```yaml
-# good
-version: 2
-
-tasks:
-  docker:build:
-    cmds:
-      - docker ...
-
-  docker:run:
-    cmds:
-      - docker-compose ...
-```
-
-This is also done automatically when using included Taskfiles.

docs/taskfile_versions.md

@@ -15,6 +15,8 @@ available, but not `3.0.0+`.
 
 ## Version 1
 
+> NOTE: Taskfiles in version 1 are not supported on Task >= v3.0.0 anymore.
+
 In the first version of the `Taskfile`, the `version:` key was not available,
 because the tasks was in the root of the YAML document. Like this:
 

docs/usage.md

@@ -63,7 +63,7 @@ tasks:
       - echo $GREETING
 ```
 
-> NOTE: `env` supports expansion and retrieving output from a shell command
+> NOTE: `env` supports expansion and and retrieving output from a shell command
 > just like variables, as you can see on the [Variables](#variables) section.
 
 ## Operating System specific tasks
@@ -193,9 +193,6 @@ tasks:
 If there is more than one dependency, they always run in parallel for better
 performance.
 
-> You can also make the tasks given by the command line run in parallel by
-> using the `--parallel` flag (alias `-p`). Example: `task --parallel js css`.
-
 If you want to pass information to dependencies, you can do that the same
 manner as you would to [call another task](#calling-another-task):
 
@@ -269,6 +266,8 @@ The above syntax is also supported in `deps`.
 
 ## Prevent unnecessary work
 
+### By fingerprinting locally generated files and their sources
+
 If a task generates something, you can inform Task the source and generated
 files, so Task will prevent to run them if not necessary.
 
@@ -324,6 +323,8 @@ tasks:
 
 > TIP: method `none` skips any validation and always run the task.
 
+### Using programmatic checks to indicate a task is up to date.
+
 Alternatively, you can inform a sequence of tests as `status`. If no error
 is returned (exit status 0), the task is considered up-to-date:
 
@@ -343,15 +344,34 @@ tasks:
       - test -f directory/file2.txt
 ```
 
+Normally, you would use `sources` in combination with
+`generates` - but for tasks that generate remote artifacts (Docker images,
+deploys, CD releases) the checksum source and timestamps require either
+access to the artifact or for an out-of-band refresh of the `.checksum`
+fingerprint file.
+
+Two special variables `{{.CHECKSUM}}` and `{{.TIMESTAMP}}` are available
+for interpolation within `status` commands, depending on the method assigned
+to fingerprint the sources. Only `source` globs are fingerprinted.
+
+Note that the `{{.TIMESTAMP}}` variable is a "live" Go `time.Time` struct, and
+can be formatted using any of the methods that `time.Time` responds to.
+
+See [the Go Time documentation](https://golang.org/pkg/time/) for more information.
+
 You can use `--force` or `-f` if you want to force a task to run even when
 up-to-date.
 
 Also, `task --status [tasks]...` will exit with a non-zero exit code if any of
 the tasks are not up-to-date.
 
-If you need a certain set of conditions to be _true_ you can use the
-`preconditions` stanza.  `preconditions` are very similar to `status`
-lines except they support `sh` expansion and they SHOULD all return 0.
+### Using programmatic checks to cancel execution of an task and it's dependencies
+
+In addition to `status` checks, there are also `preconditions` checks, which are
+the logical inverse of `status` checks.  That is, if you need a certain set of
+conditions to be _true_ you can use the `preconditions` stanza.
+`preconditions` are similar to `status` lines except they support `sh`
+expansion and they SHOULD all return 0.
 
 ```yaml
 version: '2'
@@ -515,7 +535,7 @@ This works for all types of variables.
 Task parse commands as [Go's template engine][gotemplate] before executing
 them. Variables are accessible through dot syntax (`.VARNAME`).
 
-All functions by the Go's [sprig lib](http://masterminds.github.io/sprig/)
+All functions by the Go's [slim-sprig lib](https://go-task.github.io/slim-sprig/)
 are available. The following example gets the current date in a given format:
 
 ```yaml
@@ -674,7 +694,7 @@ With silent mode on, the below will be print instead:
 Print something
 ```
 
-There are four ways to enable silent mode:
+There's three ways to enable silent mode:
 
 * At command level:
 
@@ -700,19 +720,6 @@ tasks:
     silent: true
 ```
 
-* Globally at Taskfile level:
-
-```yaml
-version: '2'
-
-silent: true
-
-tasks:
-  echo:
-    cmds:
-      - echo "Print something"
-```
-
 * Or globally with `--silent` or `-s` flag
 
 If you want to suppress STDOUT instead, just redirect a command to `/dev/null`:

go.mod

@@ -1,20 +1,16 @@
 module github.com/go-task/task/v2
 
 require (
-	github.com/Masterminds/semver v1.4.2 // indirect
-	github.com/Masterminds/sprig v2.16.0+incompatible
-	github.com/aokoli/goutils v1.0.1 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/google/uuid v1.0.0 // indirect
-	github.com/huandu/xstrings v1.1.0 // indirect
-	github.com/imdario/mergo v0.3.6 // indirect
+	github.com/fatih/color v1.7.0
+	github.com/go-task/slim-sprig v0.0.0-20190623010546-24867827a98b
+	github.com/mattn/go-colorable v0.1.2 // indirect
 	github.com/mattn/go-zglob v0.0.1
 	github.com/radovskyb/watcher v1.0.5
 	github.com/spf13/pflag v1.0.3
-	github.com/stretchr/testify v1.4.0
-	golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e
-	gopkg.in/yaml.v2 v2.2.2
-	mvdan.cc/sh/v3 v3.0.0-beta1
+	github.com/stretchr/testify v1.3.0
+	golang.org/x/sync v0.0.0-20190423024810-112230192c58
+	gopkg.in/yaml.v2 v2.2.1
+	mvdan.cc/sh/v3 v3.0.0-alpha2.0.20190908210725-4a0ebd2f3c1b
 )
 
 go 1.13

go.sum

@@ -1,59 +1,50 @@
-github.com/Masterminds/semver v1.4.2 h1:WBLTQ37jOCzSLtXNdoo8bNM8876KhNqOKvrlGITgsTc=
-github.com/Masterminds/semver v1.4.2/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
-github.com/Masterminds/sprig v2.16.0+incompatible h1:QZbMUPxRQ50EKAq3LFMnxddMu88/EUUG3qmxwtDmPsY=
-github.com/Masterminds/sprig v2.16.0+incompatible/go.mod h1:y6hNFY5UBTIWBxnzTeuNhlNS5hqE0NB0E6fgfo2Br3o=
-github.com/aokoli/goutils v1.0.1 h1:7fpzNGoJ3VA8qcrm++XEE1QUe0mIwNeLa02Nwq7RDkg=
-github.com/aokoli/goutils v1.0.1/go.mod h1:SijmP0QR8LtwsmDs8Yii5Z/S4trXFGFC2oO5g9DP+DQ=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/google/uuid v1.0.0 h1:b4Gk+7WdP/d3HZH8EJsZpvV7EtDOgaZLtnaNGIu1adA=
-github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/huandu/xstrings v1.1.0 h1:9oZY6Z/H3A1gytJxzuicbmV5QoR8M1TAPcn9WTg7vqg=
-github.com/huandu/xstrings v1.1.0/go.mod h1:DvyZB1rfVYsBIigL8HwpZgxHwXozlTgGqn63UyNX5k4=
-github.com/imdario/mergo v0.3.6 h1:xTNEAn+kxVO7dTZGu0CegyqKZmoWFI0rF8UxjlB2d28=
-github.com/imdario/mergo v0.3.6/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
+github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
+github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
+github.com/go-task/slim-sprig v0.0.0-20190623010546-24867827a98b h1:z6iCP1USASmEZtKTzynd/rP4vOtBLlsD3v24wItbJIs=
+github.com/go-task/slim-sprig v0.0.0-20190623010546-24867827a98b/go.mod h1:XLIiFDBy2M8pA/fEL5rx9xr2EAzrDEO0S5brm5iekOE=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/mattn/go-colorable v0.1.2 h1:/bC9yWikZXAL9uJdulbSfyVNIR3n3trXl+v8+1sx8mU=
+github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-isatty v0.0.8 h1:HLtExJ+uU2HOZ+wI0Tt5DtUDrx8yhUqDcp7fYERX4CE=
+github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
 github.com/mattn/go-zglob v0.0.1 h1:xsEx/XUoVlI6yXjqBK062zYhRTZltCNmYPx6v+8DNaY=
 github.com/mattn/go-zglob v0.0.1/go.mod h1:9fxibJccNxU2cnpIKLRRFA7zX7qhkJIQWBb449FYHOo=
-github.com/pkg/diff v0.0.0-20190930165518-531926345625/go.mod h1:kFj35MyHn14a6pIgWhm46KVjJr5CHys3eEYxkuKD1EI=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/radovskyb/watcher v1.0.5 h1:wqt7gb+HjGacvFoLTKeT44C+XVPxu7bvHvKT1IvZ7rw=
 github.com/radovskyb/watcher v1.0.5/go.mod h1:78okwvY5wPdzcb1UYnip1pvrZNIVEIh/Cm+ZuvsUYIg=
-github.com/rogpeppe/go-internal v1.5.0/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
-github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v0.0.0-20180319223459-c679ae2cc0cb/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191002192127-34f69633bfdc h1:c0o/qxkaO2LF5t6fQrT4b5hzyggAkLLlCUjqfRxd8Q4=
-golang.org/x/crypto v0.0.0-20191002192127-34f69633bfdc/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4 h1:HuIa8hRrWRSrqYzx1qI49NNxhdi2PrY7gxVSq1JjLDc=
+golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191008105621-543471e840be h1:QAcqgptGM8IQBC9K/RC4o+O9YmqEm0diQn9QmZw/0mU=
-golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190712062909-fae7ac547cb7 h1:LepdCS8Gf/MVejFIt8lsiexZATdoGVyp5bcyS+rYoUI=
+golang.org/x/sys v0.0.0-20190712062909-fae7ac547cb7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbOeHJjicWYPqR9bpxqxYG2pA=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-mvdan.cc/editorconfig v0.1.1-0.20191109213504-890940e3f00e/go.mod h1:Ge4atmRUYqueGppvJ7JNrtqpqokoJEFxYbP0Z+WeKS8=
-mvdan.cc/sh/v3 v3.0.0-beta1 h1:UqiwBEXEPzelaGxuvixaOtzc7WzKtrElePJ8HqvW7K8=
-mvdan.cc/sh/v3 v3.0.0-beta1/go.mod h1:rBIndNJFYPp8xSppiZcGIk6B5d1g3OEARxEaXjPxwVI=
+gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+mvdan.cc/sh/v3 v3.0.0-alpha2.0.20190908210725-4a0ebd2f3c1b h1:kzTXBacNrjp7n8ncNC894X9NUeL8yeKVS5MS0bigJwE=
+mvdan.cc/sh/v3 v3.0.0-alpha2.0.20190908210725-4a0ebd2f3c1b/go.mod h1:6Cd5lQRZZIHeKAdYoLvhhse0oDOIrS5gBoGacWnuiUE=

help.go

@@ -5,6 +5,7 @@ import (
 	"sort"
 	"text/tabwriter"
 
+	"github.com/go-task/task/v2/internal/logger"
 	"github.com/go-task/task/v2/internal/taskfile"
 )
 
@@ -12,10 +13,10 @@ import (
 func (e *Executor) PrintTasksHelp() {
 	tasks := e.tasksWithDesc()
 	if len(tasks) == 0 {
-		e.Logger.Outf("task: No tasks with description available")
+		e.Logger.Outf(logger.Yellow, "task: No tasks with description available")
 		return
 	}
-	e.Logger.Outf("task: Available tasks for this project:")
+	e.Logger.Outf(logger.Default, "task: Available tasks for this project:")
 
 	// Format in tab-separated columns with a tab stop of 8.
 	w := tabwriter.NewWriter(e.Stdout, 0, 8, 0, '\t', 0)

init.go

@@ -10,7 +10,7 @@ import (
 
 const defaultTaskfile = `# https://taskfile.dev
 
-version: '2'
+version: '3'
 
 vars:
   GREETING: Hello, World!

internal/args/args.go

@@ -34,10 +34,6 @@ func Parse(args ...string) ([]taskfile.Call, taskfile.Vars) {
 		}
 	}
 
-	if len(calls) == 0 {
-		calls = append(calls, taskfile.Call{Task: "default"})
-	}
-
 	return calls, globals
 }
 

internal/args/args_test.go

@@ -64,28 +64,6 @@ func TestArgs(t *testing.T) {
 				"FOO": {Static: "bar"},
 			},
 		},
-		{
-			Args: nil,
-			ExpectedCalls: []taskfile.Call{
-				{Task: "default"},
-			},
-		},
-		{
-			Args: []string{},
-			ExpectedCalls: []taskfile.Call{
-				{Task: "default"},
-			},
-		},
-		{
-			Args: []string{"FOO=bar", "BAR=baz"},
-			ExpectedCalls: []taskfile.Call{
-				{Task: "default"},
-			},
-			ExpectedGlobals: taskfile.Vars{
-				"FOO": {Static: "bar"},
-				"BAR": {Static: "baz"},
-			},
-		},
 	}
 
 	for i, test := range tests {

internal/compiler/v1/compiler_v1.go

@@ -1,137 +0,0 @@
-package v1
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"strings"
-	"sync"
-
-	"github.com/go-task/task/v2/internal/compiler"
-	"github.com/go-task/task/v2/internal/execext"
-	"github.com/go-task/task/v2/internal/logger"
-	"github.com/go-task/task/v2/internal/taskfile"
-	"github.com/go-task/task/v2/internal/templater"
-)
-
-var _ compiler.Compiler = &CompilerV1{}
-
-type CompilerV1 struct {
-	Dir  string
-	Vars taskfile.Vars
-
-	Logger *logger.Logger
-
-	dynamicCache   map[string]string
-	muDynamicCache sync.Mutex
-}
-
-// GetVariables returns fully resolved variables following the priority order:
-// 1. Call variables (should already have been resolved)
-// 2. Environment (should not need to be resolved)
-// 3. Task variables, resolved with access to:
-//    - call, taskvars and environment variables
-// 4. Taskvars variables, resolved with access to:
-//    - environment variables
-func (c *CompilerV1) GetVariables(t *taskfile.Task, call taskfile.Call) (taskfile.Vars, error) {
-	merge := func(dest taskfile.Vars, srcs ...taskfile.Vars) {
-		for _, src := range srcs {
-			for k, v := range src {
-				dest[k] = v
-			}
-		}
-	}
-	varsKeys := func(srcs ...taskfile.Vars) []string {
-		m := make(map[string]struct{})
-		for _, src := range srcs {
-			for k := range src {
-				m[k] = struct{}{}
-			}
-		}
-		lst := make([]string, 0, len(m))
-		for k := range m {
-			lst = append(lst, k)
-		}
-		return lst
-	}
-	replaceVars := func(dest taskfile.Vars, keys []string) error {
-		r := templater.Templater{Vars: dest}
-		for _, k := range keys {
-			v := dest[k]
-			dest[k] = taskfile.Var{
-				Static: r.Replace(v.Static),
-				Sh:     r.Replace(v.Sh),
-			}
-		}
-		return r.Err()
-	}
-	resolveShell := func(dest taskfile.Vars, keys []string) error {
-		for _, k := range keys {
-			v := dest[k]
-			static, err := c.HandleDynamicVar(v)
-			if err != nil {
-				return err
-			}
-			dest[k] = taskfile.Var{Static: static}
-		}
-		return nil
-	}
-	update := func(dest taskfile.Vars, srcs ...taskfile.Vars) error {
-		merge(dest, srcs...)
-		// updatedKeys ensures template evaluation is run only once.
-		updatedKeys := varsKeys(srcs...)
-		if err := replaceVars(dest, updatedKeys); err != nil {
-			return err
-		}
-		return resolveShell(dest, updatedKeys)
-	}
-
-	// Resolve taskvars variables to "result" with environment override variables.
-	override := compiler.GetEnviron()
-	result := make(taskfile.Vars, len(c.Vars)+len(t.Vars)+len(override))
-	if err := update(result, c.Vars, override); err != nil {
-		return nil, err
-	}
-	// Resolve task variables to "result" with environment and call override variables.
-	merge(override, call.Vars)
-	if err := update(result, t.Vars, override); err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
-func (c *CompilerV1) HandleDynamicVar(v taskfile.Var) (string, error) {
-	if v.Static != "" || v.Sh == "" {
-		return v.Static, nil
-	}
-
-	c.muDynamicCache.Lock()
-	defer c.muDynamicCache.Unlock()
-
-	if c.dynamicCache == nil {
-		c.dynamicCache = make(map[string]string, 30)
-	}
-	if result, ok := c.dynamicCache[v.Sh]; ok {
-		return result, nil
-	}
-
-	var stdout bytes.Buffer
-	opts := &execext.RunCommandOptions{
-		Command: v.Sh,
-		Dir:     c.Dir,
-		Stdout:  &stdout,
-		Stderr:  c.Logger.Stderr,
-	}
-	if err := execext.RunCommand(context.Background(), opts); err != nil {
-		return "", fmt.Errorf(`task: Command "%s" in taskvars file failed: %s`, opts.Command, err)
-	}
-
-	// Trim a single trailing newline from the result to make most command
-	// output easier to use in shell commands.
-	result := strings.TrimSuffix(stdout.String(), "\n")
-
-	c.dynamicCache[v.Sh] = result
-	c.Logger.VerboseErrf(`task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
-
-	return result, nil
-}

internal/compiler/v2/compiler_v2.go

@@ -103,7 +103,7 @@ func (c *CompilerV2) HandleDynamicVar(v taskfile.Var) (string, error) {
 	result := strings.TrimSuffix(stdout.String(), "\n")
 
 	c.dynamicCache[v.Sh] = result
-	c.Logger.VerboseErrf(`task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
+	c.Logger.VerboseErrf(logger.Magenta, `task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
 
 	return result, nil
 }

internal/execext/devnull.go

@@ -1,13 +0,0 @@
-package execext
-
-import (
-	"io"
-)
-
-var _ io.ReadWriteCloser = devNull{}
-
-type devNull struct{}
-
-func (devNull) Read(p []byte) (int, error)  { return 0, io.EOF }
-func (devNull) Write(p []byte) (int, error) { return len(p), nil }
-func (devNull) Close() error                { return nil }

internal/execext/exec.go

@@ -49,12 +49,7 @@ func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
 		interp.Dir(opts.Dir),
 		interp.Env(expand.ListEnviron(environ...)),
 
-		interp.OpenHandler(func(ctx context.Context, path string, flag int, perm os.FileMode) (io.ReadWriteCloser, error) {
-			if path == "/dev/null" {
-				return devNull{}, nil
-			}
-			return interp.DefaultOpenHandler()(ctx, path, flag, perm)
-		}),
+		interp.WithOpenModules(interp.OpenDevImpls),
 
 		interp.StdIO(opts.Stdin, opts.Stdout, opts.Stderr),
 	)
@@ -66,10 +61,12 @@ func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
 
 // IsExitError returns true the given error is an exis status error
 func IsExitError(err error) bool {
-	if _, ok := interp.IsExitStatus(err); ok {
+	switch err.(type) {
+	case interp.ExitStatus, interp.ShellExitStatus:
 		return true
+	default:
+		return false
 	}
-	return false
 }
 
 // Expand is a helper to mvdan.cc/shell.Fields that returns the first field

internal/logger/logger.go

@@ -1,38 +1,65 @@
 package logger
 
 import (
-	"fmt"
 	"io"
+
+	"github.com/fatih/color"
 )
 
+type PrintFunc func(io.Writer, string, ...interface{})
+
+var (
+	Default PrintFunc = color.New(color.Reset).FprintfFunc()
+	Bold    PrintFunc = color.New(color.Bold).FprintfFunc()
+	Blue    PrintFunc = color.New(color.FgBlue, color.Bold).FprintfFunc()
+	Green   PrintFunc = color.New(color.FgGreen, color.Bold).FprintfFunc()
+	Cyan    PrintFunc = color.New(color.FgCyan, color.Bold).FprintfFunc()
+	Yellow  PrintFunc = color.New(color.FgYellow, color.Bold).FprintfFunc()
+	Magenta PrintFunc = color.New(color.FgMagenta, color.Bold).FprintfFunc()
+	Red     PrintFunc = color.New(color.FgRed, color.Bold).FprintfFunc()
+)
+
+// Logger is just a wrapper that prints stuff to STDOUT or STDERR,
+// with optional color.
 type Logger struct {
 	Stdout  io.Writer
 	Stderr  io.Writer
 	Verbose bool
+	Color   bool
 }
 
-func (l *Logger) Outf(s string, args ...interface{}) {
+// Outf prints stuff to STDOUT.
+func (l *Logger) Outf(print PrintFunc, s string, args ...interface{}) {
 	if len(args) == 0 {
 		s, args = "%s", []interface{}{s}
 	}
-	fmt.Fprintf(l.Stdout, s+"\n", args...)
+	if !l.Color {
+		print = Default
+	}
+	print(l.Stdout, s+"\n", args...)
 }
 
-func (l *Logger) VerboseOutf(s string, args ...interface{}) {
+// VerboseOutf prints stuff to STDOUT if verbose mode is enabled.
+func (l *Logger) VerboseOutf(print PrintFunc, s string, args ...interface{}) {
 	if l.Verbose {
-		l.Outf(s, args...)
+		l.Outf(print, s, args...)
 	}
 }
 
-func (l *Logger) Errf(s string, args ...interface{}) {
+// Errf prints stuff to STDERR.
+func (l *Logger) Errf(print PrintFunc, s string, args ...interface{}) {
 	if len(args) == 0 {
 		s, args = "%s", []interface{}{s}
 	}
-	fmt.Fprintf(l.Stderr, s+"\n", args...)
+	if !l.Color {
+		print = Default
+	}
+	print(l.Stderr, s+"\n", args...)
 }
 
-func (l *Logger) VerboseErrf(s string, args ...interface{}) {
+// VerboseErrf prints stuff to STDERR if verbose mode is enabled.
+func (l *Logger) VerboseErrf(print PrintFunc, s string, args ...interface{}) {
 	if l.Verbose {
-		l.Errf(s, args...)
+		l.Errf(print, s, args...)
 	}
 }

internal/status/checksum.go

@@ -23,6 +23,10 @@ type Checksum struct {
 
 // IsUpToDate implements the Checker interface
 func (c *Checksum) IsUpToDate() (bool, error) {
+	if len(c.Sources) == 0 {
+		return false, nil
+	}
+
 	checksumFile := c.checksumFilePath()
 
 	data, _ := ioutil.ReadFile(checksumFile)
@@ -84,11 +88,21 @@ func (c *Checksum) checksum(files ...string) (string, error) {
 	return fmt.Sprintf("%x", h.Sum(nil)), nil
 }
 
+// Value implements the Checker Interface
+func (c *Checksum) Value() (interface{}, error) {
+	return c.checksum()
+}
+
 // OnError implements the Checker interface
 func (c *Checksum) OnError() error {
 	return os.Remove(c.checksumFilePath())
 }
 
+// Kind implements the Checker Interface
+func (*Checksum) Kind() string {
+	return "checksum"
+}
+
 func (c *Checksum) checksumFilePath() string {
 	return filepath.Join(c.Dir, ".task", "checksum", c.normalizeFilename(c.Task))
 }

internal/status/none.go

@@ -8,6 +8,15 @@ func (None) IsUpToDate() (bool, error) {
 	return false, nil
 }
 
+// Value implements the Checker interface
+func (None) Value() (interface{}, error) {
+	return "", nil
+}
+
+func (None) Kind() string {
+	return "none"
+}
+
 // OnError implements the Checker interface
 func (None) OnError() error {
 	return nil

internal/status/status.go

@@ -9,5 +9,7 @@ var (
 // Checker is an interface that checks if the status is up-to-date
 type Checker interface {
 	IsUpToDate() (bool, error)
+	Value() (interface{}, error)
 	OnError() error
+	Kind() string
 }

internal/status/timestamp.go

@@ -41,6 +41,29 @@ func (t *Timestamp) IsUpToDate() (bool, error) {
 	return !generatesMinTime.Before(sourcesMaxTime), nil
 }
 
+func (t *Timestamp) Kind() string {
+	return "timestamp"
+}
+
+// Value implements the Checker Interface
+func (t *Timestamp) Value() (interface{}, error) {
+	sources, err := globs(t.Dir, t.Sources)
+	if err != nil {
+		return time.Now(), err
+	}
+
+	sourcesMaxTime, err := getMaxTime(sources...)
+	if err != nil {
+		return time.Now(), err
+	}
+
+	if sourcesMaxTime.IsZero() {
+		return time.Unix(0, 0), nil
+	}
+
+	return sourcesMaxTime, nil
+}
+
 func getMinTime(files ...string) (time.Time, error) {
 	var t time.Time
 	for _, f := range files {

internal/summary/summary.go

@@ -20,8 +20,8 @@ func printSpaceBetweenSummaries(l *logger.Logger, i int) {
 		return
 	}
 
-	l.Outf("")
-	l.Outf("")
+	l.Outf(logger.Default, "")
+	l.Outf(logger.Default, "")
 }
 
 func PrintTask(l *logger.Logger, t *taskfile.Task) {
@@ -50,14 +50,14 @@ func printTaskSummary(l *logger.Logger, t *taskfile.Task) {
 	for i, line := range lines {
 		notLastLine := i+1 < len(lines)
 		if notLastLine || line != "" {
-			l.Outf(line)
+			l.Outf(logger.Default, line)
 		}
 	}
 }
 
 func printTaskName(l *logger.Logger, t *taskfile.Task) {
-	l.Outf("task: %s", t.Task)
-	l.Outf("")
+	l.Outf(logger.Default, "task: %s", t.Task)
+	l.Outf(logger.Default, "")
 }
 
 func hasDescription(t *taskfile.Task) bool {
@@ -65,11 +65,11 @@ func hasDescription(t *taskfile.Task) bool {
 }
 
 func printTaskDescription(l *logger.Logger, t *taskfile.Task) {
-	l.Outf(t.Desc)
+	l.Outf(logger.Default, t.Desc)
 }
 
 func printNoDescriptionOrSummary(l *logger.Logger) {
-	l.Outf("(task does not have description or summary)")
+	l.Outf(logger.Default, "(task does not have description or summary)")
 }
 
 func printTaskDependencies(l *logger.Logger, t *taskfile.Task) {
@@ -77,11 +77,11 @@ func printTaskDependencies(l *logger.Logger, t *taskfile.Task) {
 		return
 	}
 
-	l.Outf("")
-	l.Outf("dependencies:")
+	l.Outf(logger.Default, "")
+	l.Outf(logger.Default, "dependencies:")
 
 	for _, d := range t.Deps {
-		l.Outf(" - %s", d.Task)
+		l.Outf(logger.Default, " - %s", d.Task)
 	}
 }
 
@@ -90,14 +90,14 @@ func printTaskCommands(l *logger.Logger, t *taskfile.Task) {
 		return
 	}
 
-	l.Outf("")
-	l.Outf("commands:")
+	l.Outf(logger.Default, "")
+	l.Outf(logger.Default, "commands:")
 	for _, c := range t.Cmds {
 		isCommand := c.Cmd != ""
 		if isCommand {
-			l.Outf(" - %s", c.Cmd)
+			l.Outf(logger.Default, " - %s", c.Cmd)
 		} else {
-			l.Outf(" - Task: %s", c.Task)
+			l.Outf(logger.Default, " - Task: %s", c.Task)
 		}
 	}
 }

internal/taskfile/taskfile.go

@@ -5,29 +5,24 @@ type Taskfile struct {
 	Version    string
 	Expansions int
 	Output     string
+	Method     string
 	Includes   map[string]string
 	Vars       Vars
 	Env        Vars
 	Tasks      Tasks
-	Silent     bool
 }
 
 // UnmarshalYAML implements yaml.Unmarshaler interface
 func (tf *Taskfile) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	if err := unmarshal(&tf.Tasks); err == nil {
-		tf.Version = "1"
-		return nil
-	}
-
 	var taskfile struct {
 		Version    string
 		Expansions int
 		Output     string
+		Method     string
 		Includes   map[string]string
 		Vars       Vars
 		Env        Vars
 		Tasks      Tasks
-		Silent     bool
 	}
 	if err := unmarshal(&taskfile); err != nil {
 		return err
@@ -35,11 +30,11 @@ func (tf *Taskfile) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	tf.Version = taskfile.Version
 	tf.Expansions = taskfile.Expansions
 	tf.Output = taskfile.Output
+	tf.Method = taskfile.Method
 	tf.Includes = taskfile.Includes
 	tf.Vars = taskfile.Vars
 	tf.Env = taskfile.Env
 	tf.Tasks = taskfile.Tasks
-	tf.Silent = taskfile.Silent
 	if tf.Expansions <= 0 {
 		tf.Expansions = 2
 	}

internal/taskfile/var.go

@@ -13,17 +13,22 @@ var (
 // Vars is a string[string] variables map.
 type Vars map[string]Var
 
-// ToStringMap converts Vars to a string map containing only the static
+// ToCacheMap converts Vars to a map containing only the static
 // variables
-func (vs Vars) ToStringMap() (m map[string]string) {
-	m = make(map[string]string, len(vs))
+func (vs Vars) ToCacheMap() (m map[string]interface{}) {
+	m = make(map[string]interface{}, len(vs))
 	for k, v := range vs {
 		if v.Sh != "" {
 			// Dynamic variable is not yet resolved; trigger
 			// <no value> to be used in templates.
 			continue
 		}
-		m[k] = v.Static
+
+		if v.Live != nil {
+			m[k] = v.Live
+		} else {
+			m[k] = v.Static
+		}
 	}
 	return
 }
@@ -31,6 +36,7 @@ func (vs Vars) ToStringMap() (m map[string]string) {
 // Var represents either a static or dynamic variable.
 type Var struct {
 	Static string
+	Live   interface{}
 	Sh     string
 }
 

internal/templater/funcs.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 	"text/template"
 
-	"github.com/Masterminds/sprig"
+	"github.com/go-task/slim-sprig"
 )
 
 var (

internal/templater/templater.go

@@ -14,8 +14,12 @@ import (
 type Templater struct {
 	Vars taskfile.Vars
 
-	strMap map[string]string
-	err    error
+	cacheMap map[string]interface{}
+	err      error
+}
+
+func (r *Templater) ResetCache() {
+	r.cacheMap = r.Vars.ToCacheMap()
 }
 
 func (r *Templater) Replace(str string) string {
@@ -29,12 +33,12 @@ func (r *Templater) Replace(str string) string {
 		return ""
 	}
 
-	if r.strMap == nil {
-		r.strMap = r.Vars.ToStringMap()
+	if r.cacheMap == nil {
+		r.cacheMap = r.Vars.ToCacheMap()
 	}
 
 	var b bytes.Buffer
-	if err = templ.Execute(&b, r.strMap); err != nil {
+	if err = templ.Execute(&b, r.cacheMap); err != nil {
 		r.err = err
 		return ""
 	}
@@ -62,6 +66,7 @@ func (r *Templater) ReplaceVars(vars taskfile.Vars) taskfile.Vars {
 	for k, v := range vars {
 		new[k] = taskfile.Var{
 			Static: r.Replace(v.Static),
+			Live:   v.Live,
 			Sh:     r.Replace(v.Sh),
 		}
 	}

precondition.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 
 	"github.com/go-task/task/v2/internal/execext"
+	"github.com/go-task/task/v2/internal/logger"
 	"github.com/go-task/task/v2/internal/taskfile"
 )
 
@@ -22,7 +23,7 @@ func (e *Executor) areTaskPreconditionsMet(ctx context.Context, t *taskfile.Task
 		})
 
 		if err != nil {
-			e.Logger.Errf("task: %s", p.Msg)
+			e.Logger.Errf(logger.Magenta, "task: %s", p.Msg)
 			return false, ErrPreconditionFailed
 		}
 	}

status.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	"github.com/go-task/task/v2/internal/execext"
+	"github.com/go-task/task/v2/internal/logger"
 	"github.com/go-task/task/v2/internal/status"
 	"github.com/go-task/task/v2/internal/taskfile"
 )
@@ -49,25 +50,37 @@ func (e *Executor) statusOnError(t *taskfile.Task) error {
 }
 
 func (e *Executor) getStatusChecker(t *taskfile.Task) (status.Checker, error) {
-	switch t.Method {
-	case "", "timestamp":
-		return &status.Timestamp{
-			Dir:       t.Dir,
-			Sources:   t.Sources,
-			Generates: t.Generates,
-		}, nil
+	method := t.Method
+	if method == "" {
+		method = e.Taskfile.Method
+	}
+	switch method {
+	case "timestamp":
+		return e.timestampChecker(t), nil
 	case "checksum":
-		return &status.Checksum{
-			Dir:       t.Dir,
-			Task:      t.Task,
-			Sources:   t.Sources,
-			Generates: t.Generates,
-			Dry:       e.Dry,
-		}, nil
+		return e.checksumChecker(t), nil
 	case "none":
 		return status.None{}, nil
 	default:
-		return nil, fmt.Errorf(`task: invalid method "%s"`, t.Method)
+		return nil, fmt.Errorf(`task: invalid method "%s"`, method)
+	}
+}
+
+func (e *Executor) timestampChecker(t *taskfile.Task) status.Checker {
+	return &status.Timestamp{
+		Dir:       t.Dir,
+		Sources:   t.Sources,
+		Generates: t.Generates,
+	}
+}
+
+func (e *Executor) checksumChecker(t *taskfile.Task) status.Checker {
+	return &status.Checksum{
+		Dir:       t.Dir,
+		Task:      t.Task,
+		Sources:   t.Sources,
+		Generates: t.Generates,
+		Dry:       e.Dry,
 	}
 }
 
@@ -79,10 +92,10 @@ func (e *Executor) isTaskUpToDateStatus(ctx context.Context, t *taskfile.Task) (
 			Env:     getEnviron(t),
 		})
 		if err != nil {
-			e.Logger.VerboseOutf("task: status command %s exited non-zero: %s", s, err)
+			e.Logger.VerboseOutf(logger.Yellow, "task: status command %s exited non-zero: %s", s, err)
 			return false, nil
 		}
-		e.Logger.VerboseOutf("task: status command %s exited zero", s)
+		e.Logger.VerboseOutf(logger.Yellow, "task: status command %s exited zero", s)
 	}
 	return true, nil
 }

task.go

@@ -11,7 +11,6 @@ import (
 	"sync/atomic"
 
 	"github.com/go-task/task/v2/internal/compiler"
-	compilerv1 "github.com/go-task/task/v2/internal/compiler/v1"
 	compilerv2 "github.com/go-task/task/v2/internal/compiler/v2"
 	"github.com/go-task/task/v2/internal/execext"
 	"github.com/go-task/task/v2/internal/logger"
@@ -41,7 +40,7 @@ type Executor struct {
 	Silent     bool
 	Dry        bool
 	Summary    bool
-	Parallel   bool
+	Color      bool
 
 	Stdin  io.Reader
 	Stdout io.Writer
@@ -78,18 +77,12 @@ func (e *Executor) Run(ctx context.Context, calls ...taskfile.Call) error {
 		return e.watchTasks(calls...)
 	}
 
-	g, ctx := errgroup.WithContext(ctx)
 	for _, c := range calls {
-		c := c
-		if e.Parallel {
-			g.Go(func() error { return e.RunTask(ctx, c) })
-		} else {
-			if err := e.RunTask(ctx, c); err != nil {
-				return err
-			}
+		if err := e.RunTask(ctx, c); err != nil {
+			return err
 		}
 	}
-	return g.Wait()
+	return nil
 }
 
 // Setup setups Executor's internal state
@@ -121,38 +114,38 @@ func (e *Executor) Setup() error {
 		Stdout:  e.Stdout,
 		Stderr:  e.Stderr,
 		Verbose: e.Verbose,
+		Color:   e.Color,
 	}
 
 	v, err := strconv.ParseFloat(e.Taskfile.Version, 64)
 	if err != nil {
 		return fmt.Errorf(`task: Could not parse taskfile version "%s": %v`, e.Taskfile.Version, err)
 	}
+
+	if v < 2 {
+		return fmt.Errorf(`task: Taskfile versions prior to v2 are not supported anymore`)
+	}
+
 	// consider as equal to the greater version if round
 	if v == 2.0 {
 		v = 2.6
 	}
 
-	if v < 1 {
-		return fmt.Errorf(`task: Taskfile version should be greater or equal to v1`)
-	}
-	if v > 2.6 {
-		return fmt.Errorf(`task: Taskfile versions greater than v2.6 not implemented in the version of Task`)
+	if v > 3.0 {
+		return fmt.Errorf(`task: Taskfile versions greater than v3.0 not implemented in the version of Task`)
 	}
 
-	if v < 2 {
-		e.Compiler = &compilerv1.CompilerV1{
-			Dir:    e.Dir,
-			Vars:   e.taskvars,
-			Logger: e.Logger,
-		}
-	} else { // v >= 2
-		e.Compiler = &compilerv2.CompilerV2{
-			Dir:          e.Dir,
-			Taskvars:     e.taskvars,
-			TaskfileVars: e.Taskfile.Vars,
-			Expansions:   e.Taskfile.Expansions,
-			Logger:       e.Logger,
-		}
+	// Color available only on v3
+	if v < 3 {
+		e.Logger.Color = false
+	}
+
+	e.Compiler = &compilerv2.CompilerV2{
+		Dir:          e.Dir,
+		Taskvars:     e.taskvars,
+		TaskfileVars: e.Taskfile.Vars,
+		Expansions:   e.Taskfile.Expansions,
+		Logger:       e.Logger,
 	}
 
 	if v < 2.1 && e.Taskfile.Output != "" {
@@ -176,6 +169,14 @@ func (e *Executor) Setup() error {
 		return fmt.Errorf(`task: output option "%s" not recognized`, e.Taskfile.Output)
 	}
 
+	if e.Taskfile.Method == "" {
+		if v >= 3 {
+			e.Taskfile.Method = "checksum"
+		} else {
+			e.Taskfile.Method = "timestamp"
+		}
+	}
+
 	if v <= 2.1 {
 		err := errors.New(`task: Taskfile option "ignore_error" is only available starting on Taskfile version v2.1`)
 
@@ -235,24 +236,24 @@ func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {
 
 		if upToDate && preCondMet {
 			if !e.Silent {
-				e.Logger.Errf(`task: Task "%s" is up to date`, t.Task)
+				e.Logger.Errf(logger.Magenta, `task: Task "%s" is up to date`, t.Task)
 			}
 			return nil
 		}
 	}
 
 	if err := e.mkdir(t); err != nil {
-		e.Logger.Errf("task: cannot make directory %q: %v", t.Dir, err)
+		e.Logger.Errf(logger.Red, "task: cannot make directory %q: %v", t.Dir, err)
 	}
 
 	for i := range t.Cmds {
 		if err := e.runCommand(ctx, t, call, i); err != nil {
 			if err2 := e.statusOnError(t); err2 != nil {
-				e.Logger.VerboseErrf("task: error cleaning status on error: %v", err2)
+				e.Logger.VerboseErrf(logger.Yellow, "task: error cleaning status on error: %v", err2)
 			}
 
 			if execext.IsExitError(err) && t.IgnoreError {
-				e.Logger.VerboseErrf("task: task error ignored: %v", err)
+				e.Logger.VerboseErrf(logger.Yellow, "task: task error ignored: %v", err)
 				continue
 			}
 
@@ -308,8 +309,8 @@ func (e *Executor) runCommand(ctx context.Context, t *taskfile.Task, call taskfi
 		}
 		return nil
 	case cmd.Cmd != "":
-		if e.Verbose || (!cmd.Silent && !t.Silent && !e.Taskfile.Silent && !e.Silent) {
-			e.Logger.Errf(cmd.Cmd)
+		if e.Verbose || (!cmd.Silent && !t.Silent && !e.Silent) {
+			e.Logger.Errf(logger.Green, "task: %s", cmd.Cmd)
 		}
 
 		if e.Dry {
@@ -340,7 +341,7 @@ func (e *Executor) runCommand(ctx context.Context, t *taskfile.Task, call taskfi
 			Stderr:  stdErr,
 		})
 		if execext.IsExitError(err) && cmd.IgnoreError {
-			e.Logger.VerboseErrf("task: command error ignored: %v", err)
+			e.Logger.VerboseErrf(logger.Yellow, "task: command error ignored: %v", err)
 			return nil
 		}
 		return err
@@ -355,8 +356,10 @@ func getEnviron(t *taskfile.Task) []string {
 	}
 
 	environ := os.Environ()
-	for k, v := range t.Env.ToStringMap() {
-		environ = append(environ, fmt.Sprintf("%s=%s", k, v))
+	for k, v := range t.Env.ToCacheMap() {
+		if s, ok := v.(string); ok {
+			environ = append(environ, fmt.Sprintf("%s=%s", k, s))
+		}
 	}
 	return environ
 }

task_test.go

@@ -69,43 +69,6 @@ func TestEnv(t *testing.T) {
 	tt.Run(t)
 }
 
-func TestVarsV1(t *testing.T) {
-	tt := fileContentTest{
-		Dir:       "testdata/vars/v1",
-		Target:    "default",
-		TrimSpace: true,
-		Files: map[string]string{
-			// hello task:
-			"foo.txt":              "foo",
-			"bar.txt":              "bar",
-			"baz.txt":              "baz",
-			"tmpl_foo.txt":         "foo",
-			"tmpl_bar.txt":         "<no value>",
-			"tmpl_foo2.txt":        "foo2",
-			"tmpl_bar2.txt":        "bar2",
-			"shtmpl_foo.txt":       "foo",
-			"shtmpl_foo2.txt":      "foo2",
-			"nestedtmpl_foo.txt":   "{{.FOO}}",
-			"nestedtmpl_foo2.txt":  "foo2",
-			"foo2.txt":             "foo2",
-			"bar2.txt":             "bar2",
-			"baz2.txt":             "baz2",
-			"tmpl2_foo.txt":        "<no value>",
-			"tmpl2_foo2.txt":       "foo2",
-			"tmpl2_bar.txt":        "<no value>",
-			"tmpl2_bar2.txt":       "<no value>",
-			"shtmpl2_foo.txt":      "<no value>",
-			"shtmpl2_foo2.txt":     "foo2",
-			"nestedtmpl2_foo2.txt": "{{.FOO2}}",
-			"override.txt":         "bar",
-		},
-	}
-	tt.Run(t)
-	// Ensure identical results when running hello task directly.
-	tt.Target = "hello"
-	tt.Run(t)
-}
-
 func TestVarsV2(t *testing.T) {
 	tt := fileContentTest{
 		Dir:       "testdata/vars/v2",
@@ -144,7 +107,7 @@ func TestVarsV2(t *testing.T) {
 }
 
 func TestMultilineVars(t *testing.T) {
-	for _, dir := range []string{"testdata/vars/v1/multiline", "testdata/vars/v2/multiline"} {
+	for _, dir := range []string{"testdata/vars/v2/multiline"} {
 		tt := fileContentTest{
 			Dir:       dir,
 			Target:    "default",
@@ -168,7 +131,7 @@ func TestMultilineVars(t *testing.T) {
 
 func TestVarsInvalidTmpl(t *testing.T) {
 	const (
-		dir         = "testdata/vars/v1"
+		dir         = "testdata/vars/v2"
 		target      = "invalid-var-tmpl"
 		expectError = "template: :1: unexpected EOF"
 	)
@@ -406,6 +369,34 @@ func TestStatusChecksum(t *testing.T) {
 	assert.Equal(t, `task: Task "build" is up to date`+"\n", buff.String())
 }
 
+func TestStatusVariables(t *testing.T) {
+	const dir = "testdata/status_vars"
+
+	_ = os.RemoveAll(filepath.Join(dir, ".task"))
+	_ = os.Remove(filepath.Join(dir, "generated.txt"))
+
+	var buff bytes.Buffer
+	e := task.Executor{
+		Dir:     dir,
+		Stdout:  &buff,
+		Stderr:  &buff,
+		Silent:  false,
+		Verbose: true,
+	}
+	assert.NoError(t, e.Setup())
+	assert.NoError(t, e.Run(context.Background(), taskfile.Call{Task: "build"}))
+
+	assert.Contains(t, buff.String(), "d41d8cd98f00b204e9800998ecf8427e")
+
+	inf, err := os.Stat(filepath.Join(dir, "source.txt"))
+	assert.NoError(t, err)
+	ts := fmt.Sprintf("%d", inf.ModTime().Unix())
+	tf := fmt.Sprintf("%s", inf.ModTime())
+
+	assert.Contains(t, buff.String(), ts)
+	assert.Contains(t, buff.String(), tf)
+}
+
 func TestInit(t *testing.T) {
 	const dir = "testdata/init"
 	var file = filepath.Join(dir, "Taskfile.yml")
@@ -441,7 +432,6 @@ func TestTaskVersion(t *testing.T) {
 		Dir     string
 		Version string
 	}{
-		{"testdata/version/v1", "1"},
 		{"testdata/version/v2", "2"},
 	}
 
@@ -511,7 +501,7 @@ func TestDry(t *testing.T) {
 	assert.NoError(t, e.Setup())
 	assert.NoError(t, e.Run(context.Background(), taskfile.Call{Task: "build"}))
 
-	assert.Equal(t, "touch file.txt", strings.TrimSpace(buff.String()))
+	assert.Equal(t, "task: touch file.txt", strings.TrimSpace(buff.String()))
 	if _, err := os.Stat(file); err == nil {
 		t.Errorf("File should not exist %s", file)
 	}
@@ -668,7 +658,7 @@ func TestWhenDirAttributeItCreatesMissingAndRunsInThatDir(t *testing.T) {
 	}
 
 	// Ensure that the directory to be created doesn't actually exist.
-	_ = os.Remove(toBeCreated)
+	_ = os.RemoveAll(toBeCreated)
 	if _, err := os.Stat(toBeCreated); err == nil {
 		t.Errorf("Directory should not exist: %v", err)
 	}
@@ -679,5 +669,17 @@ func TestWhenDirAttributeItCreatesMissingAndRunsInThatDir(t *testing.T) {
 	assert.Equal(t, expected, got, "Mismatch in the working directory")
 
 	// Clean-up after ourselves only if no error.
-	_ = os.Remove(toBeCreated)
+	_ = os.RemoveAll(toBeCreated)
+}
+
+func TestDisplaysErrorOnUnsupportedVersion(t *testing.T) {
+	e := task.Executor{
+		Dir:    "testdata/version/v1",
+		Stdout: ioutil.Discard,
+		Stderr: ioutil.Discard,
+	}
+	err := e.Setup()
+	assert.Error(t, err)
+	assert.Equal(t, "task: Taskfile versions prior to v2 are not supported anymore", err.Error())
+
 }

testdata/checksum/Taskfile.yml

@@ -1,9 +1,12 @@
-build:
-  cmds:
-    - cp ./source.txt ./generated.txt
-  sources:
-    - ./**/glob-with-inexistent-file.txt
-    - ./source.txt
-  generates:
-    - ./generated.txt
-  method: checksum
+version: '2'
+
+tasks:
+  build:
+    cmds:
+      - cp ./source.txt ./generated.txt
+    sources:
+      - ./**/glob-with-inexistent-file.txt
+      - ./source.txt
+    generates:
+      - ./generated.txt
+    method: checksum

testdata/cyclic/Taskfile.yml

@@ -1,7 +1,10 @@
-task-1:
-  deps:
-    - task: task-2
+version: '2'
 
-task-2:
-  deps:
-    - task: task-1
+tasks:
+  task-1:
+    deps:
+      - task: task-2
+
+  task-2:
+    deps:
+      - task: task-1

testdata/deps/Taskfile.yml

@@ -1,53 +1,56 @@
-default:
-  deps: [d1, d2, d3]
+version: '2'
 
-d1:
-  deps: [d11, d12, d13]
-  cmds:
-    - echo 'Text' > d1.txt
+tasks:
+  default:
+    deps: [d1, d2, d3]
 
-d2:
-  deps: [d21, d22, d23]
-  cmds:
-    - echo 'Text' > d2.txt
+  d1:
+    deps: [d11, d12, d13]
+    cmds:
+      - echo 'Text' > d1.txt
 
-d3:
-  deps: [d31, d32, d33]
-  cmds:
-    - echo 'Text' > d3.txt
+  d2:
+    deps: [d21, d22, d23]
+    cmds:
+      - echo 'Text' > d2.txt
 
-d11:
-  cmds:
-    - echo 'Text' > d11.txt
+  d3:
+    deps: [d31, d32, d33]
+    cmds:
+      - echo 'Text' > d3.txt
 
-d12:
-  cmds:
-    - echo 'Text' > d12.txt
+  d11:
+    cmds:
+      - echo 'Text' > d11.txt
 
-d13:
-  cmds:
-    - echo 'Text' > d13.txt
+  d12:
+    cmds:
+      - echo 'Text' > d12.txt
 
-d21:
-  cmds:
-    - echo 'Text' > d21.txt
+  d13:
+    cmds:
+      - echo 'Text' > d13.txt
 
-d22:
-  cmds:
-    - echo 'Text' > d22.txt
+  d21:
+    cmds:
+      - echo 'Text' > d21.txt
 
-d23:
-  cmds:
-    - echo 'Text' > d23.txt
+  d22:
+    cmds:
+      - echo 'Text' > d22.txt
 
-d31:
-  cmds:
-    - echo 'Text' > d31.txt
+  d23:
+    cmds:
+      - echo 'Text' > d23.txt
 
-d32:
-  cmds:
-    - echo 'Text' > d32.txt
+  d31:
+    cmds:
+      - echo 'Text' > d31.txt
 
-d33:
-  cmds:
-    - echo 'Text' > d33.txt
+  d32:
+    cmds:
+      - echo 'Text' > d32.txt
+
+  d33:
+    cmds:
+      - echo 'Text' > d33.txt

testdata/generates/Taskfile.yml

@@ -1,41 +1,48 @@
-abs.txt:
-  desc: generates dest file based on absolute paths
-  deps:
-    - sub/src.txt
-  dir: sub
-  cmds:
-    - cat src.txt > '{{.BUILD_DIR}}/abs.txt'
-  sources:
-    - src.txt
-  generates:
-    - "{{.BUILD_DIR}}/abs.txt"
+version: '2'
 
-rel.txt:
-  desc: generates dest file based on relative paths
-  deps:
-    - sub/src.txt
-  dir: sub
-  cmds:
-    - cat src.txt > '../rel.txt'
-  sources:
-    - src.txt
-  generates:
-    - "../rel.txt"
+tasks:
+  abs.txt:
+    desc: generates dest file based on absolute paths
+    deps:
+      - sub/src.txt
+    dir: sub
+    cmds:
+      - cat src.txt > '{{.BUILD_DIR}}/abs.txt'
+    method: timestamp
+    sources:
+      - src.txt
+    generates:
+      - "{{.BUILD_DIR}}/abs.txt"
 
-sub/src.txt:
-  desc: generate source file
-  cmds:
-    - mkdir -p sub
-    - echo "hello world" > sub/src.txt
-  status:
-    - test -f sub/src.txt
+  rel.txt:
+    desc: generates dest file based on relative paths
+    deps:
+      - sub/src.txt
+    dir: sub
+    cmds:
+      - cat src.txt > '../rel.txt'
+    method: timestamp
+    sources:
+      - src.txt
+    generates:
+      - "../rel.txt"
 
-'my text file.txt':
-  desc: generate file with spaces in the name
-  deps: [sub/src.txt]
-  cmds:
-    - cat sub/src.txt > 'my text file.txt'
-  sources:
-    - sub/src.txt
-  generates:
-    - 'my text file.txt'
+  sub/src.txt:
+    desc: generate source file
+    cmds:
+      - mkdir -p sub
+      - echo "hello world" > sub/src.txt
+    method: timestamp
+    status:
+      - test -f sub/src.txt
+
+  'my text file.txt':
+    desc: generate file with spaces in the name
+    deps: [sub/src.txt]
+    cmds:
+      - cat sub/src.txt > 'my text file.txt'
+    method: timestamp
+    sources:
+      - sub/src.txt
+    generates:
+      - 'my text file.txt'

testdata/params/Taskfile.yml

@@ -1,37 +1,40 @@
-default:
-  vars:
-    SPANISH: ¡Holla mundo!
-    PORTUGUESE: "{{.PORTUGUESE_HELLO_WORLD}}"
-    GERMAN: "Welt!"
-  deps:
-    - task: write-file
-      vars: {CONTENT: Dependence1, FILE: dep1.txt}
-    - task: write-file
-      vars: {CONTENT: Dependence2, FILE: dep2.txt}
-    - task: write-file
-      vars: {CONTENT: "{{.SPANISH|replace \"mundo\" \"dependencia\"}}", FILE: spanish-dep.txt}
-  cmds:
-    - task: write-file
-      vars: {CONTENT: Hello, FILE: hello.txt}
-    - task: write-file
-      vars: {CONTENT: "$echo 'World'", FILE: world.txt}
-    - task: write-file
-      vars: {CONTENT: "!", FILE: exclamation.txt}
-    - task: write-file
-      vars: {CONTENT: "{{.SPANISH}}", FILE: spanish.txt}
-    - task: write-file
-      vars: {CONTENT: "{{.PORTUGUESE}}", FILE: portuguese.txt}
-    - task: write-file
-      vars: {CONTENT: "{{.GERMAN}}", FILE: german.txt}
-    - task: non-default
+version: '2'
 
-write-file:
-  cmds:
-    - echo {{.CONTENT}} > {{.FILE}}
+tasks:
+  default:
+    vars:
+      SPANISH: ¡Holla mundo!
+      PORTUGUESE: "{{.PORTUGUESE_HELLO_WORLD}}"
+      GERMAN: "Welt!"
+    deps:
+      - task: write-file
+        vars: {CONTENT: Dependence1, FILE: dep1.txt}
+      - task: write-file
+        vars: {CONTENT: Dependence2, FILE: dep2.txt}
+      - task: write-file
+        vars: {CONTENT: "{{.SPANISH|replace \"mundo\" \"dependencia\"}}", FILE: spanish-dep.txt}
+    cmds:
+      - task: write-file
+        vars: {CONTENT: Hello, FILE: hello.txt}
+      - task: write-file
+        vars: {CONTENT: "$echo 'World'", FILE: world.txt}
+      - task: write-file
+        vars: {CONTENT: "!", FILE: exclamation.txt}
+      - task: write-file
+        vars: {CONTENT: "{{.SPANISH}}", FILE: spanish.txt}
+      - task: write-file
+        vars: {CONTENT: "{{.PORTUGUESE}}", FILE: portuguese.txt}
+      - task: write-file
+        vars: {CONTENT: "{{.GERMAN}}", FILE: german.txt}
+      - task: non-default
 
-non-default:
-  vars:
-    PORTUGUESE: "{{.PORTUGUESE_HELLO_WORLD}}"
-  cmds:
-    - task: write-file
-      vars: {CONTENT: "{{.PORTUGUESE}}", FILE: portuguese2.txt}
+  write-file:
+    cmds:
+      - echo {{.CONTENT}} > {{.FILE}}
+
+  non-default:
+    vars:
+      PORTUGUESE: "{{.PORTUGUESE_HELLO_WORLD}}"
+    cmds:
+      - task: write-file
+        vars: {CONTENT: "{{.PORTUGUESE}}", FILE: portuguese2.txt}

testdata/status/Taskfile.yml

@@ -1,5 +1,8 @@
-gen-foo:
-  cmds:
-    - touch foo.txt
-  status:
-    - test -f foo.txt
+version: '2'
+
+tasks:
+  gen-foo:
+    cmds:
+      - touch foo.txt
+    status:
+      - test -f foo.txt

testdata/status_vars/.gitignore

@@ -0,0 +1 @@
+generated.txt

testdata/status_vars/Taskfile.yml

@@ -0,0 +1,10 @@
+version: '3'
+
+tasks:
+  build:
+    sources:
+      - ./source.txt
+    status:
+      - echo "{{.CHECKSUM}}"
+      - echo '{{.TIMESTAMP.Unix}}'
+      - echo '{{.TIMESTAMP}}'

testdata/status_vars/source.txt

@@ -0,0 +1 @@
+Hello, World!

testdata/summary/Taskfile.yml

@@ -1,4 +1,4 @@
-version: 2
+version: '2'
 
 tasks:
   task-with-summary:

testdata/vars/v1/.gitignore

@@ -1 +0,0 @@
-*.txt

testdata/vars/v1/Taskfile.yml

@@ -1,48 +0,0 @@
-default:
-  deps: [hello]
-
-hello:
-  cmds:
-    - echo {{.FOO}} > foo.txt
-    - echo {{.BAR}} > bar.txt
-    - echo {{.BAZ}} > baz.txt
-    - echo '{{.TMPL_FOO}}' > tmpl_foo.txt
-    - echo '{{.TMPL_BAR}}' > tmpl_bar.txt
-    - echo '{{.TMPL_FOO2}}' > tmpl_foo2.txt
-    - echo '{{.TMPL_BAR2}}' > tmpl_bar2.txt
-    - echo '{{.SHTMPL_FOO}}' > shtmpl_foo.txt
-    - echo '{{.SHTMPL_FOO2}}' > shtmpl_foo2.txt
-    - echo '{{.NESTEDTMPL_FOO}}' > nestedtmpl_foo.txt
-    - echo '{{.NESTEDTMPL_FOO2}}' > nestedtmpl_foo2.txt
-    - echo {{.FOO2}} > foo2.txt
-    - echo {{.BAR2}} > bar2.txt
-    - echo {{.BAZ2}} > baz2.txt
-    - echo '{{.TMPL2_FOO}}' > tmpl2_foo.txt
-    - echo '{{.TMPL2_BAR}}' > tmpl2_bar.txt
-    - echo '{{.TMPL2_FOO2}}' > tmpl2_foo2.txt
-    - echo '{{.TMPL2_BAR2}}' > tmpl2_bar2.txt
-    - echo '{{.SHTMPL2_FOO}}' > shtmpl2_foo.txt
-    - echo '{{.SHTMPL2_FOO2}}' > shtmpl2_foo2.txt
-    - echo '{{.NESTEDTMPL2_FOO2}}' > nestedtmpl2_foo2.txt
-    - echo {{.OVERRIDE}} > override.txt
-  vars:
-    FOO: foo
-    BAR: $echo bar
-    BAZ:
-      sh: echo baz
-    TMPL_FOO: "{{.FOO}}"
-    TMPL_BAR: "{{.BAR}}"
-    TMPL_FOO2: "{{.FOO2}}"
-    TMPL_BAR2: "{{.BAR2}}"
-    SHTMPL_FOO:
-      sh: "echo '{{.FOO}}'"
-    SHTMPL_FOO2:
-      sh: "echo '{{.FOO2}}'"
-    NESTEDTMPL_FOO: "{{.TMPL_FOO}}"
-    NESTEDTMPL_FOO2: "{{.TMPL2_FOO2}}"
-    OVERRIDE: "bar"
-
-invalid-var-tmpl:
-  vars:
-    CHARS: "abcd"
-    INVALID: "{{range .CHARS}}no end"

testdata/vars/v1/Taskvars.yml

@@ -1,12 +0,0 @@
-FOO2: foo2
-BAR2: $echo bar2
-BAZ2:
-  sh: echo baz2
-TMPL2_FOO: "{{.FOO}}"
-TMPL2_BAR: "{{.BAR}}"
-TMPL2_FOO2: "{{.FOO2}}"
-TMPL2_BAR2: "{{.BAR2}}"
-SHTMPL2_FOO2:
-  sh: "echo '{{.FOO2}}'"
-NESTEDTMPL2_FOO2: "{{.TMPL2_FOO2}}"
-OVERRIDE: "foo"

testdata/vars/v1/multiline/Taskfile.yml

@@ -1,43 +0,0 @@
-default:
-  vars:
-    MULTILINE: "\n\nfoo\n  bar\nfoobar\n\nbaz\n\n"
-  cmds:
-    - task: file
-      vars:
-        CONTENT:
-          sh: "echo 'foo\nbar'"
-        FILE: "echo_foobar.txt"
-    - task: file
-      vars:
-        CONTENT:
-          sh: "echo -n 'foo\nbar'"
-        FILE: "echo_n_foobar.txt"
-    - task: file
-      vars:
-        CONTENT:
-          sh: echo -n "{{.MULTILINE}}"
-        FILE: "echo_n_multiline.txt"
-    - task: file
-      vars:
-        CONTENT: "{{.MULTILINE}}"
-        FILE: "var_multiline.txt"
-    - task: file
-      vars:
-        CONTENT: "{{.MULTILINE | catLines}}"
-        FILE: "var_catlines.txt"
-    - task: enumfile
-      vars:
-        LINES: "{{.MULTILINE}}"
-        FILE: "var_enumfile.txt"
-file:
-  cmds:
-    - |
-      cat << EOF > '{{.FILE}}'
-      {{.CONTENT}}
-      EOF
-enumfile:
-  cmds:
-    - |
-      cat << EOF > '{{.FILE}}'
-      {{range $i, $line := .LINES| splitLines}}{{$i}}:{{$line}}
-      {{end}}EOF

testdata/version/v2/Taskfile.yml

@@ -1,9 +1,9 @@
-version: 2
+version: '2'
+
 tasks:
   foo:
     cmds:
       - echo "Foo"
-
   bar:
     cmds:
       - echo "Bar"

variables.go

@@ -2,8 +2,10 @@ package task
 
 import (
 	"path/filepath"
+	"strings"
 
 	"github.com/go-task/task/v2/internal/execext"
+	"github.com/go-task/task/v2/internal/status"
 	"github.com/go-task/task/v2/internal/taskfile"
 	"github.com/go-task/task/v2/internal/templater"
 )
@@ -20,6 +22,7 @@ func (e *Executor) CompiledTask(call taskfile.Call) (*taskfile.Task, error) {
 	if err != nil {
 		return nil, err
 	}
+
 	r := templater.Templater{Vars: vars}
 
 	new := taskfile.Task{
@@ -27,7 +30,6 @@ func (e *Executor) CompiledTask(call taskfile.Call) (*taskfile.Task, error) {
 		Desc:        r.Replace(origTask.Desc),
 		Sources:     r.ReplaceSlice(origTask.Sources),
 		Generates:   r.ReplaceSlice(origTask.Generates),
-		Status:      r.ReplaceSlice(origTask.Status),
 		Dir:         r.Replace(origTask.Dir),
 		Vars:        nil,
 		Env:         nil,
@@ -94,5 +96,21 @@ func (e *Executor) CompiledTask(call taskfile.Call) (*taskfile.Task, error) {
 		}
 	}
 
+	if len(origTask.Status) > 0 {
+		for _, checker := range []status.Checker{e.timestampChecker(&new), e.checksumChecker(&new)} {
+			value, err := checker.Value()
+			if err != nil {
+				return nil, err
+			}
+			vars[strings.ToUpper(checker.Kind())] = taskfile.Var{Live: value}
+		}
+
+		// Adding new variables, requires us to refresh the templaters
+		// cache of the the values manually
+		r.ResetCache()
+
+		new.Status = r.ReplaceSlice(origTask.Status)
+	}
+
 	return &new, r.Err()
 }

vendor/github.com/mitchellh/go-homedir/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Mitchell Hashimoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/github.com/mitchellh/go-homedir/README.md

@@ -0,0 +1,14 @@
+# go-homedir
+
+This is a Go library for detecting the user's home directory without
+the use of cgo, so the library can be used in cross-compilation environments.
+
+Usage is incredibly simple, just call `homedir.Dir()` to get the home directory
+for a user, and `homedir.Expand()` to expand the `~` in a path to the home
+directory.
+
+**Why not just use `os/user`?** The built-in `os/user` package requires
+cgo on Darwin systems. This means that any Go code that uses that package
+cannot cross compile. But 99% of the time the use for `os/user` is just to
+retrieve the home directory, which we can do for the current user without
+cgo. This library does that, enabling cross-compilation.

vendor/github.com/mitchellh/go-homedir/go.mod

@@ -0,0 +1 @@
+module github.com/mitchellh/go-homedir

vendor/github.com/mitchellh/go-homedir/homedir.go

@@ -0,0 +1,157 @@
+package homedir
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+// DisableCache will disable caching of the home directory. Caching is enabled
+// by default.
+var DisableCache bool
+
+var homedirCache string
+var cacheLock sync.RWMutex
+
+// Dir returns the home directory for the executing user.
+//
+// This uses an OS-specific method for discovering the home directory.
+// An error is returned if a home directory cannot be detected.
+func Dir() (string, error) {
+	if !DisableCache {
+		cacheLock.RLock()
+		cached := homedirCache
+		cacheLock.RUnlock()
+		if cached != "" {
+			return cached, nil
+		}
+	}
+
+	cacheLock.Lock()
+	defer cacheLock.Unlock()
+
+	var result string
+	var err error
+	if runtime.GOOS == "windows" {
+		result, err = dirWindows()
+	} else {
+		// Unix-like system, so just assume Unix
+		result, err = dirUnix()
+	}
+
+	if err != nil {
+		return "", err
+	}
+	homedirCache = result
+	return result, nil
+}
+
+// Expand expands the path to include the home directory if the path
+// is prefixed with `~`. If it isn't prefixed with `~`, the path is
+// returned as-is.
+func Expand(path string) (string, error) {
+	if len(path) == 0 {
+		return path, nil
+	}
+
+	if path[0] != '~' {
+		return path, nil
+	}
+
+	if len(path) > 1 && path[1] != '/' && path[1] != '\\' {
+		return "", errors.New("cannot expand user-specific home dir")
+	}
+
+	dir, err := Dir()
+	if err != nil {
+		return "", err
+	}
+
+	return filepath.Join(dir, path[1:]), nil
+}
+
+func dirUnix() (string, error) {
+	homeEnv := "HOME"
+	if runtime.GOOS == "plan9" {
+		// On plan9, env vars are lowercase.
+		homeEnv = "home"
+	}
+
+	// First prefer the HOME environmental variable
+	if home := os.Getenv(homeEnv); home != "" {
+		return home, nil
+	}
+
+	var stdout bytes.Buffer
+
+	// If that fails, try OS specific commands
+	if runtime.GOOS == "darwin" {
+		cmd := exec.Command("sh", "-c", `dscl -q . -read /Users/"$(whoami)" NFSHomeDirectory | sed 's/^[^ ]*: //'`)
+		cmd.Stdout = &stdout
+		if err := cmd.Run(); err == nil {
+			result := strings.TrimSpace(stdout.String())
+			if result != "" {
+				return result, nil
+			}
+		}
+	} else {
+		cmd := exec.Command("getent", "passwd", strconv.Itoa(os.Getuid()))
+		cmd.Stdout = &stdout
+		if err := cmd.Run(); err != nil {
+			// If the error is ErrNotFound, we ignore it. Otherwise, return it.
+			if err != exec.ErrNotFound {
+				return "", err
+			}
+		} else {
+			if passwd := strings.TrimSpace(stdout.String()); passwd != "" {
+				// username:password:uid:gid:gecos:home:shell
+				passwdParts := strings.SplitN(passwd, ":", 7)
+				if len(passwdParts) > 5 {
+					return passwdParts[5], nil
+				}
+			}
+		}
+	}
+
+	// If all else fails, try the shell
+	stdout.Reset()
+	cmd := exec.Command("sh", "-c", "cd && pwd")
+	cmd.Stdout = &stdout
+	if err := cmd.Run(); err != nil {
+		return "", err
+	}
+
+	result := strings.TrimSpace(stdout.String())
+	if result == "" {
+		return "", errors.New("blank output when reading home directory")
+	}
+
+	return result, nil
+}
+
+func dirWindows() (string, error) {
+	// First prefer the HOME environmental variable
+	if home := os.Getenv("HOME"); home != "" {
+		return home, nil
+	}
+
+	// Prefer standard environment variable USERPROFILE
+	if home := os.Getenv("USERPROFILE"); home != "" {
+		return home, nil
+	}
+
+	drive := os.Getenv("HOMEDRIVE")
+	path := os.Getenv("HOMEPATH")
+	home := drive + path
+	if drive == "" || path == "" {
+		return "", errors.New("HOMEDRIVE, HOMEPATH, or USERPROFILE are blank")
+	}
+
+	return home, nil
+}

vendor/github.com/stretchr/testify/assert/assertion_format.go

@@ -113,17 +113,6 @@ func Errorf(t TestingT, err error, msg string, args ...interface{}) bool {
 	return Error(t, err, append([]interface{}{msg}, args...)...)
 }
 
-// Eventuallyf asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-//    assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-	return Eventually(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...)
-}
-
 // Exactlyf asserts that two objects are equal in value and type.
 //
 //    assert.Exactlyf(t, int32(123, "error message %s", "formatted"), int64(123))
@@ -168,31 +157,6 @@ func FileExistsf(t TestingT, path string, msg string, args ...interface{}) bool
 	return FileExists(t, path, append([]interface{}{msg}, args...)...)
 }
 
-// Greaterf asserts that the first element is greater than the second
-//
-//    assert.Greaterf(t, 2, 1, "error message %s", "formatted")
-//    assert.Greaterf(t, float64(2, "error message %s", "formatted"), float64(1))
-//    assert.Greaterf(t, "b", "a", "error message %s", "formatted")
-func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-	return Greater(t, e1, e2, append([]interface{}{msg}, args...)...)
-}
-
-// GreaterOrEqualf asserts that the first element is greater than or equal to the second
-//
-//    assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted")
-//    assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted")
-//    assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted")
-//    assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted")
-func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-	return GreaterOrEqual(t, e1, e2, append([]interface{}{msg}, args...)...)
-}
-
 // HTTPBodyContainsf asserts that a specified handler returns a
 // body that contains a string.
 //
@@ -325,14 +289,6 @@ func JSONEqf(t TestingT, expected string, actual string, msg string, args ...int
 	return JSONEq(t, expected, actual, append([]interface{}{msg}, args...)...)
 }
 
-// YAMLEqf asserts that two YAML strings are equivalent.
-func YAMLEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-	return YAMLEq(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
 // Lenf asserts that the specified object has specific length.
 // Lenf also fails if the object has a type that len() not accept.
 //
@@ -344,31 +300,6 @@ func Lenf(t TestingT, object interface{}, length int, msg string, args ...interf
 	return Len(t, object, length, append([]interface{}{msg}, args...)...)
 }
 
-// Lessf asserts that the first element is less than the second
-//
-//    assert.Lessf(t, 1, 2, "error message %s", "formatted")
-//    assert.Lessf(t, float64(1, "error message %s", "formatted"), float64(2))
-//    assert.Lessf(t, "a", "b", "error message %s", "formatted")
-func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-	return Less(t, e1, e2, append([]interface{}{msg}, args...)...)
-}
-
-// LessOrEqualf asserts that the first element is less than or equal to the second
-//
-//    assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted")
-//    assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted")
-//    assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted")
-//    assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted")
-func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-	return LessOrEqual(t, e1, e2, append([]interface{}{msg}, args...)...)
-}
-
 // Nilf asserts that the specified object is nil.
 //
 //    assert.Nilf(t, err, "error message %s", "formatted")
@@ -513,19 +444,6 @@ func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...in
 	return Regexp(t, rx, str, append([]interface{}{msg}, args...)...)
 }
 
-// Samef asserts that two pointers reference the same object.
-//
-//    assert.Samef(t, ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func Samef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-	return Same(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
 // Subsetf asserts that the specified list(array, slice...) contains all
 // elements given in the specified subset(array, slice...).
 //

vendor/github.com/stretchr/testify/assert/assertion_forward.go

@@ -215,28 +215,6 @@ func (a *Assertions) Errorf(err error, msg string, args ...interface{}) bool {
 	return Errorf(a.t, err, msg, args...)
 }
 
-// Eventually asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-//    a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond)
-func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return Eventually(a.t, condition, waitFor, tick, msgAndArgs...)
-}
-
-// Eventuallyf asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-//    a.Eventuallyf(func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func (a *Assertions) Eventuallyf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return Eventuallyf(a.t, condition, waitFor, tick, msg, args...)
-}
-
 // Exactly asserts that two objects are equal in value and type.
 //
 //    a.Exactly(int32(123), int64(123))
@@ -325,56 +303,6 @@ func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) b
 	return FileExistsf(a.t, path, msg, args...)
 }
 
-// Greater asserts that the first element is greater than the second
-//
-//    a.Greater(2, 1)
-//    a.Greater(float64(2), float64(1))
-//    a.Greater("b", "a")
-func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return Greater(a.t, e1, e2, msgAndArgs...)
-}
-
-// GreaterOrEqual asserts that the first element is greater than or equal to the second
-//
-//    a.GreaterOrEqual(2, 1)
-//    a.GreaterOrEqual(2, 2)
-//    a.GreaterOrEqual("b", "a")
-//    a.GreaterOrEqual("b", "b")
-func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return GreaterOrEqual(a.t, e1, e2, msgAndArgs...)
-}
-
-// GreaterOrEqualf asserts that the first element is greater than or equal to the second
-//
-//    a.GreaterOrEqualf(2, 1, "error message %s", "formatted")
-//    a.GreaterOrEqualf(2, 2, "error message %s", "formatted")
-//    a.GreaterOrEqualf("b", "a", "error message %s", "formatted")
-//    a.GreaterOrEqualf("b", "b", "error message %s", "formatted")
-func (a *Assertions) GreaterOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return GreaterOrEqualf(a.t, e1, e2, msg, args...)
-}
-
-// Greaterf asserts that the first element is greater than the second
-//
-//    a.Greaterf(2, 1, "error message %s", "formatted")
-//    a.Greaterf(float64(2, "error message %s", "formatted"), float64(1))
-//    a.Greaterf("b", "a", "error message %s", "formatted")
-func (a *Assertions) Greaterf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return Greaterf(a.t, e1, e2, msg, args...)
-}
-
 // HTTPBodyContains asserts that a specified handler returns a
 // body that contains a string.
 //
@@ -639,22 +567,6 @@ func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ..
 	return JSONEqf(a.t, expected, actual, msg, args...)
 }
 
-// YAMLEq asserts that two YAML strings are equivalent.
-func (a *Assertions) YAMLEq(expected string, actual string, msgAndArgs ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return YAMLEq(a.t, expected, actual, msgAndArgs...)
-}
-
-// YAMLEqf asserts that two YAML strings are equivalent.
-func (a *Assertions) YAMLEqf(expected string, actual string, msg string, args ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return YAMLEqf(a.t, expected, actual, msg, args...)
-}
-
 // Len asserts that the specified object has specific length.
 // Len also fails if the object has a type that len() not accept.
 //
@@ -677,56 +589,6 @@ func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...in
 	return Lenf(a.t, object, length, msg, args...)
 }
 
-// Less asserts that the first element is less than the second
-//
-//    a.Less(1, 2)
-//    a.Less(float64(1), float64(2))
-//    a.Less("a", "b")
-func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return Less(a.t, e1, e2, msgAndArgs...)
-}
-
-// LessOrEqual asserts that the first element is less than or equal to the second
-//
-//    a.LessOrEqual(1, 2)
-//    a.LessOrEqual(2, 2)
-//    a.LessOrEqual("a", "b")
-//    a.LessOrEqual("b", "b")
-func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return LessOrEqual(a.t, e1, e2, msgAndArgs...)
-}
-
-// LessOrEqualf asserts that the first element is less than or equal to the second
-//
-//    a.LessOrEqualf(1, 2, "error message %s", "formatted")
-//    a.LessOrEqualf(2, 2, "error message %s", "formatted")
-//    a.LessOrEqualf("a", "b", "error message %s", "formatted")
-//    a.LessOrEqualf("b", "b", "error message %s", "formatted")
-func (a *Assertions) LessOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return LessOrEqualf(a.t, e1, e2, msg, args...)
-}
-
-// Lessf asserts that the first element is less than the second
-//
-//    a.Lessf(1, 2, "error message %s", "formatted")
-//    a.Lessf(float64(1, "error message %s", "formatted"), float64(2))
-//    a.Lessf("a", "b", "error message %s", "formatted")
-func (a *Assertions) Lessf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return Lessf(a.t, e1, e2, msg, args...)
-}
-
 // Nil asserts that the specified object is nil.
 //
 //    a.Nil(err)
@@ -1015,32 +877,6 @@ func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args .
 	return Regexpf(a.t, rx, str, msg, args...)
 }
 
-// Same asserts that two pointers reference the same object.
-//
-//    a.Same(ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) Same(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return Same(a.t, expected, actual, msgAndArgs...)
-}
-
-// Samef asserts that two pointers reference the same object.
-//
-//    a.Samef(ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) Samef(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
-	if h, ok := a.t.(tHelper); ok {
-		h.Helper()
-	}
-	return Samef(a.t, expected, actual, msg, args...)
-}
-
 // Subset asserts that the specified list(array, slice...) contains all
 // elements given in the specified subset(array, slice...).
 //

vendor/github.com/stretchr/testify/assert/assertion_order.go

@@ -1,309 +0,0 @@
-package assert
-
-import (
-	"fmt"
-	"reflect"
-)
-
-func compare(obj1, obj2 interface{}, kind reflect.Kind) (int, bool) {
-	switch kind {
-	case reflect.Int:
-		{
-			intobj1 := obj1.(int)
-			intobj2 := obj2.(int)
-			if intobj1 > intobj2 {
-				return -1, true
-			}
-			if intobj1 == intobj2 {
-				return 0, true
-			}
-			if intobj1 < intobj2 {
-				return 1, true
-			}
-		}
-	case reflect.Int8:
-		{
-			int8obj1 := obj1.(int8)
-			int8obj2 := obj2.(int8)
-			if int8obj1 > int8obj2 {
-				return -1, true
-			}
-			if int8obj1 == int8obj2 {
-				return 0, true
-			}
-			if int8obj1 < int8obj2 {
-				return 1, true
-			}
-		}
-	case reflect.Int16:
-		{
-			int16obj1 := obj1.(int16)
-			int16obj2 := obj2.(int16)
-			if int16obj1 > int16obj2 {
-				return -1, true
-			}
-			if int16obj1 == int16obj2 {
-				return 0, true
-			}
-			if int16obj1 < int16obj2 {
-				return 1, true
-			}
-		}
-	case reflect.Int32:
-		{
-			int32obj1 := obj1.(int32)
-			int32obj2 := obj2.(int32)
-			if int32obj1 > int32obj2 {
-				return -1, true
-			}
-			if int32obj1 == int32obj2 {
-				return 0, true
-			}
-			if int32obj1 < int32obj2 {
-				return 1, true
-			}
-		}
-	case reflect.Int64:
-		{
-			int64obj1 := obj1.(int64)
-			int64obj2 := obj2.(int64)
-			if int64obj1 > int64obj2 {
-				return -1, true
-			}
-			if int64obj1 == int64obj2 {
-				return 0, true
-			}
-			if int64obj1 < int64obj2 {
-				return 1, true
-			}
-		}
-	case reflect.Uint:
-		{
-			uintobj1 := obj1.(uint)
-			uintobj2 := obj2.(uint)
-			if uintobj1 > uintobj2 {
-				return -1, true
-			}
-			if uintobj1 == uintobj2 {
-				return 0, true
-			}
-			if uintobj1 < uintobj2 {
-				return 1, true
-			}
-		}
-	case reflect.Uint8:
-		{
-			uint8obj1 := obj1.(uint8)
-			uint8obj2 := obj2.(uint8)
-			if uint8obj1 > uint8obj2 {
-				return -1, true
-			}
-			if uint8obj1 == uint8obj2 {
-				return 0, true
-			}
-			if uint8obj1 < uint8obj2 {
-				return 1, true
-			}
-		}
-	case reflect.Uint16:
-		{
-			uint16obj1 := obj1.(uint16)
-			uint16obj2 := obj2.(uint16)
-			if uint16obj1 > uint16obj2 {
-				return -1, true
-			}
-			if uint16obj1 == uint16obj2 {
-				return 0, true
-			}
-			if uint16obj1 < uint16obj2 {
-				return 1, true
-			}
-		}
-	case reflect.Uint32:
-		{
-			uint32obj1 := obj1.(uint32)
-			uint32obj2 := obj2.(uint32)
-			if uint32obj1 > uint32obj2 {
-				return -1, true
-			}
-			if uint32obj1 == uint32obj2 {
-				return 0, true
-			}
-			if uint32obj1 < uint32obj2 {
-				return 1, true
-			}
-		}
-	case reflect.Uint64:
-		{
-			uint64obj1 := obj1.(uint64)
-			uint64obj2 := obj2.(uint64)
-			if uint64obj1 > uint64obj2 {
-				return -1, true
-			}
-			if uint64obj1 == uint64obj2 {
-				return 0, true
-			}
-			if uint64obj1 < uint64obj2 {
-				return 1, true
-			}
-		}
-	case reflect.Float32:
-		{
-			float32obj1 := obj1.(float32)
-			float32obj2 := obj2.(float32)
-			if float32obj1 > float32obj2 {
-				return -1, true
-			}
-			if float32obj1 == float32obj2 {
-				return 0, true
-			}
-			if float32obj1 < float32obj2 {
-				return 1, true
-			}
-		}
-	case reflect.Float64:
-		{
-			float64obj1 := obj1.(float64)
-			float64obj2 := obj2.(float64)
-			if float64obj1 > float64obj2 {
-				return -1, true
-			}
-			if float64obj1 == float64obj2 {
-				return 0, true
-			}
-			if float64obj1 < float64obj2 {
-				return 1, true
-			}
-		}
-	case reflect.String:
-		{
-			stringobj1 := obj1.(string)
-			stringobj2 := obj2.(string)
-			if stringobj1 > stringobj2 {
-				return -1, true
-			}
-			if stringobj1 == stringobj2 {
-				return 0, true
-			}
-			if stringobj1 < stringobj2 {
-				return 1, true
-			}
-		}
-	}
-
-	return 0, false
-}
-
-// Greater asserts that the first element is greater than the second
-//
-//    assert.Greater(t, 2, 1)
-//    assert.Greater(t, float64(2), float64(1))
-//    assert.Greater(t, "b", "a")
-func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-
-	e1Kind := reflect.ValueOf(e1).Kind()
-	e2Kind := reflect.ValueOf(e2).Kind()
-	if e1Kind != e2Kind {
-		return Fail(t, "Elements should be the same type", msgAndArgs...)
-	}
-
-	res, isComparable := compare(e1, e2, e1Kind)
-	if !isComparable {
-		return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...)
-	}
-
-	if res != -1 {
-		return Fail(t, fmt.Sprintf("\"%v\" is not greater than \"%v\"", e1, e2), msgAndArgs...)
-	}
-
-	return true
-}
-
-// GreaterOrEqual asserts that the first element is greater than or equal to the second
-//
-//    assert.GreaterOrEqual(t, 2, 1)
-//    assert.GreaterOrEqual(t, 2, 2)
-//    assert.GreaterOrEqual(t, "b", "a")
-//    assert.GreaterOrEqual(t, "b", "b")
-func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-
-	e1Kind := reflect.ValueOf(e1).Kind()
-	e2Kind := reflect.ValueOf(e2).Kind()
-	if e1Kind != e2Kind {
-		return Fail(t, "Elements should be the same type", msgAndArgs...)
-	}
-
-	res, isComparable := compare(e1, e2, e1Kind)
-	if !isComparable {
-		return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...)
-	}
-
-	if res != -1 && res != 0 {
-		return Fail(t, fmt.Sprintf("\"%v\" is not greater than or equal to \"%v\"", e1, e2), msgAndArgs...)
-	}
-
-	return true
-}
-
-// Less asserts that the first element is less than the second
-//
-//    assert.Less(t, 1, 2)
-//    assert.Less(t, float64(1), float64(2))
-//    assert.Less(t, "a", "b")
-func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-
-	e1Kind := reflect.ValueOf(e1).Kind()
-	e2Kind := reflect.ValueOf(e2).Kind()
-	if e1Kind != e2Kind {
-		return Fail(t, "Elements should be the same type", msgAndArgs...)
-	}
-
-	res, isComparable := compare(e1, e2, e1Kind)
-	if !isComparable {
-		return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...)
-	}
-
-	if res != 1 {
-		return Fail(t, fmt.Sprintf("\"%v\" is not less than \"%v\"", e1, e2), msgAndArgs...)
-	}
-
-	return true
-}
-
-// LessOrEqual asserts that the first element is less than or equal to the second
-//
-//    assert.LessOrEqual(t, 1, 2)
-//    assert.LessOrEqual(t, 2, 2)
-//    assert.LessOrEqual(t, "a", "b")
-//    assert.LessOrEqual(t, "b", "b")
-func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-
-	e1Kind := reflect.ValueOf(e1).Kind()
-	e2Kind := reflect.ValueOf(e2).Kind()
-	if e1Kind != e2Kind {
-		return Fail(t, "Elements should be the same type", msgAndArgs...)
-	}
-
-	res, isComparable := compare(e1, e2, e1Kind)
-	if !isComparable {
-		return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...)
-	}
-
-	if res != 1 && res != 0 {
-		return Fail(t, fmt.Sprintf("\"%v\" is not less than or equal to \"%v\"", e1, e2), msgAndArgs...)
-	}
-
-	return true
-}

vendor/github.com/stretchr/testify/assert/assertions.go

@@ -18,7 +18,6 @@ import (
 
 	"github.com/davecgh/go-spew/spew"
 	"github.com/pmezard/go-difflib/difflib"
-	yaml "gopkg.in/yaml.v2"
 )
 
 //go:generate go run ../_codegen/main.go -output-package=assert -template=assertion_format.go.tmpl
@@ -351,37 +350,6 @@ func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{})
 
 }
 
-// Same asserts that two pointers reference the same object.
-//
-//    assert.Same(t, ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func Same(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-
-	expectedPtr, actualPtr := reflect.ValueOf(expected), reflect.ValueOf(actual)
-	if expectedPtr.Kind() != reflect.Ptr || actualPtr.Kind() != reflect.Ptr {
-		return Fail(t, "Invalid operation: both arguments must be pointers", msgAndArgs...)
-	}
-
-	expectedType, actualType := reflect.TypeOf(expected), reflect.TypeOf(actual)
-	if expectedType != actualType {
-		return Fail(t, fmt.Sprintf("Pointer expected to be of type %v, but was %v",
-			expectedType, actualType), msgAndArgs...)
-	}
-
-	if expected != actual {
-		return Fail(t, fmt.Sprintf("Not same: \n"+
-			"expected: %p %#v\n"+
-			"actual  : %p %#v", expected, expected, actual, actual), msgAndArgs...)
-	}
-
-	return true
-}
-
 // formatUnequalValues takes two values of arbitrary types and returns string
 // representations appropriate to be presented to the user.
 //
@@ -511,14 +479,14 @@ func isEmpty(object interface{}) bool {
 	// collection types are empty when they have no element
 	case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice:
 		return objValue.Len() == 0
-		// pointers are empty if nil or if the value they point to is empty
+	// pointers are empty if nil or if the value they point to is empty
 	case reflect.Ptr:
 		if objValue.IsNil() {
 			return true
 		}
 		deref := objValue.Elem().Interface()
 		return isEmpty(deref)
-		// for all other types, compare against the zero value
+	// for all other types, compare against the zero value
 	default:
 		zero := reflect.Zero(objValue.Type())
 		return reflect.DeepEqual(object, zero.Interface())
@@ -661,7 +629,7 @@ func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{
 func includeElement(list interface{}, element interface{}) (ok, found bool) {
 
 	listValue := reflect.ValueOf(list)
-	listKind := reflect.TypeOf(list).Kind()
+	elementValue := reflect.ValueOf(element)
 	defer func() {
 		if e := recover(); e != nil {
 			ok = false
@@ -669,12 +637,11 @@ func includeElement(list interface{}, element interface{}) (ok, found bool) {
 		}
 	}()
 
-	if listKind == reflect.String {
-		elementValue := reflect.ValueOf(element)
+	if reflect.TypeOf(list).Kind() == reflect.String {
 		return true, strings.Contains(listValue.String(), elementValue.String())
 	}
 
-	if listKind == reflect.Map {
+	if reflect.TypeOf(list).Kind() == reflect.Map {
 		mapKeys := listValue.MapKeys()
 		for i := 0; i < len(mapKeys); i++ {
 			if ObjectsAreEqual(mapKeys[i].Interface(), element) {
@@ -1370,24 +1337,6 @@ func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{
 	return Equal(t, expectedJSONAsInterface, actualJSONAsInterface, msgAndArgs...)
 }
 
-// YAMLEq asserts that two YAML strings are equivalent.
-func YAMLEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-	var expectedYAMLAsInterface, actualYAMLAsInterface interface{}
-
-	if err := yaml.Unmarshal([]byte(expected), &expectedYAMLAsInterface); err != nil {
-		return Fail(t, fmt.Sprintf("Expected value ('%s') is not valid yaml.\nYAML parsing error: '%s'", expected, err.Error()), msgAndArgs...)
-	}
-
-	if err := yaml.Unmarshal([]byte(actual), &actualYAMLAsInterface); err != nil {
-		return Fail(t, fmt.Sprintf("Input ('%s') needs to be valid yaml.\nYAML error: '%s'", actual, err.Error()), msgAndArgs...)
-	}
-
-	return Equal(t, expectedYAMLAsInterface, actualYAMLAsInterface, msgAndArgs...)
-}
-
 func typeAndKind(v interface{}) (reflect.Type, reflect.Kind) {
 	t := reflect.TypeOf(v)
 	k := t.Kind()
@@ -1422,8 +1371,8 @@ func diff(expected interface{}, actual interface{}) string {
 		e = spewConfig.Sdump(expected)
 		a = spewConfig.Sdump(actual)
 	} else {
-		e = reflect.ValueOf(expected).String()
-		a = reflect.ValueOf(actual).String()
+		e = expected.(string)
+		a = actual.(string)
 	}
 
 	diff, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{
@@ -1465,34 +1414,3 @@ var spewConfig = spew.ConfigState{
 type tHelper interface {
 	Helper()
 }
-
-// Eventually asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-//    assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond)
-func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
-	if h, ok := t.(tHelper); ok {
-		h.Helper()
-	}
-
-	timer := time.NewTimer(waitFor)
-	ticker := time.NewTicker(tick)
-	checkPassed := make(chan bool)
-	defer timer.Stop()
-	defer ticker.Stop()
-	defer close(checkPassed)
-	for {
-		select {
-		case <-timer.C:
-			return Fail(t, "Condition never satisfied", msgAndArgs...)
-		case result := <-checkPassed:
-			if result {
-				return true
-			}
-		case <-ticker.C:
-			go func() {
-				checkPassed <- condition()
-			}()
-		}
-	}
-}

vendor/golang.org/x/crypto/scrypt/scrypt.go

@@ -10,7 +10,6 @@ package scrypt // import "golang.org/x/crypto/scrypt"
 import (
 	"crypto/sha256"
 	"errors"
-	"math/bits"
 
 	"golang.org/x/crypto/pbkdf2"
 )
@@ -30,7 +29,7 @@ func blockXOR(dst, src []uint32, n int) {
 }
 
 // salsaXOR applies Salsa20/8 to the XOR of 16 numbers from tmp and in,
-// and puts the result into both tmp and out.
+// and puts the result into both both tmp and out.
 func salsaXOR(tmp *[16]uint32, in, out []uint32) {
 	w0 := tmp[0] ^ in[0]
 	w1 := tmp[1] ^ in[1]
@@ -53,45 +52,77 @@ func salsaXOR(tmp *[16]uint32, in, out []uint32) {
 	x9, x10, x11, x12, x13, x14, x15 := w9, w10, w11, w12, w13, w14, w15
 
 	for i := 0; i < 8; i += 2 {
-		x4 ^= bits.RotateLeft32(x0+x12, 7)
-		x8 ^= bits.RotateLeft32(x4+x0, 9)
-		x12 ^= bits.RotateLeft32(x8+x4, 13)
-		x0 ^= bits.RotateLeft32(x12+x8, 18)
+		u := x0 + x12
+		x4 ^= u<<7 | u>>(32-7)
+		u = x4 + x0
+		x8 ^= u<<9 | u>>(32-9)
+		u = x8 + x4
+		x12 ^= u<<13 | u>>(32-13)
+		u = x12 + x8
+		x0 ^= u<<18 | u>>(32-18)
 
-		x9 ^= bits.RotateLeft32(x5+x1, 7)
-		x13 ^= bits.RotateLeft32(x9+x5, 9)
-		x1 ^= bits.RotateLeft32(x13+x9, 13)
-		x5 ^= bits.RotateLeft32(x1+x13, 18)
+		u = x5 + x1
+		x9 ^= u<<7 | u>>(32-7)
+		u = x9 + x5
+		x13 ^= u<<9 | u>>(32-9)
+		u = x13 + x9
+		x1 ^= u<<13 | u>>(32-13)
+		u = x1 + x13
+		x5 ^= u<<18 | u>>(32-18)
 
-		x14 ^= bits.RotateLeft32(x10+x6, 7)
-		x2 ^= bits.RotateLeft32(x14+x10, 9)
-		x6 ^= bits.RotateLeft32(x2+x14, 13)
-		x10 ^= bits.RotateLeft32(x6+x2, 18)
+		u = x10 + x6
+		x14 ^= u<<7 | u>>(32-7)
+		u = x14 + x10
+		x2 ^= u<<9 | u>>(32-9)
+		u = x2 + x14
+		x6 ^= u<<13 | u>>(32-13)
+		u = x6 + x2
+		x10 ^= u<<18 | u>>(32-18)
 
-		x3 ^= bits.RotateLeft32(x15+x11, 7)
-		x7 ^= bits.RotateLeft32(x3+x15, 9)
-		x11 ^= bits.RotateLeft32(x7+x3, 13)
-		x15 ^= bits.RotateLeft32(x11+x7, 18)
+		u = x15 + x11
+		x3 ^= u<<7 | u>>(32-7)
+		u = x3 + x15
+		x7 ^= u<<9 | u>>(32-9)
+		u = x7 + x3
+		x11 ^= u<<13 | u>>(32-13)
+		u = x11 + x7
+		x15 ^= u<<18 | u>>(32-18)
 
-		x1 ^= bits.RotateLeft32(x0+x3, 7)
-		x2 ^= bits.RotateLeft32(x1+x0, 9)
-		x3 ^= bits.RotateLeft32(x2+x1, 13)
-		x0 ^= bits.RotateLeft32(x3+x2, 18)
+		u = x0 + x3
+		x1 ^= u<<7 | u>>(32-7)
+		u = x1 + x0
+		x2 ^= u<<9 | u>>(32-9)
+		u = x2 + x1
+		x3 ^= u<<13 | u>>(32-13)
+		u = x3 + x2
+		x0 ^= u<<18 | u>>(32-18)
 
-		x6 ^= bits.RotateLeft32(x5+x4, 7)
-		x7 ^= bits.RotateLeft32(x6+x5, 9)
-		x4 ^= bits.RotateLeft32(x7+x6, 13)
-		x5 ^= bits.RotateLeft32(x4+x7, 18)
+		u = x5 + x4
+		x6 ^= u<<7 | u>>(32-7)
+		u = x6 + x5
+		x7 ^= u<<9 | u>>(32-9)
+		u = x7 + x6
+		x4 ^= u<<13 | u>>(32-13)
+		u = x4 + x7
+		x5 ^= u<<18 | u>>(32-18)
 
-		x11 ^= bits.RotateLeft32(x10+x9, 7)
-		x8 ^= bits.RotateLeft32(x11+x10, 9)
-		x9 ^= bits.RotateLeft32(x8+x11, 13)
-		x10 ^= bits.RotateLeft32(x9+x8, 18)
+		u = x10 + x9
+		x11 ^= u<<7 | u>>(32-7)
+		u = x11 + x10
+		x8 ^= u<<9 | u>>(32-9)
+		u = x8 + x11
+		x9 ^= u<<13 | u>>(32-13)
+		u = x9 + x8
+		x10 ^= u<<18 | u>>(32-18)
 
-		x12 ^= bits.RotateLeft32(x15+x14, 7)
-		x13 ^= bits.RotateLeft32(x12+x15, 9)
-		x14 ^= bits.RotateLeft32(x13+x12, 13)
-		x15 ^= bits.RotateLeft32(x14+x13, 18)
+		u = x15 + x14
+		x12 ^= u<<7 | u>>(32-7)
+		u = x12 + x15
+		x13 ^= u<<9 | u>>(32-9)
+		u = x13 + x12
+		x14 ^= u<<13 | u>>(32-13)
+		u = x14 + x13
+		x15 ^= u<<18 | u>>(32-18)
 	}
 	x0 += w0
 	x1 += w1

vendor/golang.org/x/crypto/ssh/terminal/terminal.go

@@ -7,7 +7,6 @@ package terminal
 import (
 	"bytes"
 	"io"
-	"strconv"
 	"sync"
 	"unicode/utf8"
 )
@@ -160,10 +159,6 @@ func bytesToKey(b []byte, pasteActive bool) (rune, []byte) {
 			return keyClearScreen, b[1:]
 		case 23: // ^W
 			return keyDeleteWord, b[1:]
-		case 14: // ^N
-			return keyDown, b[1:]
-		case 16: // ^P
-			return keyUp, b[1:]
 		}
 	}
 
@@ -272,44 +267,34 @@ func (t *Terminal) moveCursorToPos(pos int) {
 }
 
 func (t *Terminal) move(up, down, left, right int) {
-	m := []rune{}
-
-	// 1 unit up can be expressed as ^[[A or ^[A
-	// 5 units up can be expressed as ^[[5A
-
-	if up == 1 {
-		m = append(m, keyEscape, '[', 'A')
-	} else if up > 1 {
-		m = append(m, keyEscape, '[')
-		m = append(m, []rune(strconv.Itoa(up))...)
-		m = append(m, 'A')
+	movement := make([]rune, 3*(up+down+left+right))
+	m := movement
+	for i := 0; i < up; i++ {
+		m[0] = keyEscape
+		m[1] = '['
+		m[2] = 'A'
+		m = m[3:]
+	}
+	for i := 0; i < down; i++ {
+		m[0] = keyEscape
+		m[1] = '['
+		m[2] = 'B'
+		m = m[3:]
+	}
+	for i := 0; i < left; i++ {
+		m[0] = keyEscape
+		m[1] = '['
+		m[2] = 'D'
+		m = m[3:]
+	}
+	for i := 0; i < right; i++ {
+		m[0] = keyEscape
+		m[1] = '['
+		m[2] = 'C'
+		m = m[3:]
 	}
 
-	if down == 1 {
-		m = append(m, keyEscape, '[', 'B')
-	} else if down > 1 {
-		m = append(m, keyEscape, '[')
-		m = append(m, []rune(strconv.Itoa(down))...)
-		m = append(m, 'B')
-	}
-
-	if right == 1 {
-		m = append(m, keyEscape, '[', 'C')
-	} else if right > 1 {
-		m = append(m, keyEscape, '[')
-		m = append(m, []rune(strconv.Itoa(right))...)
-		m = append(m, 'C')
-	}
-
-	if left == 1 {
-		m = append(m, keyEscape, '[', 'D')
-	} else if left > 1 {
-		m = append(m, keyEscape, '[')
-		m = append(m, []rune(strconv.Itoa(left))...)
-		m = append(m, 'D')
-	}
-
-	t.queue(m)
+	t.queue(movement)
 }
 
 func (t *Terminal) clearLineToRight() {

vendor/golang.org/x/crypto/ssh/terminal/util.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix darwin dragonfly freebsd linux,!appengine netbsd openbsd
+// +build darwin dragonfly freebsd linux,!appengine netbsd openbsd
 
 // Package terminal provides support functions for dealing with terminals, as
 // commonly found on UNIX systems.
@@ -25,7 +25,7 @@ type State struct {
 	termios unix.Termios
 }
 
-// IsTerminal returns whether the given file descriptor is a terminal.
+// IsTerminal returns true if the given file descriptor is a terminal.
 func IsTerminal(fd int) bool {
 	_, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
 	return err == nil

vendor/golang.org/x/crypto/ssh/terminal/util_aix.go

@@ -1,12 +0,0 @@
-// Copyright 2018 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.
-
-// +build aix
-
-package terminal
-
-import "golang.org/x/sys/unix"
-
-const ioctlReadTermios = unix.TCGETS
-const ioctlWriteTermios = unix.TCSETS

vendor/golang.org/x/crypto/ssh/terminal/util_plan9.go

@@ -21,7 +21,7 @@ import (
 
 type State struct{}
 
-// IsTerminal returns whether the given file descriptor is a terminal.
+// IsTerminal returns true if the given file descriptor is a terminal.
 func IsTerminal(fd int) bool {
 	return false
 }

vendor/golang.org/x/crypto/ssh/terminal/util_solaris.go

@@ -17,7 +17,7 @@ type State struct {
 	termios unix.Termios
 }
 
-// IsTerminal returns whether the given file descriptor is a terminal.
+// IsTerminal returns true if the given file descriptor is a terminal.
 func IsTerminal(fd int) bool {
 	_, err := unix.IoctlGetTermio(fd, unix.TCGETA)
 	return err == nil

vendor/golang.org/x/crypto/ssh/terminal/util_windows.go

@@ -26,7 +26,7 @@ type State struct {
 	mode uint32
 }
 
-// IsTerminal returns whether the given file descriptor is a terminal.
+// IsTerminal returns true if the given file descriptor is a terminal.
 func IsTerminal(fd int) bool {
 	var st uint32
 	err := windows.GetConsoleMode(windows.Handle(fd), &st)
@@ -64,15 +64,13 @@ func Restore(fd int, state *State) error {
 	return windows.SetConsoleMode(windows.Handle(fd), state.mode)
 }
 
-// GetSize returns the visible dimensions of the given terminal.
-//
-// These dimensions don't include any scrollback buffer height.
+// GetSize returns the dimensions of the given terminal.
 func GetSize(fd int) (width, height int, err error) {
 	var info windows.ConsoleScreenBufferInfo
 	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(fd), &info); err != nil {
 		return 0, 0, err
 	}
-	return int(info.Window.Right - info.Window.Left + 1), int(info.Window.Bottom - info.Window.Top + 1), nil
+	return int(info.Size.X), int(info.Size.Y), nil
 }
 
 // ReadPassword reads a line of input from a terminal without local echo.  This

vendor/golang.org/x/net/AUTHORS

@@ -0,0 +1,3 @@
+# This source code refers to The Go Authors for copyright purposes.
+# The master list of authors is in the main Go distribution,
+# visible at http://tip.golang.org/AUTHORS.

vendor/golang.org/x/net/CONTRIBUTORS

@@ -0,0 +1,3 @@
+# This source code was written by the Go contributors.
+# The master list of contributors is in the main Go distribution,
+# visible at http://tip.golang.org/CONTRIBUTORS.

vendor/golang.org/x/net/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2019 The Go Authors. All rights reserved.
+Copyright (c) 2009 The Go Authors. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are

vendor/golang.org/x/net/context/context.go

@@ -0,0 +1,56 @@
+// Copyright 2014 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 context defines the Context type, which carries deadlines,
+// cancelation signals, and other request-scoped values across API boundaries
+// and between processes.
+// As of Go 1.7 this package is available in the standard library under the
+// name context.  https://golang.org/pkg/context.
+//
+// Incoming requests to a server should create a Context, and outgoing calls to
+// servers should accept a Context. The chain of function calls between must
+// propagate the Context, optionally replacing it with a modified copy created
+// using WithDeadline, WithTimeout, WithCancel, or WithValue.
+//
+// Programs that use Contexts should follow these rules to keep interfaces
+// consistent across packages and enable static analysis tools to check context
+// propagation:
+//
+// Do not store Contexts inside a struct type; instead, pass a Context
+// explicitly to each function that needs it. The Context should be the first
+// parameter, typically named ctx:
+//
+// 	func DoSomething(ctx context.Context, arg Arg) error {
+// 		// ... use ctx ...
+// 	}
+//
+// Do not pass a nil Context, even if a function permits it. Pass context.TODO
+// if you are unsure about which Context to use.
+//
+// Use context Values only for request-scoped data that transits processes and
+// APIs, not for passing optional parameters to functions.
+//
+// The same Context may be passed to functions running in different goroutines;
+// Contexts are safe for simultaneous use by multiple goroutines.
+//
+// See http://blog.golang.org/context for example code for a server that uses
+// Contexts.
+package context // import "golang.org/x/net/context"
+
+// Background returns a non-nil, empty Context. It is never canceled, has no
+// values, and has no deadline. It is typically used by the main function,
+// initialization, and tests, and as the top-level Context for incoming
+// requests.
+func Background() Context {
+	return background
+}
+
+// TODO returns a non-nil, empty Context. Code should use context.TODO when
+// it's unclear which Context to use or it is not yet available (because the
+// surrounding function has not yet been extended to accept a Context
+// parameter).  TODO is recognized by static analysis tools that determine
+// whether Contexts are propagated correctly in a program.
+func TODO() Context {
+	return todo
+}

vendor/golang.org/x/net/context/go17.go

@@ -0,0 +1,72 @@
+// Copyright 2016 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.
+
+// +build go1.7
+
+package context
+
+import (
+	"context" // standard library's context, as of Go 1.7
+	"time"
+)
+
+var (
+	todo       = context.TODO()
+	background = context.Background()
+)
+
+// Canceled is the error returned by Context.Err when the context is canceled.
+var Canceled = context.Canceled
+
+// DeadlineExceeded is the error returned by Context.Err when the context's
+// deadline passes.
+var DeadlineExceeded = context.DeadlineExceeded
+
+// WithCancel returns a copy of parent with a new Done channel. The returned
+// context's Done channel is closed when the returned cancel function is called
+// or when the parent context's Done channel is closed, whichever happens first.
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete.
+func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
+	ctx, f := context.WithCancel(parent)
+	return ctx, CancelFunc(f)
+}
+
+// WithDeadline returns a copy of the parent context with the deadline adjusted
+// to be no later than d. If the parent's deadline is already earlier than d,
+// WithDeadline(parent, d) is semantically equivalent to parent. The returned
+// context's Done channel is closed when the deadline expires, when the returned
+// cancel function is called, or when the parent context's Done channel is
+// closed, whichever happens first.
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete.
+func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) {
+	ctx, f := context.WithDeadline(parent, deadline)
+	return ctx, CancelFunc(f)
+}
+
+// WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)).
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete:
+//
+// 	func slowOperationWithTimeout(ctx context.Context) (Result, error) {
+// 		ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
+// 		defer cancel()  // releases resources if slowOperation completes before timeout elapses
+// 		return slowOperation(ctx)
+// 	}
+func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
+	return WithDeadline(parent, time.Now().Add(timeout))
+}
+
+// WithValue returns a copy of parent in which the value associated with key is
+// val.
+//
+// Use context Values only for request-scoped data that transits processes and
+// APIs, not for passing optional parameters to functions.
+func WithValue(parent Context, key interface{}, val interface{}) Context {
+	return context.WithValue(parent, key, val)
+}

vendor/golang.org/x/net/context/go19.go

@@ -0,0 +1,20 @@
+// Copyright 2017 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.
+
+// +build go1.9
+
+package context
+
+import "context" // standard library's context, as of Go 1.7
+
+// A Context carries a deadline, a cancelation signal, and other values across
+// API boundaries.
+//
+// Context's methods may be called by multiple goroutines simultaneously.
+type Context = context.Context
+
+// A CancelFunc tells an operation to abandon its work.
+// A CancelFunc does not wait for the work to stop.
+// After the first call, subsequent calls to a CancelFunc do nothing.
+type CancelFunc = context.CancelFunc

vendor/golang.org/x/net/context/pre_go17.go

@@ -0,0 +1,300 @@
+// Copyright 2014 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.
+
+// +build !go1.7
+
+package context
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+)
+
+// An emptyCtx is never canceled, has no values, and has no deadline. It is not
+// struct{}, since vars of this type must have distinct addresses.
+type emptyCtx int
+
+func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
+	return
+}
+
+func (*emptyCtx) Done() <-chan struct{} {
+	return nil
+}
+
+func (*emptyCtx) Err() error {
+	return nil
+}
+
+func (*emptyCtx) Value(key interface{}) interface{} {
+	return nil
+}
+
+func (e *emptyCtx) String() string {
+	switch e {
+	case background:
+		return "context.Background"
+	case todo:
+		return "context.TODO"
+	}
+	return "unknown empty Context"
+}
+
+var (
+	background = new(emptyCtx)
+	todo       = new(emptyCtx)
+)
+
+// Canceled is the error returned by Context.Err when the context is canceled.
+var Canceled = errors.New("context canceled")
+
+// DeadlineExceeded is the error returned by Context.Err when the context's
+// deadline passes.
+var DeadlineExceeded = errors.New("context deadline exceeded")
+
+// WithCancel returns a copy of parent with a new Done channel. The returned
+// context's Done channel is closed when the returned cancel function is called
+// or when the parent context's Done channel is closed, whichever happens first.
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete.
+func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
+	c := newCancelCtx(parent)
+	propagateCancel(parent, c)
+	return c, func() { c.cancel(true, Canceled) }
+}
+
+// newCancelCtx returns an initialized cancelCtx.
+func newCancelCtx(parent Context) *cancelCtx {
+	return &cancelCtx{
+		Context: parent,
+		done:    make(chan struct{}),
+	}
+}
+
+// propagateCancel arranges for child to be canceled when parent is.
+func propagateCancel(parent Context, child canceler) {
+	if parent.Done() == nil {
+		return // parent is never canceled
+	}
+	if p, ok := parentCancelCtx(parent); ok {
+		p.mu.Lock()
+		if p.err != nil {
+			// parent has already been canceled
+			child.cancel(false, p.err)
+		} else {
+			if p.children == nil {
+				p.children = make(map[canceler]bool)
+			}
+			p.children[child] = true
+		}
+		p.mu.Unlock()
+	} else {
+		go func() {
+			select {
+			case <-parent.Done():
+				child.cancel(false, parent.Err())
+			case <-child.Done():
+			}
+		}()
+	}
+}
+
+// parentCancelCtx follows a chain of parent references until it finds a
+// *cancelCtx. This function understands how each of the concrete types in this
+// package represents its parent.
+func parentCancelCtx(parent Context) (*cancelCtx, bool) {
+	for {
+		switch c := parent.(type) {
+		case *cancelCtx:
+			return c, true
+		case *timerCtx:
+			return c.cancelCtx, true
+		case *valueCtx:
+			parent = c.Context
+		default:
+			return nil, false
+		}
+	}
+}
+
+// removeChild removes a context from its parent.
+func removeChild(parent Context, child canceler) {
+	p, ok := parentCancelCtx(parent)
+	if !ok {
+		return
+	}
+	p.mu.Lock()
+	if p.children != nil {
+		delete(p.children, child)
+	}
+	p.mu.Unlock()
+}
+
+// A canceler is a context type that can be canceled directly. The
+// implementations are *cancelCtx and *timerCtx.
+type canceler interface {
+	cancel(removeFromParent bool, err error)
+	Done() <-chan struct{}
+}
+
+// A cancelCtx can be canceled. When canceled, it also cancels any children
+// that implement canceler.
+type cancelCtx struct {
+	Context
+
+	done chan struct{} // closed by the first cancel call.
+
+	mu       sync.Mutex
+	children map[canceler]bool // set to nil by the first cancel call
+	err      error             // set to non-nil by the first cancel call
+}
+
+func (c *cancelCtx) Done() <-chan struct{} {
+	return c.done
+}
+
+func (c *cancelCtx) Err() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.err
+}
+
+func (c *cancelCtx) String() string {
+	return fmt.Sprintf("%v.WithCancel", c.Context)
+}
+
+// cancel closes c.done, cancels each of c's children, and, if
+// removeFromParent is true, removes c from its parent's children.
+func (c *cancelCtx) cancel(removeFromParent bool, err error) {
+	if err == nil {
+		panic("context: internal error: missing cancel error")
+	}
+	c.mu.Lock()
+	if c.err != nil {
+		c.mu.Unlock()
+		return // already canceled
+	}
+	c.err = err
+	close(c.done)
+	for child := range c.children {
+		// NOTE: acquiring the child's lock while holding parent's lock.
+		child.cancel(false, err)
+	}
+	c.children = nil
+	c.mu.Unlock()
+
+	if removeFromParent {
+		removeChild(c.Context, c)
+	}
+}
+
+// WithDeadline returns a copy of the parent context with the deadline adjusted
+// to be no later than d. If the parent's deadline is already earlier than d,
+// WithDeadline(parent, d) is semantically equivalent to parent. The returned
+// context's Done channel is closed when the deadline expires, when the returned
+// cancel function is called, or when the parent context's Done channel is
+// closed, whichever happens first.
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete.
+func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) {
+	if cur, ok := parent.Deadline(); ok && cur.Before(deadline) {
+		// The current deadline is already sooner than the new one.
+		return WithCancel(parent)
+	}
+	c := &timerCtx{
+		cancelCtx: newCancelCtx(parent),
+		deadline:  deadline,
+	}
+	propagateCancel(parent, c)
+	d := deadline.Sub(time.Now())
+	if d <= 0 {
+		c.cancel(true, DeadlineExceeded) // deadline has already passed
+		return c, func() { c.cancel(true, Canceled) }
+	}
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.err == nil {
+		c.timer = time.AfterFunc(d, func() {
+			c.cancel(true, DeadlineExceeded)
+		})
+	}
+	return c, func() { c.cancel(true, Canceled) }
+}
+
+// A timerCtx carries a timer and a deadline. It embeds a cancelCtx to
+// implement Done and Err. It implements cancel by stopping its timer then
+// delegating to cancelCtx.cancel.
+type timerCtx struct {
+	*cancelCtx
+	timer *time.Timer // Under cancelCtx.mu.
+
+	deadline time.Time
+}
+
+func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
+	return c.deadline, true
+}
+
+func (c *timerCtx) String() string {
+	return fmt.Sprintf("%v.WithDeadline(%s [%s])", c.cancelCtx.Context, c.deadline, c.deadline.Sub(time.Now()))
+}
+
+func (c *timerCtx) cancel(removeFromParent bool, err error) {
+	c.cancelCtx.cancel(false, err)
+	if removeFromParent {
+		// Remove this timerCtx from its parent cancelCtx's children.
+		removeChild(c.cancelCtx.Context, c)
+	}
+	c.mu.Lock()
+	if c.timer != nil {
+		c.timer.Stop()
+		c.timer = nil
+	}
+	c.mu.Unlock()
+}
+
+// WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)).
+//
+// Canceling this context releases resources associated with it, so code should
+// call cancel as soon as the operations running in this Context complete:
+//
+// 	func slowOperationWithTimeout(ctx context.Context) (Result, error) {
+// 		ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
+// 		defer cancel()  // releases resources if slowOperation completes before timeout elapses
+// 		return slowOperation(ctx)
+// 	}
+func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
+	return WithDeadline(parent, time.Now().Add(timeout))
+}
+
+// WithValue returns a copy of parent in which the value associated with key is
+// val.
+//
+// Use context Values only for request-scoped data that transits processes and
+// APIs, not for passing optional parameters to functions.
+func WithValue(parent Context, key interface{}, val interface{}) Context {
+	return &valueCtx{parent, key, val}
+}
+
+// A valueCtx carries a key-value pair. It implements Value for that key and
+// delegates all other calls to the embedded Context.
+type valueCtx struct {
+	Context
+	key, val interface{}
+}
+
+func (c *valueCtx) String() string {
+	return fmt.Sprintf("%v.WithValue(%#v, %#v)", c.Context, c.key, c.val)
+}
+
+func (c *valueCtx) Value(key interface{}) interface{} {
+	if c.key == key {
+		return c.val
+	}
+	return c.Context.Value(key)
+}

vendor/golang.org/x/net/context/pre_go19.go

@@ -0,0 +1,109 @@
+// Copyright 2014 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.
+
+// +build !go1.9
+
+package context
+
+import "time"
+
+// A Context carries a deadline, a cancelation signal, and other values across
+// API boundaries.
+//
+// Context's methods may be called by multiple goroutines simultaneously.
+type Context interface {
+	// Deadline returns the time when work done on behalf of this context
+	// should be canceled. Deadline returns ok==false when no deadline is
+	// set. Successive calls to Deadline return the same results.
+	Deadline() (deadline time.Time, ok bool)
+
+	// Done returns a channel that's closed when work done on behalf of this
+	// context should be canceled. Done may return nil if this context can
+	// never be canceled. Successive calls to Done return the same value.
+	//
+	// WithCancel arranges for Done to be closed when cancel is called;
+	// WithDeadline arranges for Done to be closed when the deadline
+	// expires; WithTimeout arranges for Done to be closed when the timeout
+	// elapses.
+	//
+	// Done is provided for use in select statements:
+	//
+	//  // Stream generates values with DoSomething and sends them to out
+	//  // until DoSomething returns an error or ctx.Done is closed.
+	//  func Stream(ctx context.Context, out chan<- Value) error {
+	//  	for {
+	//  		v, err := DoSomething(ctx)
+	//  		if err != nil {
+	//  			return err
+	//  		}
+	//  		select {
+	//  		case <-ctx.Done():
+	//  			return ctx.Err()
+	//  		case out <- v:
+	//  		}
+	//  	}
+	//  }
+	//
+	// See http://blog.golang.org/pipelines for more examples of how to use
+	// a Done channel for cancelation.
+	Done() <-chan struct{}
+
+	// Err returns a non-nil error value after Done is closed. Err returns
+	// Canceled if the context was canceled or DeadlineExceeded if the
+	// context's deadline passed. No other values for Err are defined.
+	// After Done is closed, successive calls to Err return the same value.
+	Err() error
+
+	// Value returns the value associated with this context for key, or nil
+	// if no value is associated with key. Successive calls to Value with
+	// the same key returns the same result.
+	//
+	// Use context values only for request-scoped data that transits
+	// processes and API boundaries, not for passing optional parameters to
+	// functions.
+	//
+	// A key identifies a specific value in a Context. Functions that wish
+	// to store values in Context typically allocate a key in a global
+	// variable then use that key as the argument to context.WithValue and
+	// Context.Value. A key can be any type that supports equality;
+	// packages should define keys as an unexported type to avoid
+	// collisions.
+	//
+	// Packages that define a Context key should provide type-safe accessors
+	// for the values stores using that key:
+	//
+	// 	// Package user defines a User type that's stored in Contexts.
+	// 	package user
+	//
+	// 	import "golang.org/x/net/context"
+	//
+	// 	// User is the type of value stored in the Contexts.
+	// 	type User struct {...}
+	//
+	// 	// key is an unexported type for keys defined in this package.
+	// 	// This prevents collisions with keys defined in other packages.
+	// 	type key int
+	//
+	// 	// userKey is the key for user.User values in Contexts. It is
+	// 	// unexported; clients use user.NewContext and user.FromContext
+	// 	// instead of using this key directly.
+	// 	var userKey key = 0
+	//
+	// 	// NewContext returns a new Context that carries value u.
+	// 	func NewContext(ctx context.Context, u *User) context.Context {
+	// 		return context.WithValue(ctx, userKey, u)
+	// 	}
+	//
+	// 	// FromContext returns the User value stored in ctx, if any.
+	// 	func FromContext(ctx context.Context) (*User, bool) {
+	// 		u, ok := ctx.Value(userKey).(*User)
+	// 		return u, ok
+	// 	}
+	Value(key interface{}) interface{}
+}
+
+// A CancelFunc tells an operation to abandon its work.
+// A CancelFunc does not wait for the work to stop.
+// After the first call, subsequent calls to a CancelFunc do nothing.
+type CancelFunc func()

vendor/golang.org/x/sync/errgroup/errgroup.go

@@ -7,8 +7,9 @@
 package errgroup
 
 import (
-	"context"
 	"sync"
+
+	"golang.org/x/net/context"
 )
 
 // A Group is a collection of goroutines working on subtasks that are part of

vendor/golang.org/x/sys/unix/README.md

@@ -14,7 +14,7 @@ migrating the build system to use containers so the builds are reproducible.
 This is being done on an OS-by-OS basis. Please update this documentation as
 components of the build system change.
 
-### Old Build System (currently for `GOOS != "linux"`)
+### Old Build System (currently for `GOOS != "Linux" || GOARCH == "sparc64"`)
 
 The old build system generates the Go files based on the C header files
 present on your system. This means that files
@@ -32,9 +32,9 @@ To build the files for your current OS and architecture, make sure GOOS and
 GOARCH are set correctly and run `mkall.sh`. This will generate the files for
 your specific system. Running `mkall.sh -n` shows the commands that will be run.
 
-Requirements: bash, go
+Requirements: bash, perl, go
 
-### New Build System (currently for `GOOS == "linux"`)
+### New Build System (currently for `GOOS == "Linux" && GOARCH != "sparc64"`)
 
 The new build system uses a Docker container to generate the go files directly
 from source checkouts of the kernel and various system libraries. This means
@@ -52,14 +52,14 @@ system and have your GOOS and GOARCH set accordingly. Running `mkall.sh` will
 then generate all of the files for all of the GOOS/GOARCH pairs in the new build
 system. Running `mkall.sh -n` shows the commands that will be run.
 
-Requirements: bash, go, docker
+Requirements: bash, perl, go, docker
 
 ## Component files
 
 This section describes the various files used in the code generation process.
 It also contains instructions on how to modify these files to add a new
 architecture/OS or to add additional syscalls, types, or constants. Note that
-if you are using the new build system, the scripts/programs cannot be called normally.
+if you are using the new build system, the scripts cannot be called normally.
 They must be called from within the docker container.
 
 ### asm files
@@ -81,8 +81,8 @@ each GOOS/GOARCH pair.
 
 ### mksysnum
 
-Mksysnum is a Go program located at `${GOOS}/mksysnum.go` (or `mksysnum_${GOOS}.go`
-for the old system). This program takes in a list of header files containing the
+Mksysnum is a script located at `${GOOS}/mksysnum.pl` (or `mksysnum_${GOOS}.pl`
+for the old system). This script takes in a list of header files containing the
 syscall number declarations and parses them to produce the corresponding list of
 Go numeric constants. See `zsysnum_${GOOS}_${GOARCH}.go` for the generated
 constants.
@@ -92,14 +92,14 @@ new installation of the target OS (or updating the source checkouts for the
 new build system). However, depending on the OS, you make need to update the
 parsing in mksysnum.
 
-### mksyscall.go
+### mksyscall.pl
 
 The `syscall.go`, `syscall_${GOOS}.go`, `syscall_${GOOS}_${GOARCH}.go` are
 hand-written Go files which implement system calls (for unix, the specific OS,
 or the specific OS/Architecture pair respectively) that need special handling
 and list `//sys` comments giving prototypes for ones that can be generated.
 
-The mksyscall.go program takes the `//sys` and `//sysnb` comments and converts
+The mksyscall.pl script takes the `//sys` and `//sysnb` comments and converts
 them into syscalls. This requires the name of the prototype in the comment to
 match a syscall number in the `zsysnum_${GOOS}_${GOARCH}.go` file. The function
 prototype can be exported (capitalized) or not.
@@ -160,7 +160,7 @@ signal numbers, and constants. Generated by `mkerrors.sh` (see above).
 ### `zsyscall_${GOOS}_${GOARCH}.go`
 
 A file containing all the generated syscalls for a specific GOOS and GOARCH.
-Generated by `mksyscall.go` (see above).
+Generated by `mksyscall.pl` (see above).
 
 ### `zsysnum_${GOOS}_${GOARCH}.go`
 

vendor/golang.org/x/sys/unix/affinity_linux.go

@@ -7,7 +7,6 @@
 package unix
 
 import (
-	"math/bits"
 	"unsafe"
 )
 
@@ -80,7 +79,46 @@ func (s *CPUSet) IsSet(cpu int) bool {
 func (s *CPUSet) Count() int {
 	c := 0
 	for _, b := range s {
-		c += bits.OnesCount64(uint64(b))
+		c += onesCount64(uint64(b))
 	}
 	return c
 }
+
+// onesCount64 is a copy of Go 1.9's math/bits.OnesCount64.
+// Once this package can require Go 1.9, we can delete this
+// and update the caller to use bits.OnesCount64.
+func onesCount64(x uint64) int {
+	const m0 = 0x5555555555555555 // 01010101 ...
+	const m1 = 0x3333333333333333 // 00110011 ...
+	const m2 = 0x0f0f0f0f0f0f0f0f // 00001111 ...
+	const m3 = 0x00ff00ff00ff00ff // etc.
+	const m4 = 0x0000ffff0000ffff
+
+	// Implementation: Parallel summing of adjacent bits.
+	// See "Hacker's Delight", Chap. 5: Counting Bits.
+	// The following pattern shows the general approach:
+	//
+	//   x = x>>1&(m0&m) + x&(m0&m)
+	//   x = x>>2&(m1&m) + x&(m1&m)
+	//   x = x>>4&(m2&m) + x&(m2&m)
+	//   x = x>>8&(m3&m) + x&(m3&m)
+	//   x = x>>16&(m4&m) + x&(m4&m)
+	//   x = x>>32&(m5&m) + x&(m5&m)
+	//   return int(x)
+	//
+	// Masking (& operations) can be left away when there's no
+	// danger that a field's sum will carry over into the next
+	// field: Since the result cannot be > 64, 8 bits is enough
+	// and we can ignore the masks for the shifts by 8 and up.
+	// Per "Hacker's Delight", the first line can be simplified
+	// more, but it saves at best one instruction, so we leave
+	// it alone for clarity.
+	const m = 1<<64 - 1
+	x = x>>1&(m0&m) + x&(m0&m)
+	x = x>>2&(m1&m) + x&(m1&m)
+	x = (x>>4 + x) & (m2 & m)
+	x += x >> 8
+	x += x >> 16
+	x += x >> 32
+	return int(x) & (1<<7 - 1)
+}

vendor/golang.org/x/sys/unix/asm_aix_ppc64.s

@@ -1,17 +0,0 @@
-// Copyright 2018 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System calls for ppc64, AIX are implemented in runtime/syscall_aix.go
-//
-
-TEXT ·syscall6(SB),NOSPLIT,$0-88
-	JMP	syscall·syscall6(SB)
-
-TEXT ·rawSyscall6(SB),NOSPLIT,$0-88
-	JMP	syscall·rawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_freebsd_arm64.s

@@ -1,29 +0,0 @@
-// Copyright 2018 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System call support for ARM64, FreeBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-56
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	JMP	syscall·Syscall9(SB)
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-56
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s

@@ -15,6 +15,12 @@
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 
+TEXT ·Syscall(SB),NOSPLIT,$0-56
+	BR	syscall·Syscall(SB)
+
+TEXT ·Syscall6(SB),NOSPLIT,$0-80
+	BR	syscall·Syscall6(SB)
+
 TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
 	BL	runtime·entersyscall(SB)
 	MOVD	a1+8(FP), R3
@@ -30,6 +36,12 @@ TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
 	BL	runtime·exitsyscall(SB)
 	RET
 
+TEXT ·RawSyscall(SB),NOSPLIT,$0-56
+	BR	syscall·RawSyscall(SB)
+
+TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
+	BR	syscall·RawSyscall6(SB)
+
 TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
 	MOVD	a1+8(FP), R3
 	MOVD	a2+16(FP), R4

vendor/golang.org/x/sys/unix/asm_linux_riscv64.s

@@ -1,54 +0,0 @@
-// Copyright 2019 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.
-
-// +build riscv64,!gccgo
-
-#include "textflag.h"
-
-//
-// System calls for linux/riscv64.
-//
-// Where available, just jump to package syscall's implementation of
-// these functions.
-
-TEXT ·Syscall(SB),NOSPLIT,$0-56
-	JMP	syscall·Syscall(SB)
-
-TEXT ·Syscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·Syscall6(SB)
-
-TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
-	CALL	runtime·entersyscall(SB)
-	MOV	a1+8(FP), A0
-	MOV	a2+16(FP), A1
-	MOV	a3+24(FP), A2
-	MOV	$0, A3
-	MOV	$0, A4
-	MOV	$0, A5
-	MOV	$0, A6
-	MOV	trap+0(FP), A7	// syscall entry
-	ECALL
-	MOV	A0, r1+32(FP)	// r1
-	MOV	A1, r2+40(FP)	// r2
-	CALL	runtime·exitsyscall(SB)
-	RET
-
-TEXT ·RawSyscall(SB),NOSPLIT,$0-56
-	JMP	syscall·RawSyscall(SB)
-
-TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·RawSyscall6(SB)
-
-TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
-	MOV	a1+8(FP), A0
-	MOV	a2+16(FP), A1
-	MOV	a3+24(FP), A2
-	MOV	ZERO, A3
-	MOV	ZERO, A4
-	MOV	ZERO, A5
-	MOV	trap+0(FP), A7	// syscall entry
-	ECALL
-	MOV	A0, r1+32(FP)
-	MOV	A1, r2+40(FP)
-	RET

vendor/golang.org/x/sys/unix/asm_netbsd_arm64.s

@@ -1,29 +0,0 @@
-// Copyright 2019 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System call support for ARM64, NetBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-56
-	B	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	B	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	B	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-56
-	B	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	B	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/asm_openbsd_arm64.s

@@ -1,29 +0,0 @@
-// Copyright 2019 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.
-
-// +build !gccgo
-
-#include "textflag.h"
-
-//
-// System call support for arm64, OpenBSD
-//
-
-// Just jump to package syscall's implementation for all these functions.
-// The runtime may know about them.
-
-TEXT	·Syscall(SB),NOSPLIT,$0-56
-	JMP	syscall·Syscall(SB)
-
-TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·Syscall6(SB)
-
-TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	JMP	syscall·Syscall9(SB)
-
-TEXT	·RawSyscall(SB),NOSPLIT,$0-56
-	JMP	syscall·RawSyscall(SB)
-
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	JMP	syscall·RawSyscall6(SB)

vendor/golang.org/x/sys/unix/dev_aix_ppc.go

@@ -6,7 +6,17 @@
 // +build ppc
 
 // Functions to access/create device major and minor numbers matching the
-// encoding used by AIX.
+// encoding used by the Linux kernel and glibc.
+//
+// The information below is extracted and adapted from bits/sysmacros.h in the
+// glibc sources:
+//
+// dev_t in glibc is 64-bit, with 32-bit major and minor numbers. glibc's
+// default encoding is MMMM Mmmm mmmM MMmm, where M is a hex digit of the major
+// number and m is a hex digit of the minor number. This is backward compatible
+// with legacy systems where dev_t is 16 bits wide, encoded as MMmm. It is also
+// backward compatible with the Linux kernel, which for some architectures uses
+// 32-bit dev_t, encoded as mmmM MMmm.
 
 package unix
 

vendor/golang.org/x/sys/unix/dev_aix_ppc64.go

@@ -6,7 +6,17 @@
 // +build ppc64
 
 // Functions to access/create device major and minor numbers matching the
-// encoding used AIX.
+// encoding used by the Linux kernel and glibc.
+//
+// The information below is extracted and adapted from bits/sysmacros.h in the
+// glibc sources:
+//
+// dev_t in glibc is 64-bit, with 32-bit major and minor numbers. glibc's
+// default encoding is MMMM Mmmm mmmM MMmm, where M is a hex digit of the major
+// number and m is a hex digit of the minor number. This is backward compatible
+// with legacy systems where dev_t is 16 bits wide, encoded as MMmm. It is also
+// backward compatible with the Linux kernel, which for some architectures uses
+// 32-bit dev_t, encoded as mmmM MMmm.
 
 package unix
 

vendor/golang.org/x/sys/unix/dirent.go

@@ -2,101 +2,16 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
+// +build aix darwin dragonfly freebsd linux nacl netbsd openbsd solaris
 
 package unix
 
-import "unsafe"
-
-// readInt returns the size-bytes unsigned integer in native byte order at offset off.
-func readInt(b []byte, off, size uintptr) (u uint64, ok bool) {
-	if len(b) < int(off+size) {
-		return 0, false
-	}
-	if isBigEndian {
-		return readIntBE(b[off:], size), true
-	}
-	return readIntLE(b[off:], size), true
-}
-
-func readIntBE(b []byte, size uintptr) uint64 {
-	switch size {
-	case 1:
-		return uint64(b[0])
-	case 2:
-		_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808
-		return uint64(b[1]) | uint64(b[0])<<8
-	case 4:
-		_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808
-		return uint64(b[3]) | uint64(b[2])<<8 | uint64(b[1])<<16 | uint64(b[0])<<24
-	case 8:
-		_ = b[7] // bounds check hint to compiler; see golang.org/issue/14808
-		return uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |
-			uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56
-	default:
-		panic("syscall: readInt with unsupported size")
-	}
-}
-
-func readIntLE(b []byte, size uintptr) uint64 {
-	switch size {
-	case 1:
-		return uint64(b[0])
-	case 2:
-		_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808
-		return uint64(b[0]) | uint64(b[1])<<8
-	case 4:
-		_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808
-		return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24
-	case 8:
-		_ = b[7] // bounds check hint to compiler; see golang.org/issue/14808
-		return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |
-			uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
-	default:
-		panic("syscall: readInt with unsupported size")
-	}
-}
+import "syscall"
 
 // ParseDirent parses up to max directory entries in buf,
 // appending the names to names. It returns the number of
 // bytes consumed from buf, the number of entries added
 // to names, and the new names slice.
 func ParseDirent(buf []byte, max int, names []string) (consumed int, count int, newnames []string) {
-	origlen := len(buf)
-	count = 0
-	for max != 0 && len(buf) > 0 {
-		reclen, ok := direntReclen(buf)
-		if !ok || reclen > uint64(len(buf)) {
-			return origlen, count, names
-		}
-		rec := buf[:reclen]
-		buf = buf[reclen:]
-		ino, ok := direntIno(rec)
-		if !ok {
-			break
-		}
-		if ino == 0 { // File absent in directory.
-			continue
-		}
-		const namoff = uint64(unsafe.Offsetof(Dirent{}.Name))
-		namlen, ok := direntNamlen(rec)
-		if !ok || namoff+namlen > uint64(len(rec)) {
-			break
-		}
-		name := rec[namoff : namoff+namlen]
-		for i, c := range name {
-			if c == 0 {
-				name = name[:i]
-				break
-			}
-		}
-		// Check for useless names before allocating a string.
-		if string(name) == "." || string(name) == ".." {
-			continue
-		}
-		max--
-		count++
-		names = append(names, string(name))
-	}
-	return origlen - len(buf), count, names
+	return syscall.ParseDirent(buf, max, names)
 }

vendor/golang.org/x/sys/unix/endian_little.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //
-// +build 386 amd64 amd64p32 arm arm64 ppc64le mipsle mips64le riscv64
+// +build 386 amd64 amd64p32 arm arm64 ppc64le mipsle mips64le
 
 package unix
 

vendor/golang.org/x/sys/unix/fcntl.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build dragonfly freebsd linux netbsd openbsd
+// +build darwin dragonfly freebsd linux netbsd openbsd
 
 package unix
 

vendor/golang.org/x/sys/unix/fcntl_darwin.go

@@ -1,18 +0,0 @@
-// Copyright 2019 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 unix
-
-import "unsafe"
-
-// FcntlInt performs a fcntl syscall on fd with the provided command and argument.
-func FcntlInt(fd uintptr, cmd, arg int) (int, error) {
-	return fcntl(int(fd), cmd, arg)
-}
-
-// FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command.
-func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {
-	_, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(lk))))
-	return err
-}

vendor/golang.org/x/sys/unix/ioctl.go

@@ -2,23 +2,11 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
+// +build darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package unix
 
-import (
-	"runtime"
-	"unsafe"
-)
-
-// ioctl itself should not be exposed directly, but additional get/set
-// functions for specific types are permissible.
-
-// IoctlSetInt performs an ioctl operation which sets an integer value
-// on fd, using the specified request number.
-func IoctlSetInt(fd int, req uint, value int) error {
-	return ioctl(fd, req, uintptr(value))
-}
+import "runtime"
 
 // IoctlSetWinsize performs an ioctl on fd with a *Winsize argument.
 //
@@ -26,7 +14,7 @@ func IoctlSetInt(fd int, req uint, value int) error {
 func IoctlSetWinsize(fd int, req uint, value *Winsize) error {
 	// TODO: if we get the chance, remove the req parameter and
 	// hardcode TIOCSWINSZ.
-	err := ioctl(fd, req, uintptr(unsafe.Pointer(value)))
+	err := ioctlSetWinsize(fd, req, value)
 	runtime.KeepAlive(value)
 	return err
 }
@@ -36,30 +24,7 @@ func IoctlSetWinsize(fd int, req uint, value *Winsize) error {
 // The req value will usually be TCSETA or TIOCSETA.
 func IoctlSetTermios(fd int, req uint, value *Termios) error {
 	// TODO: if we get the chance, remove the req parameter.
-	err := ioctl(fd, req, uintptr(unsafe.Pointer(value)))
+	err := ioctlSetTermios(fd, req, value)
 	runtime.KeepAlive(value)
 	return err
 }
-
-// IoctlGetInt performs an ioctl operation which gets an integer value
-// from fd, using the specified request number.
-//
-// A few ioctl requests use the return value as an output parameter;
-// for those, IoctlRetInt should be used instead of this function.
-func IoctlGetInt(fd int, req uint) (int, error) {
-	var value int
-	err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
-	return value, err
-}
-
-func IoctlGetWinsize(fd int, req uint) (*Winsize, error) {
-	var value Winsize
-	err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
-	return &value, err
-}
-
-func IoctlGetTermios(fd int, req uint) (*Termios, error) {
-	var value Termios
-	err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
-	return &value, err
-}

vendor/golang.org/x/sys/unix/mkall.sh

@@ -10,14 +10,13 @@
 GOOSARCH="${GOOS}_${GOARCH}"
 
 # defaults
-mksyscall="go run mksyscall.go"
+mksyscall="./mksyscall.pl"
 mkerrors="./mkerrors.sh"
 zerrors="zerrors_$GOOSARCH.go"
 mksysctl=""
 zsysctl="zsysctl_$GOOSARCH.go"
 mksysnum=
 mktypes=
-mkasm=
 run="sh"
 cmd=""
 
@@ -46,8 +45,8 @@ case "$#" in
 	exit 2
 esac
 
-if [[ "$GOOS" = "linux" ]]; then
-	# Use the Docker-based build system
+if [[ "$GOOS" = "linux" ]] && [[ "$GOARCH" != "sparc64" ]]; then
+	# Use then new build system
 	# Files generated through docker (use $cmd so you can Ctl-C the build or run)
 	$cmd docker build --tag generate:$GOOS $GOOS
 	$cmd docker run --interactive --tty --volume $(dirname "$(readlink -f "$0")"):/build generate:$GOOS
@@ -62,130 +61,112 @@ _* | *_ | _)
 	;;
 aix_ppc)
 	mkerrors="$mkerrors -maix32"
-	mksyscall="go run mksyscall_aix_ppc.go -aix"
+	mksyscall="perl mksyscall_aix.pl -aix"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
 	;;
 aix_ppc64)
 	mkerrors="$mkerrors -maix64"
-	mksyscall="go run mksyscall_aix_ppc64.go -aix"
+	mksyscall="perl mksyscall_aix.pl -aix"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
 	;;
 darwin_386)
 	mkerrors="$mkerrors -m32"
-	mksyscall="go run mksyscall.go -l32"
-	mksysnum="go run mksysnum.go $(xcrun --show-sdk-path --sdk macosx)/usr/include/sys/syscall.h"
+	mksyscall="./mksyscall.pl -l32"
+	mksysnum="./mksysnum_darwin.pl $(xcrun --show-sdk-path --sdk macosx)/usr/include/sys/syscall.h"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
-	mkasm="go run mkasm_darwin.go"
 	;;
 darwin_amd64)
 	mkerrors="$mkerrors -m64"
-	mksysnum="go run mksysnum.go $(xcrun --show-sdk-path --sdk macosx)/usr/include/sys/syscall.h"
+	mksysnum="./mksysnum_darwin.pl $(xcrun --show-sdk-path --sdk macosx)/usr/include/sys/syscall.h"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
-	mkasm="go run mkasm_darwin.go"
 	;;
 darwin_arm)
 	mkerrors="$mkerrors"
-	mksyscall="go run mksyscall.go -l32"
-	mksysnum="go run mksysnum.go $(xcrun --show-sdk-path --sdk iphoneos)/usr/include/sys/syscall.h"
+	mksysnum="./mksysnum_darwin.pl $(xcrun --show-sdk-path --sdk iphoneos)/usr/include/sys/syscall.h"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
-	mkasm="go run mkasm_darwin.go"
 	;;
 darwin_arm64)
 	mkerrors="$mkerrors -m64"
-	mksysnum="go run mksysnum.go $(xcrun --show-sdk-path --sdk iphoneos)/usr/include/sys/syscall.h"
+	mksysnum="./mksysnum_darwin.pl $(xcrun --show-sdk-path --sdk iphoneos)/usr/include/sys/syscall.h"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
-	mkasm="go run mkasm_darwin.go"
 	;;
 dragonfly_amd64)
 	mkerrors="$mkerrors -m64"
-	mksyscall="go run mksyscall.go -dragonfly"
-	mksysnum="go run mksysnum.go 'https://gitweb.dragonflybsd.org/dragonfly.git/blob_plain/HEAD:/sys/kern/syscalls.master'"
+	mksyscall="./mksyscall.pl -dragonfly"
+	mksysnum="curl -s 'http://gitweb.dragonflybsd.org/dragonfly.git/blob_plain/HEAD:/sys/kern/syscalls.master' | ./mksysnum_dragonfly.pl"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
 	;;
 freebsd_386)
 	mkerrors="$mkerrors -m32"
-	mksyscall="go run mksyscall.go -l32"
-	mksysnum="go run mksysnum.go 'https://svn.freebsd.org/base/stable/11/sys/kern/syscalls.master'"
+	mksyscall="./mksyscall.pl -l32"
+	mksysnum="curl -s 'http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master' | ./mksysnum_freebsd.pl"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
 	;;
 freebsd_amd64)
 	mkerrors="$mkerrors -m64"
-	mksysnum="go run mksysnum.go 'https://svn.freebsd.org/base/stable/11/sys/kern/syscalls.master'"
+	mksysnum="curl -s 'http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master' | ./mksysnum_freebsd.pl"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
 	;;
 freebsd_arm)
 	mkerrors="$mkerrors"
-	mksyscall="go run mksyscall.go -l32 -arm"
-	mksysnum="go run mksysnum.go 'https://svn.freebsd.org/base/stable/11/sys/kern/syscalls.master'"
+	mksyscall="./mksyscall.pl -l32 -arm"
+	mksysnum="curl -s 'http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master' | ./mksysnum_freebsd.pl"
 	# Let the type of C char be signed for making the bare syscall
 	# API consistent across platforms.
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char"
 	;;
-freebsd_arm64)
+linux_sparc64)
+	GOOSARCH_in=syscall_linux_sparc64.go
+	unistd_h=/usr/include/sparc64-linux-gnu/asm/unistd.h
 	mkerrors="$mkerrors -m64"
-	mksysnum="go run mksysnum.go 'https://svn.freebsd.org/base/stable/11/sys/kern/syscalls.master'"
+	mksysnum="./mksysnum_linux.pl $unistd_h"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
 	;;
 netbsd_386)
 	mkerrors="$mkerrors -m32"
-	mksyscall="go run mksyscall.go -l32 -netbsd"
-	mksysnum="go run mksysnum.go 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master'"
+	mksyscall="./mksyscall.pl -l32 -netbsd"
+	mksysnum="curl -s 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master' | ./mksysnum_netbsd.pl"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
 	;;
 netbsd_amd64)
 	mkerrors="$mkerrors -m64"
-	mksyscall="go run mksyscall.go -netbsd"
-	mksysnum="go run mksysnum.go 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master'"
+	mksyscall="./mksyscall.pl -netbsd"
+	mksysnum="curl -s 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master' | ./mksysnum_netbsd.pl"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
 	;;
 netbsd_arm)
 	mkerrors="$mkerrors"
-	mksyscall="go run mksyscall.go -l32 -netbsd -arm"
-	mksysnum="go run mksysnum.go 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master'"
+	mksyscall="./mksyscall.pl -l32 -netbsd -arm"
+	mksysnum="curl -s 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master' | ./mksysnum_netbsd.pl"
 	# Let the type of C char be signed for making the bare syscall
 	# API consistent across platforms.
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char"
 	;;
-netbsd_arm64)
-	mkerrors="$mkerrors -m64"
-	mksyscall="go run mksyscall.go -netbsd"
-	mksysnum="go run mksysnum.go 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master'"
-	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
-	;;
 openbsd_386)
 	mkerrors="$mkerrors -m32"
-	mksyscall="go run mksyscall.go -l32 -openbsd"
-	mksysctl="go run mksysctl_openbsd.go"
-	mksysnum="go run mksysnum.go 'https://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master'"
+	mksyscall="./mksyscall.pl -l32 -openbsd"
+	mksysctl="./mksysctl_openbsd.pl"
+	mksysnum="curl -s 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master' | ./mksysnum_openbsd.pl"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
 	;;
 openbsd_amd64)
 	mkerrors="$mkerrors -m64"
-	mksyscall="go run mksyscall.go -openbsd"
-	mksysctl="go run mksysctl_openbsd.go"
-	mksysnum="go run mksysnum.go 'https://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master'"
+	mksyscall="./mksyscall.pl -openbsd"
+	mksysctl="./mksysctl_openbsd.pl"
+	mksysnum="curl -s 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master' | ./mksysnum_openbsd.pl"
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
 	;;
 openbsd_arm)
 	mkerrors="$mkerrors"
-	mksyscall="go run mksyscall.go -l32 -openbsd -arm"
-	mksysctl="go run mksysctl_openbsd.go"
-	mksysnum="go run mksysnum.go 'https://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master'"
-	# Let the type of C char be signed for making the bare syscall
-	# API consistent across platforms.
-	mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char"
-	;;
-openbsd_arm64)
-	mkerrors="$mkerrors -m64"
-	mksyscall="go run mksyscall.go -openbsd"
-	mksysctl="go run mksysctl_openbsd.go"
-	mksysnum="go run mksysnum.go 'https://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master'"
+	mksyscall="./mksyscall.pl -l32 -openbsd -arm"
+	mksysctl="./mksysctl_openbsd.pl"
+	mksysnum="curl -s 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master' | ./mksysnum_openbsd.pl"
 	# Let the type of C char be signed for making the bare syscall
 	# API consistent across platforms.
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char"
 	;;
 solaris_amd64)
-	mksyscall="go run mksyscall_solaris.go"
+	mksyscall="./mksyscall_solaris.pl"
 	mkerrors="$mkerrors -m64"
 	mksysnum=
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
@@ -206,24 +187,12 @@ esac
 			syscall_goos="syscall_bsd.go $syscall_goos"
 			;;
 		esac
-		if [ -n "$mksyscall" ]; then
-			if [ "$GOOSARCH" == "aix_ppc64" ]; then
-				# aix/ppc64 script generates files instead of writing to stdin.
-				echo "$mksyscall -tags $GOOS,$GOARCH $syscall_goos $GOOSARCH_in && gofmt -w zsyscall_$GOOSARCH.go && gofmt -w zsyscall_"$GOOSARCH"_gccgo.go && gofmt -w zsyscall_"$GOOSARCH"_gc.go " ;
-			elif [ "$GOOS" == "darwin" ]; then
-			        # pre-1.12, direct syscalls
-			        echo "$mksyscall -tags $GOOS,$GOARCH,!go1.12 $syscall_goos syscall_darwin_${GOARCH}.1_11.go $GOOSARCH_in |gofmt >zsyscall_$GOOSARCH.1_11.go";
-			        # 1.12 and later, syscalls via libSystem
-				echo "$mksyscall -tags $GOOS,$GOARCH,go1.12 $syscall_goos $GOOSARCH_in |gofmt >zsyscall_$GOOSARCH.go";
-				# 1.13 and later, syscalls via libSystem (including syscallPtr)
-				echo "$mksyscall -tags $GOOS,$GOARCH,go1.13 syscall_darwin.1_13.go |gofmt >zsyscall_$GOOSARCH.1_13.go";
-			else
-				echo "$mksyscall -tags $GOOS,$GOARCH $syscall_goos $GOOSARCH_in |gofmt >zsyscall_$GOOSARCH.go";
-			fi
-		fi
+		if [ -n "$mksyscall" ]; then echo "$mksyscall -tags $GOOS,$GOARCH $syscall_goos $GOOSARCH_in |gofmt >zsyscall_$GOOSARCH.go"; fi
+		;;
 	esac
 	if [ -n "$mksysctl" ]; then echo "$mksysctl |gofmt >$zsysctl"; fi
 	if [ -n "$mksysnum" ]; then echo "$mksysnum |gofmt >zsysnum_$GOOSARCH.go"; fi
-	if [ -n "$mktypes" ]; then echo "$mktypes types_$GOOS.go | go run mkpost.go > ztypes_$GOOSARCH.go"; fi
-	if [ -n "$mkasm" ]; then echo "$mkasm $GOARCH"; fi
+	if [ -n "$mktypes" ]; then
+		echo "$mktypes types_$GOOS.go | go run mkpost.go > ztypes_$GOOSARCH.go";
+	fi
 ) | $run

vendor/golang.org/x/sys/unix/mkerrors.sh

@@ -17,10 +17,12 @@ if test -z "$GOARCH" -o -z "$GOOS"; then
 fi
 
 # Check that we are using the new build system if we should
-if [[ "$GOOS" = "linux" ]] && [[ "$GOLANG_SYS_BUILD" != "docker" ]]; then
-	echo 1>&2 "In the Docker based build system, mkerrors should not be called directly."
-	echo 1>&2 "See README.md"
-	exit 1
+if [[ "$GOOS" = "linux" ]] && [[ "$GOARCH" != "sparc64" ]]; then
+	if [[ "$GOLANG_SYS_BUILD" != "docker" ]]; then
+		echo 1>&2 "In the new build system, mkerrors should not be called directly."
+		echo 1>&2 "See README.md"
+		exit 1
+	fi
 fi
 
 if [[ "$GOOS" = "aix" ]]; then
@@ -44,7 +46,6 @@ includes_AIX='
 #include <sys/stropts.h>
 #include <sys/mman.h>
 #include <sys/poll.h>
-#include <sys/termio.h>
 #include <termios.h>
 #include <fcntl.h>
 
@@ -60,7 +61,6 @@ includes_Darwin='
 #include <sys/types.h>
 #include <sys/event.h>
 #include <sys/ptrace.h>
-#include <sys/select.h>
 #include <sys/socket.h>
 #include <sys/sockio.h>
 #include <sys/sysctl.h>
@@ -81,13 +81,11 @@ includes_Darwin='
 includes_DragonFly='
 #include <sys/types.h>
 #include <sys/event.h>
-#include <sys/select.h>
 #include <sys/socket.h>
 #include <sys/sockio.h>
 #include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <sys/mman.h>
-#include <sys/mount.h>
 #include <sys/wait.h>
 #include <sys/ioctl.h>
 #include <net/bpf.h>
@@ -101,11 +99,10 @@ includes_DragonFly='
 '
 
 includes_FreeBSD='
-#include <sys/capsicum.h>
+#include <sys/capability.h>
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/event.h>
-#include <sys/select.h>
 #include <sys/socket.h>
 #include <sys/sockio.h>
 #include <sys/stat.h>
@@ -182,68 +179,44 @@ struct ltchars {
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/time.h>
-#include <sys/select.h>
-#include <sys/signalfd.h>
 #include <sys/socket.h>
 #include <sys/xattr.h>
-#include <linux/bpf.h>
-#include <linux/can.h>
-#include <linux/capability.h>
-#include <linux/cryptouser.h>
-#include <linux/errqueue.h>
-#include <linux/falloc.h>
-#include <linux/fanotify.h>
-#include <linux/filter.h>
-#include <linux/fs.h>
-#include <linux/genetlink.h>
-#include <linux/hdreg.h>
-#include <linux/icmpv6.h>
 #include <linux/if.h>
-#include <linux/if_addr.h>
 #include <linux/if_alg.h>
 #include <linux/if_arp.h>
 #include <linux/if_ether.h>
-#include <linux/if_ppp.h>
 #include <linux/if_tun.h>
 #include <linux/if_packet.h>
-#include <linux/if_xdp.h>
-#include <linux/kexec.h>
+#include <linux/if_addr.h>
+#include <linux/falloc.h>
+#include <linux/filter.h>
+#include <linux/fs.h>
 #include <linux/keyctl.h>
-#include <linux/loop.h>
 #include <linux/magic.h>
-#include <linux/memfd.h>
-#include <linux/module.h>
 #include <linux/netfilter/nfnetlink.h>
 #include <linux/netlink.h>
 #include <linux/net_namespace.h>
-#include <linux/nsfs.h>
 #include <linux/perf_event.h>
-#include <linux/ptrace.h>
 #include <linux/random.h>
 #include <linux/reboot.h>
-#include <linux/rtc.h>
 #include <linux/rtnetlink.h>
+#include <linux/ptrace.h>
 #include <linux/sched.h>
 #include <linux/seccomp.h>
-#include <linux/serial.h>
 #include <linux/sockios.h>
-#include <linux/taskstats.h>
-#include <linux/tipc.h>
-#include <linux/vm_sockets.h>
 #include <linux/wait.h>
+#include <linux/icmpv6.h>
+#include <linux/serial.h>
+#include <linux/can.h>
+#include <linux/vm_sockets.h>
+#include <linux/taskstats.h>
+#include <linux/genetlink.h>
 #include <linux/watchdog.h>
-
+#include <linux/hdreg.h>
+#include <linux/rtc.h>
 #include <mtd/ubi-user.h>
 #include <net/route.h>
-
-#if defined(__sparc__)
-// On sparc{,64}, the kernel defines struct termios2 itself which clashes with the
-// definition in glibc. As only the error constants are needed here, include the
-// generic termibits.h (which is included by termbits.h on sparc).
-#include <asm-generic/termbits.h>
-#else
 #include <asm/termbits.h>
-#endif
 
 #ifndef MSG_FASTOPEN
 #define MSG_FASTOPEN    0x20000000
@@ -271,11 +244,6 @@ struct ltchars {
 #define FS_KEY_DESC_PREFIX              "fscrypt:"
 #define FS_KEY_DESC_PREFIX_SIZE         8
 #define FS_MAX_KEY_SIZE                 64
-
-// The code generator produces -0x1 for (~0), but an unsigned value is necessary
-// for the tipc_subscr timeout __u32 field.
-#undef TIPC_WAIT_FOREVER
-#define TIPC_WAIT_FOREVER 0xffffffff
 '
 
 includes_NetBSD='
@@ -284,8 +252,6 @@ includes_NetBSD='
 #include <sys/event.h>
 #include <sys/extattr.h>
 #include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/select.h>
 #include <sys/socket.h>
 #include <sys/sockio.h>
 #include <sys/sysctl.h>
@@ -311,8 +277,6 @@ includes_OpenBSD='
 #include <sys/param.h>
 #include <sys/event.h>
 #include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/select.h>
 #include <sys/socket.h>
 #include <sys/sockio.h>
 #include <sys/stat.h>
@@ -349,7 +313,6 @@ includes_OpenBSD='
 includes_SunOS='
 #include <limits.h>
 #include <sys/types.h>
-#include <sys/select.h>
 #include <sys/socket.h>
 #include <sys/sockio.h>
 #include <sys/stat.h>
@@ -415,7 +378,6 @@ ccflags="$@"
 		$2 ~ /^EXTATTR_NAMESPACE_NAMES/ ||
 		$2 ~ /^EXTATTR_NAMESPACE_[A-Z]+_STRING/ {next}
 
-		$2 !~ /^ECCAPBITS/ &&
 		$2 !~ /^ETH_/ &&
 		$2 !~ /^EPROC_/ &&
 		$2 !~ /^EQUIV_/ &&
@@ -442,7 +404,6 @@ ccflags="$@"
 		$2 == "XCASE" ||
 		$2 == "ALTWERASE" ||
 		$2 == "NOKERNINFO" ||
-		$2 == "NFDBITS" ||
 		$2 ~ /^PAR/ ||
 		$2 ~ /^SIG[^_]/ ||
 		$2 ~ /^O[CNPFPL][A-Z]+[^_][A-Z]+$/ ||
@@ -452,9 +413,7 @@ ccflags="$@"
 		$2 ~ /^TC[IO](ON|OFF)$/ ||
 		$2 ~ /^IN_/ ||
 		$2 ~ /^LOCK_(SH|EX|NB|UN)$/ ||
-		$2 ~ /^LO_(KEY|NAME)_SIZE$/ ||
-		$2 ~ /^LOOP_(CLR|CTL|GET|SET)_/ ||
-		$2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|ICMP6|TCP|MCAST|EVFILT|NOTE|EV|SHUT|PROT|MAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR)_/ ||
+		$2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|ICMP6|TCP|EVFILT|NOTE|EV|SHUT|PROT|MAP|T?PACKET|MSG|SCM|MCL|DT|MADV|PR)_/ ||
 		$2 ~ /^TP_STATUS_/ ||
 		$2 ~ /^FALLOC_/ ||
 		$2 == "ICMPV6_FILTER" ||
@@ -465,15 +424,11 @@ ccflags="$@"
 		$2 ~ /^KERN_(HOSTNAME|OS(RELEASE|TYPE)|VERSION)$/ ||
 		$2 ~ /^HW_MACHINE$/ ||
 		$2 ~ /^SYSCTL_VERS/ ||
-		$2 !~ "MNT_BITS" &&
 		$2 ~ /^(MS|MNT|UMOUNT)_/ ||
-		$2 ~ /^NS_GET_/ ||
 		$2 ~ /^TUN(SET|GET|ATTACH|DETACH)/ ||
-		$2 ~ /^(O|F|[ES]?FD|NAME|S|PTRACE|PT)_/ ||
-		$2 ~ /^KEXEC_/ ||
+		$2 ~ /^(O|F|E?FD|NAME|S|PTRACE|PT)_/ ||
 		$2 ~ /^LINUX_REBOOT_CMD_/ ||
 		$2 ~ /^LINUX_REBOOT_MAGIC[12]$/ ||
-		$2 ~ /^MODULE_INIT_/ ||
 		$2 !~ "NLA_TYPE_MASK" &&
 		$2 ~ /^(NETLINK|NLM|NLMSG|NLA|IFA|IFAN|RT|RTC|RTCF|RTN|RTPROT|RTNH|ARPHRD|ETH_P|NETNSA)_/ ||
 		$2 ~ /^SIOC/ ||
@@ -488,21 +443,19 @@ ccflags="$@"
 		$2 ~ /^RLIMIT_(AS|CORE|CPU|DATA|FSIZE|LOCKS|MEMLOCK|MSGQUEUE|NICE|NOFILE|NPROC|RSS|RTPRIO|RTTIME|SIGPENDING|STACK)|RLIM_INFINITY/ ||
 		$2 ~ /^PRIO_(PROCESS|PGRP|USER)/ ||
 		$2 ~ /^CLONE_[A-Z_]+/ ||
-		$2 !~ /^(BPF_TIMEVAL|BPF_FIB_LOOKUP_[A-Z]+)$/ &&
+		$2 !~ /^(BPF_TIMEVAL)$/ &&
 		$2 ~ /^(BPF|DLT)_/ ||
-		$2 ~ /^(CLOCK|TIMER)_/ ||
+		$2 ~ /^CLOCK_/ ||
 		$2 ~ /^CAN_/ ||
 		$2 ~ /^CAP_/ ||
 		$2 ~ /^ALG_/ ||
 		$2 ~ /^FS_(POLICY_FLAGS|KEY_DESC|ENCRYPTION_MODE|[A-Z0-9_]+_KEY_SIZE|IOC_(GET|SET)_ENCRYPTION)/ ||
 		$2 ~ /^GRND_/ ||
-		$2 ~ /^RND/ ||
 		$2 ~ /^KEY_(SPEC|REQKEY_DEFL)_/ ||
 		$2 ~ /^KEYCTL_/ ||
 		$2 ~ /^PERF_EVENT_IOC_/ ||
 		$2 ~ /^SECCOMP_MODE_/ ||
 		$2 ~ /^SPLICE_/ ||
-		$2 ~ /^SYNC_FILE_RANGE_/ ||
 		$2 !~ /^AUDIT_RECORD_MAGIC/ &&
 		$2 !~ /IOC_MAGIC/ &&
 		$2 ~ /^[A-Z][A-Z0-9_]+_MAGIC2?$/ ||
@@ -520,14 +473,9 @@ ccflags="$@"
 		$2 ~ /^FSOPT_/ ||
 		$2 ~ /^WDIOC_/ ||
 		$2 ~ /^NFN/ ||
-		$2 ~ /^XDP_/ ||
 		$2 ~ /^(HDIO|WIN|SMART)_/ ||
-		$2 ~ /^CRYPTO_/ ||
-		$2 ~ /^TIPC_/ ||
 		$2 !~ "WMESGLEN" &&
 		$2 ~ /^W[A-Z0-9]+$/ ||
-		$2 ~/^PPPIOC/ ||
-		$2 ~ /^FAN_|FANOTIFY_/ ||
 		$2 ~ /^BLK[A-Z]*(GET$|SET$|BUF$|PART$|SIZE)/ {printf("\t%s = C.%s\n", $2, $2)}
 		$2 ~ /^__WCOREFLAG$/ {next}
 		$2 ~ /^__W[A-Z0-9]+$/ {printf("\t%s = C.%s\n", substr($2,3), $2)}

vendor/golang.org/x/sys/unix/mkpost.go

@@ -0,0 +1,98 @@
+// Copyright 2016 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.
+
+// +build ignore
+
+// mkpost processes the output of cgo -godefs to
+// modify the generated types. It is used to clean up
+// the sys API in an architecture specific manner.
+//
+// mkpost is run after cgo -godefs; see README.md.
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/format"
+	"io/ioutil"
+	"log"
+	"os"
+	"regexp"
+)
+
+func main() {
+	// Get the OS and architecture (using GOARCH_TARGET if it exists)
+	goos := os.Getenv("GOOS")
+	goarch := os.Getenv("GOARCH_TARGET")
+	if goarch == "" {
+		goarch = os.Getenv("GOARCH")
+	}
+	// Check that we are using the new build system if we should be.
+	if goos == "linux" && goarch != "sparc64" {
+		if os.Getenv("GOLANG_SYS_BUILD") != "docker" {
+			os.Stderr.WriteString("In the new build system, mkpost should not be called directly.\n")
+			os.Stderr.WriteString("See README.md\n")
+			os.Exit(1)
+		}
+	}
+
+	b, err := ioutil.ReadAll(os.Stdin)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Intentionally export __val fields in Fsid and Sigset_t
+	valRegex := regexp.MustCompile(`type (Fsid|Sigset_t) struct {(\s+)X__val(\s+\S+\s+)}`)
+	b = valRegex.ReplaceAll(b, []byte("type $1 struct {${2}Val$3}"))
+
+	// If we have empty Ptrace structs, we should delete them. Only s390x emits
+	// nonempty Ptrace structs.
+	ptraceRexexp := regexp.MustCompile(`type Ptrace((Psw|Fpregs|Per) struct {\s*})`)
+	b = ptraceRexexp.ReplaceAll(b, nil)
+
+	// Replace the control_regs union with a blank identifier for now.
+	controlRegsRegex := regexp.MustCompile(`(Control_regs)\s+\[0\]uint64`)
+	b = controlRegsRegex.ReplaceAll(b, []byte("_ [0]uint64"))
+
+	// Remove fields that are added by glibc
+	// Note that this is unstable as the identifers are private.
+	removeFieldsRegex := regexp.MustCompile(`X__glibc\S*`)
+	b = removeFieldsRegex.ReplaceAll(b, []byte("_"))
+
+	// Convert [65]int8 to [65]byte in Utsname members to simplify
+	// conversion to string; see golang.org/issue/20753
+	convertUtsnameRegex := regexp.MustCompile(`((Sys|Node|Domain)name|Release|Version|Machine)(\s+)\[(\d+)\]u?int8`)
+	b = convertUtsnameRegex.ReplaceAll(b, []byte("$1$3[$4]byte"))
+
+	// Remove spare fields (e.g. in Statx_t)
+	spareFieldsRegex := regexp.MustCompile(`X__spare\S*`)
+	b = spareFieldsRegex.ReplaceAll(b, []byte("_"))
+
+	// Remove cgo padding fields
+	removePaddingFieldsRegex := regexp.MustCompile(`Pad_cgo_\d+`)
+	b = removePaddingFieldsRegex.ReplaceAll(b, []byte("_"))
+
+	// Remove padding, hidden, or unused fields
+	removeFieldsRegex = regexp.MustCompile(`\b(X_\S+|Padding)`)
+	b = removeFieldsRegex.ReplaceAll(b, []byte("_"))
+
+	// Remove the first line of warning from cgo
+	b = b[bytes.IndexByte(b, '\n')+1:]
+	// Modify the command in the header to include:
+	//  mkpost, our own warning, and a build tag.
+	replacement := fmt.Sprintf(`$1 | go run mkpost.go
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build %s,%s`, goarch, goos)
+	cgoCommandRegex := regexp.MustCompile(`(cgo -godefs .*)`)
+	b = cgoCommandRegex.ReplaceAll(b, []byte(replacement))
+
+	// gofmt
+	b, err = format.Source(b)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	os.Stdout.Write(b)
+}

vendor/golang.org/x/sys/unix/mksyscall.pl

@@ -0,0 +1,341 @@
+#!/usr/bin/env perl
+# Copyright 2009 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.
+
+# This program reads a file containing function prototypes
+# (like syscall_darwin.go) and generates system call bodies.
+# The prototypes are marked by lines beginning with "//sys"
+# and read like func declarations if //sys is replaced by func, but:
+#	* The parameter lists must give a name for each argument.
+#	  This includes return parameters.
+#	* The parameter lists must give a type for each argument:
+#	  the (x, y, z int) shorthand is not allowed.
+#	* If the return parameter is an error number, it must be named errno.
+
+# A line beginning with //sysnb is like //sys, except that the
+# goroutine will not be suspended during the execution of the system
+# call.  This must only be used for system calls which can never
+# block, as otherwise the system call could cause all goroutines to
+# hang.
+
+use strict;
+
+my $cmdline = "mksyscall.pl " . join(' ', @ARGV);
+my $errors = 0;
+my $_32bit = "";
+my $plan9 = 0;
+my $openbsd = 0;
+my $netbsd = 0;
+my $dragonfly = 0;
+my $arm = 0; # 64-bit value should use (even, odd)-pair
+my $tags = "";  # build tags
+
+if($ARGV[0] eq "-b32") {
+	$_32bit = "big-endian";
+	shift;
+} elsif($ARGV[0] eq "-l32") {
+	$_32bit = "little-endian";
+	shift;
+}
+if($ARGV[0] eq "-plan9") {
+	$plan9 = 1;
+	shift;
+}
+if($ARGV[0] eq "-openbsd") {
+	$openbsd = 1;
+	shift;
+}
+if($ARGV[0] eq "-netbsd") {
+	$netbsd = 1;
+	shift;
+}
+if($ARGV[0] eq "-dragonfly") {
+	$dragonfly = 1;
+	shift;
+}
+if($ARGV[0] eq "-arm") {
+	$arm = 1;
+	shift;
+}
+if($ARGV[0] eq "-tags") {
+	shift;
+	$tags = $ARGV[0];
+	shift;
+}
+
+if($ARGV[0] =~ /^-/) {
+	print STDERR "usage: mksyscall.pl [-b32 | -l32] [-tags x,y] [file ...]\n";
+	exit 1;
+}
+
+# Check that we are using the new build system if we should
+if($ENV{'GOOS'} eq "linux" && $ENV{'GOARCH'} ne "sparc64") {
+	if($ENV{'GOLANG_SYS_BUILD'} ne "docker") {
+		print STDERR "In the new build system, mksyscall should not be called directly.\n";
+		print STDERR "See README.md\n";
+		exit 1;
+	}
+}
+
+
+sub parseparamlist($) {
+	my ($list) = @_;
+	$list =~ s/^\s*//;
+	$list =~ s/\s*$//;
+	if($list eq "") {
+		return ();
+	}
+	return split(/\s*,\s*/, $list);
+}
+
+sub parseparam($) {
+	my ($p) = @_;
+	if($p !~ /^(\S*) (\S*)$/) {
+		print STDERR "$ARGV:$.: malformed parameter: $p\n";
+		$errors = 1;
+		return ("xx", "int");
+	}
+	return ($1, $2);
+}
+
+my $text = "";
+while(<>) {
+	chomp;
+	s/\s+/ /g;
+	s/^\s+//;
+	s/\s+$//;
+	my $nonblock = /^\/\/sysnb /;
+	next if !/^\/\/sys / && !$nonblock;
+
+	# Line must be of the form
+	#	func Open(path string, mode int, perm int) (fd int, errno error)
+	# Split into name, in params, out params.
+	if(!/^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*((?i)SYS_[A-Z0-9_]+))?$/) {
+		print STDERR "$ARGV:$.: malformed //sys declaration\n";
+		$errors = 1;
+		next;
+	}
+	my ($func, $in, $out, $sysname) = ($2, $3, $4, $5);
+
+	# Split argument lists on comma.
+	my @in = parseparamlist($in);
+	my @out = parseparamlist($out);
+
+	# Try in vain to keep people from editing this file.
+	# The theory is that they jump into the middle of the file
+	# without reading the header.
+	$text .= "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n";
+
+	# Go function header.
+	my $out_decl = @out ? sprintf(" (%s)", join(', ', @out)) : "";
+	$text .= sprintf "func %s(%s)%s {\n", $func, join(', ', @in), $out_decl;
+
+	# Check if err return available
+	my $errvar = "";
+	foreach my $p (@out) {
+		my ($name, $type) = parseparam($p);
+		if($type eq "error") {
+			$errvar = $name;
+			last;
+		}
+	}
+
+	# Prepare arguments to Syscall.
+	my @args = ();
+	my $n = 0;
+	foreach my $p (@in) {
+		my ($name, $type) = parseparam($p);
+		if($type =~ /^\*/) {
+			push @args, "uintptr(unsafe.Pointer($name))";
+		} elsif($type eq "string" && $errvar ne "") {
+			$text .= "\tvar _p$n *byte\n";
+			$text .= "\t_p$n, $errvar = BytePtrFromString($name)\n";
+			$text .= "\tif $errvar != nil {\n\t\treturn\n\t}\n";
+			push @args, "uintptr(unsafe.Pointer(_p$n))";
+			$n++;
+		} elsif($type eq "string") {
+			print STDERR "$ARGV:$.: $func uses string arguments, but has no error return\n";
+			$text .= "\tvar _p$n *byte\n";
+			$text .= "\t_p$n, _ = BytePtrFromString($name)\n";
+			push @args, "uintptr(unsafe.Pointer(_p$n))";
+			$n++;
+		} elsif($type =~ /^\[\](.*)/) {
+			# Convert slice into pointer, length.
+			# Have to be careful not to take address of &a[0] if len == 0:
+			# pass dummy pointer in that case.
+			# Used to pass nil, but some OSes or simulators reject write(fd, nil, 0).
+			$text .= "\tvar _p$n unsafe.Pointer\n";
+			$text .= "\tif len($name) > 0 {\n\t\t_p$n = unsafe.Pointer(\&${name}[0])\n\t}";
+			$text .= " else {\n\t\t_p$n = unsafe.Pointer(&_zero)\n\t}";
+			$text .= "\n";
+			push @args, "uintptr(_p$n)", "uintptr(len($name))";
+			$n++;
+		} elsif($type eq "int64" && ($openbsd || $netbsd)) {
+			push @args, "0";
+			if($_32bit eq "big-endian") {
+				push @args, "uintptr($name>>32)", "uintptr($name)";
+			} elsif($_32bit eq "little-endian") {
+				push @args, "uintptr($name)", "uintptr($name>>32)";
+			} else {
+				push @args, "uintptr($name)";
+			}
+		} elsif($type eq "int64" && $dragonfly) {
+			if ($func !~ /^extp(read|write)/i) {
+				push @args, "0";
+			}
+			if($_32bit eq "big-endian") {
+				push @args, "uintptr($name>>32)", "uintptr($name)";
+			} elsif($_32bit eq "little-endian") {
+				push @args, "uintptr($name)", "uintptr($name>>32)";
+			} else {
+				push @args, "uintptr($name)";
+			}
+		} elsif($type eq "int64" && $_32bit ne "") {
+			if(@args % 2 && $arm) {
+				# arm abi specifies 64-bit argument uses
+				# (even, odd) pair
+				push @args, "0"
+			}
+			if($_32bit eq "big-endian") {
+				push @args, "uintptr($name>>32)", "uintptr($name)";
+			} else {
+				push @args, "uintptr($name)", "uintptr($name>>32)";
+			}
+		} else {
+			push @args, "uintptr($name)";
+		}
+	}
+
+	# Determine which form to use; pad args with zeros.
+	my $asm = "Syscall";
+	if ($nonblock) {
+		if ($errvar eq "" && $ENV{'GOOS'} eq "linux") {
+			$asm = "RawSyscallNoError";
+		} else {
+			$asm = "RawSyscall";
+		}
+	} else {
+		if ($errvar eq "" && $ENV{'GOOS'} eq "linux") {
+			$asm = "SyscallNoError";
+		}
+	}
+	if(@args <= 3) {
+		while(@args < 3) {
+			push @args, "0";
+		}
+	} elsif(@args <= 6) {
+		$asm .= "6";
+		while(@args < 6) {
+			push @args, "0";
+		}
+	} elsif(@args <= 9) {
+		$asm .= "9";
+		while(@args < 9) {
+			push @args, "0";
+		}
+	} else {
+		print STDERR "$ARGV:$.: too many arguments to system call\n";
+	}
+
+	# System call number.
+	if($sysname eq "") {
+		$sysname = "SYS_$func";
+		$sysname =~ s/([a-z])([A-Z])/${1}_$2/g;	# turn FooBar into Foo_Bar
+		$sysname =~ y/a-z/A-Z/;
+	}
+
+	# Actual call.
+	my $args = join(', ', @args);
+	my $call = "$asm($sysname, $args)";
+
+	# Assign return values.
+	my $body = "";
+	my @ret = ("_", "_", "_");
+	my $do_errno = 0;
+	for(my $i=0; $i<@out; $i++) {
+		my $p = $out[$i];
+		my ($name, $type) = parseparam($p);
+		my $reg = "";
+		if($name eq "err" && !$plan9) {
+			$reg = "e1";
+			$ret[2] = $reg;
+			$do_errno = 1;
+		} elsif($name eq "err" && $plan9) {
+			$ret[0] = "r0";
+			$ret[2] = "e1";
+			next;
+		} else {
+			$reg = sprintf("r%d", $i);
+			$ret[$i] = $reg;
+		}
+		if($type eq "bool") {
+			$reg = "$reg != 0";
+		}
+		if($type eq "int64" && $_32bit ne "") {
+			# 64-bit number in r1:r0 or r0:r1.
+			if($i+2 > @out) {
+				print STDERR "$ARGV:$.: not enough registers for int64 return\n";
+			}
+			if($_32bit eq "big-endian") {
+				$reg = sprintf("int64(r%d)<<32 | int64(r%d)", $i, $i+1);
+			} else {
+				$reg = sprintf("int64(r%d)<<32 | int64(r%d)", $i+1, $i);
+			}
+			$ret[$i] = sprintf("r%d", $i);
+			$ret[$i+1] = sprintf("r%d", $i+1);
+		}
+		if($reg ne "e1" || $plan9) {
+			$body .= "\t$name = $type($reg)\n";
+		}
+	}
+	if ($ret[0] eq "_" && $ret[1] eq "_" && $ret[2] eq "_") {
+		$text .= "\t$call\n";
+	} else {
+		if ($errvar eq "" && $ENV{'GOOS'} eq "linux") {
+			# raw syscall without error on Linux, see golang.org/issue/22924
+			$text .= "\t$ret[0], $ret[1] := $call\n";
+		} else {
+			$text .= "\t$ret[0], $ret[1], $ret[2] := $call\n";
+		}
+	}
+	$text .= $body;
+
+	if ($plan9 && $ret[2] eq "e1") {
+		$text .= "\tif int32(r0) == -1 {\n";
+		$text .= "\t\terr = e1\n";
+		$text .= "\t}\n";
+	} elsif ($do_errno) {
+		$text .= "\tif e1 != 0 {\n";
+		$text .= "\t\terr = errnoErr(e1)\n";
+		$text .= "\t}\n";
+	}
+	$text .= "\treturn\n";
+	$text .= "}\n\n";
+}
+
+chomp $text;
+chomp $text;
+
+if($errors) {
+	exit 1;
+}
+
+print <<EOF;
+// $cmdline
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build $tags
+
+package unix
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var _ syscall.Errno
+
+$text
+EOF
+exit 0;

vendor/golang.org/x/sys/unix/mksyscall_aix.pl

@@ -0,0 +1,385 @@
+#!/usr/bin/env perl
+# Copyright 2018 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.
+
+# This program reads a file containing function prototypes
+# (like syscall_aix.go) and generates system call bodies.
+# The prototypes are marked by lines beginning with "//sys"
+# and read like func declarations if //sys is replaced by func, but:
+#	* The parameter lists must give a name for each argument.
+#	  This includes return parameters.
+#	* The parameter lists must give a type for each argument:
+#	  the (x, y, z int) shorthand is not allowed.
+#	* If the return parameter is an error number, it must be named err.
+#	* If go func name needs to be different than its libc name,
+#	* or the function is not in libc, name could be specified
+#	* at the end, after "=" sign, like
+#	  //sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) = libsocket.getsockopt
+
+use strict;
+
+my $cmdline = "mksyscall_aix.pl " . join(' ', @ARGV);
+my $errors = 0;
+my $_32bit = "";
+my $tags = "";  # build tags
+my $aix = 0;
+my $solaris = 0;
+
+binmode STDOUT;
+
+if($ARGV[0] eq "-b32") {
+	$_32bit = "big-endian";
+	shift;
+} elsif($ARGV[0] eq "-l32") {
+	$_32bit = "little-endian";
+	shift;
+}
+if($ARGV[0] eq "-aix") {
+	$aix = 1;
+	shift;
+}
+if($ARGV[0] eq "-tags") {
+	shift;
+	$tags = $ARGV[0];
+	shift;
+}
+
+if($ARGV[0] =~ /^-/) {
+	print STDERR "usage: mksyscall_aix.pl [-b32 | -l32] [-tags x,y] [file ...]\n";
+	exit 1;
+}
+
+sub parseparamlist($) {
+	my ($list) = @_;
+	$list =~ s/^\s*//;
+	$list =~ s/\s*$//;
+	if($list eq "") {
+		return ();
+	}
+	return split(/\s*,\s*/, $list);
+}
+
+sub parseparam($) {
+	my ($p) = @_;
+	if($p !~ /^(\S*) (\S*)$/) {
+		print STDERR "$ARGV:$.: malformed parameter: $p\n";
+		$errors = 1;
+		return ("xx", "int");
+	}
+	return ($1, $2);
+}
+
+my $package = "";
+my $text = "";
+my $c_extern = "/*\n#include <stdint.h>\n";
+my @vars = ();
+while(<>) {
+	chomp;
+	s/\s+/ /g;
+	s/^\s+//;
+	s/\s+$//;
+	$package = $1 if !$package && /^package (\S+)$/;
+	my $nonblock = /^\/\/sysnb /;
+	next if !/^\/\/sys / && !$nonblock;
+
+	# Line must be of the form
+	# func Open(path string, mode int, perm int) (fd int, err error)
+	# Split into name, in params, out params.
+	if(!/^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$/) {
+		print STDERR "$ARGV:$.: malformed //sys declaration\n";
+		$errors = 1;
+		next;
+	}
+	my ($nb, $func, $in, $out, $modname, $sysname) = ($1, $2, $3, $4, $5, $6);
+
+	# Split argument lists on comma.
+	my @in = parseparamlist($in);
+	my @out = parseparamlist($out);
+
+	$in = join(', ', @in);
+	$out = join(', ', @out);
+
+	# Try in vain to keep people from editing this file.
+	# The theory is that they jump into the middle of the file
+	# without reading the header.
+	$text .= "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n";
+
+	# Check if value return, err return available
+	my $errvar = "";
+	my $retvar = "";
+	my $rettype = "";
+	foreach my $p (@out) {
+		my ($name, $type) = parseparam($p);
+		if($type eq "error") {
+			$errvar = $name;
+		} else {
+			$retvar = $name;
+			$rettype = $type;
+		}
+	}
+
+	# System call name.
+	#if($func ne "fcntl") {
+
+	if($sysname eq "") {
+		$sysname = "$func";
+	}
+
+	$sysname =~ s/([a-z])([A-Z])/${1}_$2/g;
+	$sysname =~ y/A-Z/a-z/; # All libc functions are lowercase.
+
+	my $C_rettype = "";
+	if($rettype eq "unsafe.Pointer") {
+		$C_rettype = "uintptr_t";
+	} elsif($rettype eq "uintptr") {
+		$C_rettype = "uintptr_t";
+	} elsif($rettype =~ /^_/) {
+		$C_rettype = "uintptr_t";
+	} elsif($rettype eq "int") {
+		$C_rettype = "int";
+	} elsif($rettype eq "int32") {
+		$C_rettype = "int";
+	} elsif($rettype eq "int64") {
+		$C_rettype = "long long";
+	} elsif($rettype eq "uint32") {
+		$C_rettype = "unsigned int";
+	} elsif($rettype eq "uint64") {
+		$C_rettype = "unsigned long long";
+	} else {
+		$C_rettype = "int";
+	}
+	if($sysname eq "exit") {
+		$C_rettype = "void";
+	}
+
+	# Change types to c
+	my @c_in = ();
+	foreach my $p (@in) {
+		my ($name, $type) = parseparam($p);
+		if($type =~ /^\*/) {
+			push @c_in, "uintptr_t";
+			} elsif($type eq "string") {
+			push @c_in, "uintptr_t";
+		} elsif($type =~ /^\[\](.*)/) {
+			push @c_in, "uintptr_t", "size_t";
+		} elsif($type eq "unsafe.Pointer") {
+			push @c_in, "uintptr_t";
+		} elsif($type eq "uintptr") {
+			push @c_in, "uintptr_t";
+		} elsif($type =~ /^_/) {
+			push @c_in, "uintptr_t";
+		} elsif($type eq "int") {
+			push @c_in, "int";
+		} elsif($type eq "int32") {
+			push @c_in, "int";
+		} elsif($type eq "int64") {
+			push @c_in, "long long";
+		} elsif($type eq "uint32") {
+			push @c_in, "unsigned int";
+		} elsif($type eq "uint64") {
+			push @c_in, "unsigned long long";
+		} else {
+			push @c_in, "int";
+		}
+	}
+
+	if ($func ne "fcntl" && $func ne "FcntlInt" && $func ne "readlen" && $func ne "writelen") {
+		# Imports of system calls from libc
+		$c_extern .= "$C_rettype $sysname";
+		my $c_in = join(', ', @c_in);
+		$c_extern .= "($c_in);\n";
+	}
+
+	# So file name.
+	if($aix) {
+		if($modname eq "") {
+			$modname = "libc.a/shr_64.o";
+		} else {
+			print STDERR "$func: only syscall using libc are available\n";
+			$errors = 1;
+			next;
+		}
+	}
+
+	my $strconvfunc = "C.CString";
+	my $strconvtype = "*byte";
+
+	# Go function header.
+	if($out ne "") {
+		$out = " ($out)";
+	}
+	if($text ne "") {
+		$text .= "\n"
+	}
+
+	$text .= sprintf "func %s(%s)%s {\n", $func, join(', ', @in), $out ;
+
+	# Prepare arguments to call.
+	my @args = ();
+	my $n = 0;
+	my $arg_n = 0;
+	foreach my $p (@in) {
+		my ($name, $type) = parseparam($p);
+		if($type =~ /^\*/) {
+			push @args, "C.uintptr_t(uintptr(unsafe.Pointer($name)))";
+		} elsif($type eq "string" && $errvar ne "") {
+			$text .= "\t_p$n := uintptr(unsafe.Pointer($strconvfunc($name)))\n";
+			push @args, "C.uintptr_t(_p$n)";
+			$n++;
+		} elsif($type eq "string") {
+			print STDERR "$ARGV:$.: $func uses string arguments, but has no error return\n";
+			$text .= "\t_p$n := uintptr(unsafe.Pointer($strconvfunc($name)))\n";
+			push @args, "C.uintptr_t(_p$n)";
+			$n++;
+		} elsif($type =~ /^\[\](.*)/) {
+			# Convert slice into pointer, length.
+			# Have to be careful not to take address of &a[0] if len == 0:
+			# pass nil in that case.
+			$text .= "\tvar _p$n *$1\n";
+			$text .= "\tif len($name) > 0 {\n\t\t_p$n = \&$name\[0]\n\t}\n";
+			push @args, "C.uintptr_t(uintptr(unsafe.Pointer(_p$n)))";
+			$n++;
+			$text .= "\tvar _p$n int\n";
+			$text .= "\t_p$n = len($name)\n";
+			push @args, "C.size_t(_p$n)";
+			$n++;
+		} elsif($type eq "int64" && $_32bit ne "") {
+			if($_32bit eq "big-endian") {
+				push @args, "uintptr($name >> 32)", "uintptr($name)";
+			} else {
+				push @args, "uintptr($name)", "uintptr($name >> 32)";
+			}
+			$n++;
+		} elsif($type eq "bool") {
+			$text .= "\tvar _p$n uint32\n";
+			$text .= "\tif $name {\n\t\t_p$n = 1\n\t} else {\n\t\t_p$n = 0\n\t}\n";
+			push @args, "_p$n";
+			$n++;
+		} elsif($type =~ /^_/) {
+			push @args, "C.uintptr_t(uintptr($name))";
+		} elsif($type eq "unsafe.Pointer") {
+			push @args, "C.uintptr_t(uintptr($name))";
+		} elsif($type eq "int") {
+			if (($arg_n == 2) && (($func eq "readlen") || ($func eq "writelen"))) {
+				push @args, "C.size_t($name)";
+			} elsif ($arg_n == 0 && $func eq "fcntl") {
+				push @args, "C.uintptr_t($name)";
+			} elsif (($arg_n == 2) && (($func eq "fcntl") || ($func eq "FcntlInt"))) {
+				push @args, "C.uintptr_t($name)";
+			} else {
+				push @args, "C.int($name)";
+			}
+		} elsif($type eq "int32") {
+			push @args, "C.int($name)";
+		} elsif($type eq "int64") {
+			push @args, "C.longlong($name)";
+		} elsif($type eq "uint32") {
+			push @args, "C.uint($name)";
+		} elsif($type eq "uint64") {
+			push @args, "C.ulonglong($name)";
+		} elsif($type eq "uintptr") {
+			push @args, "C.uintptr_t($name)";
+		} else {
+			push @args, "C.int($name)";
+		}
+		$arg_n++;
+	}
+	my $nargs = @args;
+
+
+	# Determine which form to use; pad args with zeros.
+	if ($nonblock) {
+	}
+
+	my $args = join(', ', @args);
+	my $call = "";
+	if ($sysname eq "exit") {
+		if ($errvar ne "") {
+			$call .= "er :=";
+		} else {
+			$call .= "";
+		}
+	}  elsif ($errvar ne "") {
+		$call .= "r0,er :=";
+	}  elsif ($retvar ne "") {
+		$call .= "r0,_ :=";
+	}  else {
+		$call .= ""
+	}
+	$call .= "C.$sysname($args)";
+
+	# Assign return values.
+	my $body = "";
+	my $failexpr = "";
+
+	for(my $i=0; $i<@out; $i++) {
+		my $p = $out[$i];
+		my ($name, $type) = parseparam($p);
+		my $reg = "";
+		if($name eq "err") {
+			$reg = "e1";
+		} else {
+			$reg = "r0";
+		}
+		if($reg ne "e1" ) {
+						$body .= "\t$name = $type($reg)\n";
+		}
+	}
+
+	# verify return
+	if ($sysname ne "exit" && $errvar ne "") {
+		if ($C_rettype =~ /^uintptr/) {
+			$body .= "\tif \(uintptr\(r0\) ==\^uintptr\(0\) && er != nil\) {\n";
+			$body .= "\t\t$errvar = er\n";
+			$body .= "\t}\n";
+		} else {
+			$body .= "\tif \(r0 ==-1 && er != nil\) {\n";
+			$body .= "\t\t$errvar = er\n";
+			$body .= "\t}\n";
+		}
+	} elsif ($errvar ne "") {
+		$body .= "\tif \(er != nil\) {\n";
+		$body .= "\t\t$errvar = er\n";
+		$body .= "\t}\n";
+	}
+
+	$text .= "\t$call\n";
+	$text .= $body;
+
+	$text .= "\treturn\n";
+	$text .= "}\n";
+}
+
+if($errors) {
+	exit 1;
+}
+
+print <<EOF;
+// $cmdline
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build $tags
+
+package $package
+
+
+$c_extern
+*/
+import "C"
+import (
+	"unsafe"
+	"syscall"
+)
+
+
+EOF
+
+print "import \"golang.org/x/sys/unix\"\n" if $package ne "unix";
+
+chomp($_=<<EOF);
+
+$text
+EOF
+print $_;
+exit 0;