ci: linux/386

ci: add tinygo test
Fix reflect.Pointer backward compatibility (#813 )
2022-09-09 19:58:56 -04:00 · 2022-09-09 19:58:47 -04:00 · 2022-08-26 09:15:03 -04:00 · 2022-08-22 18:39:11 -04:00 · 2022-08-22 14:05:37 -04:00 · 2022-08-20 21:24:03 -04:00
56 changed files with 2133 additions and 370 deletions
@@ -1,3 +1,4 @@
 * text=auto

 benchmark/benchmark.toml text eol=lf
+testdata/** text eol=lf
@@ -35,11 +35,11 @@ jobs:

    steps:
    - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3

    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v2
      with:
        languages: ${{ matrix.language }}
        # If you wish to specify custom queries, you can do so here or in a config file.
@@ -50,7 +50,7 @@ jobs:
    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
    # If this step fails, then you should remove it and run the build manually (see below)
    - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
+      uses: github/codeql-action/autobuild@v2

    # ℹ️ Command-line programs to run using the OS shell.
    # 📚 https://git.io/JvXDl
@@ -64,4 +64,4 @@ jobs:
    #   make release

    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+      uses: github/codeql-action/analyze@v2
@@ -9,12 +9,12 @@ jobs:
    runs-on: "ubuntu-latest"
    name: report
    steps:
-      - uses: actions/checkout@master
+      - uses: actions/checkout@v3
        with:
          fetch-depth: 0
      - name: Setup go
        uses: actions/setup-go@master
        with:
-          go-version: 1.16
+          go-version: 1.19
      - name: Run tests with coverage
        run: ./ci.sh coverage -d "${GITHUB_BASE_REF-HEAD}"
@@ -0,0 +1,36 @@
+# Those tests are allowed to fail. They don't represent an officially supported\
+# situation, but rather ones that are nice to have.
+name: experimental
+on:
+# Not ready for merged commits yet.
+#  push:
+#    branches:
+#      - v2
+  pull_request:
+    branches:
+      - v2
+
+jobs:
+  linux32:
+    name: linux 386
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Setup go
+        uses: actions/setup-go@master
+        with:
+          go-version: 1.19
+      - name: Run unit tests
+        run: GOARCH=386 go test ./...
+  tinygo:
+    name: tinygo 0.25.0
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: tinygo test ./...
+        run: |
+          docker run --rm -v $(pwd):/src -w /src tinygo/tinygo:0.25.0 tinygo test ./...
@@ -0,0 +1,39 @@
+name: release
+on:
+  push:
+    tags:
+      - "v2.*"
+  workflow_call:
+    inputs:
+      args:
+        description: "Extra arguments to pass goreleaser"
+        default: ""
+        required: false
+        type: string
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Set up Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.19
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v3
+        with:
+          distribution: goreleaser
+          version: latest
+          args: release ${{ inputs.args }} --rm-dist
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -12,14 +12,21 @@ jobs:
    strategy:
      matrix:
        os: [ 'ubuntu-latest', 'windows-latest', 'macos-latest']
-        go: [ '1.16', '1.17' ]
+        go: [ '1.18', '1.19' ]
    runs-on: ${{ matrix.os }}
    name: ${{ matrix.go }}/${{ matrix.os }}
    steps:
-      - uses: actions/checkout@master
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
      - name: Setup go ${{ matrix.go }}
        uses: actions/setup-go@master
        with:
          go-version: ${{ matrix.go }}
      - name: Run unit tests
        run: go test -race ./...
+  release-check:
+    if: ${{ github.ref != 'refs/heads/v2' }}
+    uses: pelletier/go-toml/.github/workflows/release.yml@v2
+    with:
+      args: --snapshot
@@ -3,3 +3,4 @@ fuzz/
 cmd/tomll/tomll
 cmd/tomljson/tomljson
 cmd/tomltestgen/tomltestgen
+dist
@@ -0,0 +1,123 @@
+before:
+  hooks:
+    - go mod tidy
+    - go fmt ./...
+    - go test ./...
+builds:
+  - id: tomll
+    main: ./cmd/tomll
+    binary: tomll
+    env:
+      - CGO_ENABLED=0
+    flags:
+      - -trimpath
+    ldflags:
+      - -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.CommitDate}}
+    mod_timestamp: '{{ .CommitTimestamp }}'
+    targets:
+      - linux_amd64
+      - linux_arm64
+      - linux_arm
+      - windows_amd64
+      - windows_arm64
+      - windows_arm
+      - darwin_amd64
+      - darwin_arm64
+  - id: tomljson
+    main: ./cmd/tomljson
+    binary: tomljson
+    env:
+      - CGO_ENABLED=0
+    flags:
+      - -trimpath
+    ldflags:
+      - -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.CommitDate}}
+    mod_timestamp: '{{ .CommitTimestamp }}'
+    targets:
+      - linux_amd64
+      - linux_arm64
+      - linux_arm
+      - windows_amd64
+      - windows_arm64
+      - windows_arm
+      - darwin_amd64
+      - darwin_arm64
+  - id: jsontoml
+    main: ./cmd/jsontoml
+    binary: jsontoml
+    env:
+      - CGO_ENABLED=0
+    flags:
+      - -trimpath
+    ldflags:
+      - -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.CommitDate}}
+    mod_timestamp: '{{ .CommitTimestamp }}'
+    targets:
+      - linux_amd64
+      - linux_arm64
+      - linux_arm
+      - windows_amd64
+      - windows_arm64
+      - windows_arm
+      - darwin_amd64
+      - darwin_arm64
+universal_binaries:
+  - id: tomll
+    replace: true
+    name_template: tomll
+  - id: tomljson
+    replace: true
+    name_template: tomljson
+  - id: jsontoml
+    replace: true
+    name_template: jsontoml
+archives:
+- id: jsontoml
+  format: tar.xz
+  builds:
+    - jsontoml
+  files:
+  - none*
+  name_template: "{{ .Binary }}_{{.Version}}_{{ .Os }}_{{ .Arch }}"
+- id: tomljson
+  format: tar.xz
+  builds:
+    - tomljson
+  files:
+  - none*
+  name_template: "{{ .Binary }}_{{.Version}}_{{ .Os }}_{{ .Arch }}"
+- id: tomll
+  format: tar.xz
+  builds:
+    - tomll
+  files:
+  - none*
+  name_template: "{{ .Binary }}_{{.Version}}_{{ .Os }}_{{ .Arch }}"
+dockers:
+  - id: tools
+    goos: linux
+    goarch: amd64
+    ids:
+      - jsontoml
+      - tomljson
+      - tomll
+    image_templates:
+      - "ghcr.io/pelletier/go-toml:latest"
+      - "ghcr.io/pelletier/go-toml:{{ .Tag }}"
+      - "ghcr.io/pelletier/go-toml:v{{ .Major }}"
+    skip_push: false
+checksum:
+  name_template: 'sha256sums.txt'
+snapshot:
+  name_template: "{{ incpatch .Version }}-next"
+release:
+  github:
+    owner: pelletier
+    name: go-toml
+  draft: true
+  prerelease: auto
+  mode: replace
+changelog:
+  use: github-native
+announce:
+  skip: true
@@ -155,6 +155,8 @@ Checklist:
 - Does not introduce backward-incompatible changes (unless discussed).
 - Has relevant doc changes.
 - Benchstat does not show performance regression.
+- Pull request is [labeled appropriately][pr-labels].
+- Title will be understandable in the changelog.

 1. Merge using "squash and merge".
 2. Make sure to edit the commit message to keep all the useful information
@@ -163,13 +165,25 @@ Checklist:

 ### New release

-1. Go to [releases][releases]. Click on "X commits to master since this
-   release".
-2. Make note of all the changes. Look for backward incompatible changes,
-   new features, and bug fixes.
-3. Pick the new version using the above and semver.
-4. Create a [new release][new-release].
-5. Follow the same format as [1.1.0][release-110].
+1. Decide on the next version number. Use semver.
+2. Generate release notes using [`gh`][gh]. Example:
+```
+$ gh api -X POST \
+  -F tag_name='v2.0.0-beta.5' \
+  -F target_commitish='v2' \
+  -F previous_tag_name='v2.0.0-beta.4' \
+  --jq '.body' \
+  repos/pelletier/go-toml/releases/generate-notes
+```
+3. Look for "Other changes". That would indicate a pull request not labeled
+   properly. Tweak labels and pull request titles until changelog looks good for
+   users.
+4. [Draft new release][new-release].
+5. Fill tag and target with the same value used to generate the changelog.
+6. Set title to the new tag value.
+7. Paste the generated changelog.
+8. Check "create discussion", in the "Releases" category.
+9. Check pre-release if new version is an alpha or beta.

 [issues-tracker]: https://github.com/pelletier/go-toml/issues
 [bug-report]: https://github.com/pelletier/go-toml/issues/new?template=bug_report.md
@@ -177,6 +191,6 @@ Checklist:
 [readme]: ./README.md
 [fork]: https://help.github.com/articles/fork-a-repo
 [pull-request]: https://help.github.com/en/articles/creating-a-pull-request
-[releases]: https://github.com/pelletier/go-toml/releases
 [new-release]: https://github.com/pelletier/go-toml/releases/new
-[release-110]: https://github.com/pelletier/go-toml/releases/tag/v1.1.0
+[gh]: https://github.com/cli/cli
+[pr-labels]: https://github.com/pelletier/go-toml/blob/v2/.github/release.yml
@@ -0,0 +1,5 @@
+FROM scratch
+ENV PATH "$PATH:/bin"
+COPY tomll /bin/tomll
+COPY tomljson /bin/tomljson
+COPY jsontoml /bin/jsontoml
@@ -1,6 +1,6 @@
 The MIT License (MIT)

-Copyright (c) 2013 - 2021 Thomas Pelletier, Eric Anderton
+Copyright (c) 2013 - 2022 Thomas Pelletier, Eric Anderton

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -4,24 +4,14 @@ Go library for the [TOML](https://toml.io/en/) format.

 This library supports [TOML v1.0.0](https://toml.io/en/v1.0.0).

-## Development status
-
-This is the upcoming major version of go-toml. It is currently in active
-development. As of release v2.0.0-beta.1, the library has reached feature parity
-with v1, and fixes a lot known bugs and performance issues along the way.
-
-If you do not need the advanced document editing features of v1, you are
-encouraged to try out this version.
-
-[👉 Roadmap for v2](https://github.com/pelletier/go-toml/discussions/506)
-
 [🐞 Bug Reports](https://github.com/pelletier/go-toml/issues)

 [💬 Anything else](https://github.com/pelletier/go-toml/discussions)

 ## Documentation

-Full API, examples, and implementation notes are available in the Go documentation.
+Full API, examples, and implementation notes are available in the Go
+documentation.

 [![Go Reference](https://pkg.go.dev/badge/github.com/pelletier/go-toml/v2.svg)](https://pkg.go.dev/github.com/pelletier/go-toml/v2)

@@ -48,10 +38,10 @@ operations should not be shockingly slow. See [benchmarks](#benchmarks).
 ### Strict mode

 `Decoder` can be set to "strict mode", which makes it error when some parts of
-the TOML document was not prevent in the target structure. This is a great way
+the TOML document was not present in the target structure. This is a great way
 to check for typos. [See example in the documentation][strict].

-[strict]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#example-Decoder.SetStrict
+[strict]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#example-Decoder.DisallowUnknownFields

 ### Contextualized errors

@@ -160,11 +150,11 @@ Execution time speedup compared to other Go TOML libraries:
    </thead>
    <tbody>
        <tr><td>Marshal/HugoFrontMatter-2</td><td>1.9x</td><td>1.9x</td></tr>
-        <tr><td>Marshal/ReferenceFile/map-2</td><td>1.7x</td><td>1.9x</td></tr>
-        <tr><td>Marshal/ReferenceFile/struct-2</td><td>2.4x</td><td>2.6x</td></tr>
-        <tr><td>Unmarshal/HugoFrontMatter-2</td><td>2.9x</td><td>2.5x</td></tr>
-        <tr><td>Unmarshal/ReferenceFile/map-2</td><td>2.7x</td><td>2.6x</td></tr>
-        <tr><td>Unmarshal/ReferenceFile/struct-2</td><td>4.8x</td><td>5.1x</td></tr>
+        <tr><td>Marshal/ReferenceFile/map-2</td><td>1.7x</td><td>1.8x</td></tr>
+        <tr><td>Marshal/ReferenceFile/struct-2</td><td>2.2x</td><td>2.5x</td></tr>
+        <tr><td>Unmarshal/HugoFrontMatter-2</td><td>2.9x</td><td>2.9x</td></tr>
+        <tr><td>Unmarshal/ReferenceFile/map-2</td><td>2.6x</td><td>2.9x</td></tr>
+        <tr><td>Unmarshal/ReferenceFile/struct-2</td><td>4.4x</td><td>5.3x</td></tr>
     </tbody>
 </table>
 <details><summary>See more</summary>
@@ -177,17 +167,17 @@ provided for completeness.</p>
        <tr><th>Benchmark</th><th>go-toml v1</th><th>BurntSushi/toml</th></tr>
    </thead>
    <tbody>
-        <tr><td>Marshal/SimpleDocument/map-2</td><td>1.7x</td><td>2.1x</td></tr>
-        <tr><td>Marshal/SimpleDocument/struct-2</td><td>2.5x</td><td>2.8x</td></tr>
-        <tr><td>Unmarshal/SimpleDocument/map-2</td><td>4.1x</td><td>3.1x</td></tr>
-        <tr><td>Unmarshal/SimpleDocument/struct-2</td><td>6.4x</td><td>4.3x</td></tr>
-        <tr><td>UnmarshalDataset/example-2</td><td>3.4x</td><td>3.2x</td></tr>
-        <tr><td>UnmarshalDataset/code-2</td><td>2.2x</td><td>2.5x</td></tr>
-        <tr><td>UnmarshalDataset/twitter-2</td><td>2.8x</td><td>2.7x</td></tr>
-        <tr><td>UnmarshalDataset/citm_catalog-2</td><td>2.2x</td><td>2.0x</td></tr>
-        <tr><td>UnmarshalDataset/canada-2</td><td>1.8x</td><td>1.4x</td></tr>
-        <tr><td>UnmarshalDataset/config-2</td><td>4.4x</td><td>2.9x</td></tr>
-        <tr><td>[Geo mean]</td><td>2.8x</td><td>2.6x</td></tr>
+        <tr><td>Marshal/SimpleDocument/map-2</td><td>1.8x</td><td>2.9x</td></tr>
+        <tr><td>Marshal/SimpleDocument/struct-2</td><td>2.7x</td><td>4.2x</td></tr>
+        <tr><td>Unmarshal/SimpleDocument/map-2</td><td>4.5x</td><td>3.1x</td></tr>
+        <tr><td>Unmarshal/SimpleDocument/struct-2</td><td>6.2x</td><td>3.9x</td></tr>
+        <tr><td>UnmarshalDataset/example-2</td><td>3.1x</td><td>3.5x</td></tr>
+        <tr><td>UnmarshalDataset/code-2</td><td>2.3x</td><td>3.1x</td></tr>
+        <tr><td>UnmarshalDataset/twitter-2</td><td>2.5x</td><td>2.6x</td></tr>
+        <tr><td>UnmarshalDataset/citm_catalog-2</td><td>2.1x</td><td>2.2x</td></tr>
+        <tr><td>UnmarshalDataset/canada-2</td><td>1.6x</td><td>1.3x</td></tr>
+        <tr><td>UnmarshalDataset/config-2</td><td>4.3x</td><td>3.2x</td></tr>
+        <tr><td>[Geo mean]</td><td>2.7x</td><td>2.8x</td></tr>
     </tbody>
 </table>
 <p>This table can be generated with <code>./ci.sh benchmark -a -html</code>.</p>
@@ -207,6 +197,44 @@ In case of trouble: [Go Modules FAQ][mod-faq].

 [mod-faq]: https://github.com/golang/go/wiki/Modules#why-does-installing-a-tool-via-go-get-fail-with-error-cannot-find-main-module

+## Tools
+
+Go-toml provides three handy command line tools:
+
+ * `tomljson`: Reads a TOML file and outputs its JSON representation.
+
+    ```
+    $ go install github.com/pelletier/go-toml/v2/cmd/tomljson@latest
+    $ tomljson --help
+    ```
+
+ * `jsontoml`: Reads a JSON file and outputs a TOML representation.
+
+    ```
+    $ go install github.com/pelletier/go-toml/v2/cmd/jsontoml@latest
+    $ jsontoml --help
+    ```
+
+ * `tomll`: Lints and reformats a TOML file.
+
+    ```
+    $ go install github.com/pelletier/go-toml/v2/cmd/tomll@latest
+    $ tomll --help
+    ```
+
+### Docker image
+
+Those tools are also available as a [Docker image][docker]. For example, to use
+`tomljson`:
+
+```
+docker run -i ghcr.io/pelletier/go-toml:v2 tomljson < example.toml
+```
+
+Multiple versions are availble on [ghcr.io][docker].
+
+[docker]: https://github.com/pelletier/go-toml/pkgs/container/go-toml
+
 ## Migrating from v1

 This section describes the differences between v1 and v2, with some pointers on
@@ -488,45 +516,37 @@ The new name is `Encoder.SetArraysMultiline`. The behavior should be the same.
 The new name is `Encoder.SetIndentSymbol`. The behavior should be the same.


-#### Embedded structs are tables
+#### Embedded structs behave like stdlib

 V1 defaults to merging embedded struct fields into the embedding struct. This
 behavior was unexpected because it does not follow the standard library. To
 avoid breaking backward compatibility, the `Encoder.PromoteAnonymous` method was
 added to make the encoder behave correctly. Given backward compatibility is not
-a problem anymore, v2 does the right thing by default. There is no way to revert
-to the old behavior, and `Encoder.PromoteAnonymous` has been removed.
-
-```go
-type Embedded struct {
-	Value string `toml:"value"`
-}
-
-type Doc struct {
-	Embedded
-}
-
-d := Doc{}
-
-fmt.Println("v1:")
-b, err := v1.Marshal(d)
-fmt.Println(string(b))
-
-fmt.Println("v2:")
-b, err = v2.Marshal(d)
-fmt.Println(string(b))
-
-// Output:
-// v1:
-// value = ""
-//
-// v2:
-// [Embedded]
-// value = ''
-```
+a problem anymore, v2 does the right thing by default: it follows the behavior
+of `encoding/json`. `Encoder.PromoteAnonymous` has been removed.

 [nodoc]: https://github.com/pelletier/go-toml/discussions/506#discussioncomment-1526038

+### `query`
+
+go-toml v1 provided the [`go-toml/query`][query] package. It allowed to run
+JSONPath-style queries on TOML files. This feature is not available in v2. For a
+replacement, check out [dasel][dasel].
+
+This package has been removed because it was essentially not supported anymore
+(last commit May 2020), increased the complexity of the code base, and more
+complete solutions exist out there.
+
+[query]: https://github.com/pelletier/go-toml/tree/f99d6bbca119636aeafcf351ee52b3d202782627/query
+[dasel]: https://github.com/TomWright/dasel
+
+## Versioning
+
+Go-toml follows [Semantic Versioning](http://semver.org/). The supported version
+of [TOML](https://github.com/toml-lang/toml) is indicated at the beginning of
+this document. The last two major versions of Go are supported
+(see [Go Release Policy](https://golang.org/doc/devel/release.html#policy)).
+
 ## License

 The MIT License (MIT). Read [LICENSE](LICENSE).
@@ -76,7 +76,8 @@ cover() {
    fi

    pushd "$dir"
-    go test -covermode=atomic -coverprofile=coverage.out ./...
+    go test -covermode=atomic  -coverpkg=./... -coverprofile=coverage.out.tmp ./...
+    cat coverage.out.tmp | grep -v testsuite | grep -v tomltestgen | grep -v gotoml-test-decoder > coverage.out
    go tool cover -func=coverage.out
    popd

@@ -103,16 +104,23 @@ coverage() {

 	    echo ""

-	    target_pct="$(cat ${target_out} |sed -E 's/.*total.*\t([0-9.]+)%/\1/;t;d')"
-	    head_pct="$(cat ${head_out} |sed -E 's/.*total.*\t([0-9.]+)%/\1/;t;d')"
+	    target_pct="$(tail -n2 ${target_out} | head -n1 | sed -E 's/.*total.*\t([0-9.]+)%.*/\1/')"
+	    head_pct="$(tail -n2 ${head_out} | head -n1 | sed -E 's/.*total.*\t([0-9.]+)%/\1/')"
 	    echo "Results: ${target} ${target_pct}% HEAD ${head_pct}%"

 	    delta_pct=$(echo "$head_pct - $target_pct" | bc -l)
 	    echo "Delta: ${delta_pct}"

 	    if [[ $delta_pct = \-* ]]; then
-		echo "Regression!";
-		return 1
+		    echo "Regression!";
+
+            target_diff="${output_dir}/target.diff.txt"
+            head_diff="${output_dir}/head.diff.txt"
+            cat "${target_out}" | grep -E '^github.com/pelletier/go-toml' | tr -s "\t " | cut -f 2,3 | sort > "${target_diff}"
+            cat "${head_out}" | grep -E '^github.com/pelletier/go-toml' | tr -s "\t " | cut -f 2,3 | sort > "${head_diff}"
+
+            diff --side-by-side --suppress-common-lines "${target_diff}" "${head_diff}"
+		    return 1
 	    fi
 	    return 0
 	    ;;
@@ -6,7 +6,7 @@ import (
 	"os"
 	"path"

-	"github.com/pelletier/go-toml/v2/testsuite"
+	"github.com/pelletier/go-toml/v2/internal/testsuite"
 )

 func main() {
@@ -0,0 +1,55 @@
+// Package jsontoml is a program that converts JSON to TOML.
+//
+// # Usage
+//
+// Reading from stdin:
+//
+//	cat file.json | jsontoml > file.toml
+//
+// Reading from a file:
+//
+//	jsontoml file.json > file.toml
+//
+// # Installation
+//
+// Using Go:
+//
+//	go install github.com/pelletier/go-toml/v2/cmd/jsontoml@latest
+package main
+
+import (
+	"encoding/json"
+	"io"
+
+	"github.com/pelletier/go-toml/v2"
+	"github.com/pelletier/go-toml/v2/internal/cli"
+)
+
+const usage = `jsontoml can be used in two ways:
+Reading from stdin:
+  cat file.json | jsontoml > file.toml
+
+Reading from a file:
+  jsontoml file.json > file.toml
+`
+
+func main() {
+	p := cli.Program{
+		Usage: usage,
+		Fn:    convert,
+	}
+	p.Execute()
+}
+
+func convert(r io.Reader, w io.Writer) error {
+	var v interface{}
+
+	d := json.NewDecoder(r)
+	err := d.Decode(&v)
+	if err != nil {
+		return err
+	}
+
+	e := toml.NewEncoder(w)
+	return e.Encode(v)
+}
@@ -0,0 +1,48 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestConvert(t *testing.T) {
+	examples := []struct {
+		name     string
+		input    string
+		expected string
+		errors   bool
+	}{
+		{
+			name: "valid json",
+			input: `
+{
+  "mytoml": {
+    "a": 42
+  }
+}`,
+			expected: `[mytoml]
+a = 42.0
+`,
+		},
+		{
+			name:   "invalid json",
+			input:  `{ foo`,
+			errors: true,
+		},
+	}
+
+	for _, e := range examples {
+		b := new(bytes.Buffer)
+		err := convert(strings.NewReader(e.input), b)
+		if e.errors {
+			require.Error(t, err)
+		} else {
+			assert.NoError(t, err)
+			assert.Equal(t, e.expected, b.String())
+		}
+	}
+}
@@ -0,0 +1,63 @@
+// Package tomljson is a program that converts TOML to JSON.
+//
+// # Usage
+//
+// Reading from stdin:
+//
+//	cat file.toml | tomljson > file.json
+//
+// Reading from a file:
+//
+//	tomljson file.toml > file.json
+//
+// # Installation
+//
+// Using Go:
+//
+//	go install github.com/pelletier/go-toml/v2/cmd/tomljson@latest
+package main
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/pelletier/go-toml/v2"
+	"github.com/pelletier/go-toml/v2/internal/cli"
+)
+
+const usage = `tomljson can be used in two ways:
+Reading from stdin:
+  cat file.toml | tomljson > file.json
+
+Reading from a file:
+  tomljson file.toml > file.json
+`
+
+func main() {
+	p := cli.Program{
+		Usage: usage,
+		Fn:    convert,
+	}
+	p.Execute()
+}
+
+func convert(r io.Reader, w io.Writer) error {
+	var v interface{}
+
+	d := toml.NewDecoder(r)
+	err := d.Decode(&v)
+	if err != nil {
+		var derr *toml.DecodeError
+		if errors.As(err, &derr) {
+			row, col := derr.Position()
+			return fmt.Errorf("%s\nerror occurred at row %d column %d", derr.String(), row, col)
+		}
+		return err
+	}
+
+	e := json.NewEncoder(w)
+	e.SetIndent("", "  ")
+	return e.Encode(v)
+}
@@ -0,0 +1,61 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestConvert(t *testing.T) {
+	examples := []struct {
+		name     string
+		input    io.Reader
+		expected string
+		errors   bool
+	}{
+		{
+			name: "valid toml",
+			input: strings.NewReader(`
+[mytoml]
+a = 42`),
+			expected: `{
+  "mytoml": {
+    "a": 42
+  }
+}
+`,
+		},
+		{
+			name:   "invalid toml",
+			input:  strings.NewReader(`bad = []]`),
+			errors: true,
+		},
+		{
+			name:   "bad reader",
+			input:  &badReader{},
+			errors: true,
+		},
+	}
+
+	for _, e := range examples {
+		b := new(bytes.Buffer)
+		err := convert(e.input, b)
+		if e.errors {
+			require.Error(t, err)
+		} else {
+			assert.NoError(t, err)
+			assert.Equal(t, e.expected, b.String())
+		}
+	}
+}
+
+type badReader struct{}
+
+func (r *badReader) Read([]byte) (int, error) {
+	return 0, fmt.Errorf("reader failed on purpose")
+}
@@ -0,0 +1,58 @@
+// Package tomll is a linter program for TOML.
+//
+// # Usage
+//
+// Reading from stdin, writing to stdout:
+//
+//	cat file.toml | tomll
+//
+// Reading and updating a list of files in place:
+//
+//	tomll a.toml b.toml c.toml
+//
+// # Installation
+//
+// Using Go:
+//
+//	go install github.com/pelletier/go-toml/v2/cmd/tomll@latest
+package main
+
+import (
+	"io"
+
+	"github.com/pelletier/go-toml/v2"
+	"github.com/pelletier/go-toml/v2/internal/cli"
+)
+
+const usage = `tomll can be used in two ways:
+
+Reading from stdin, writing to stdout:
+  cat file.toml | tomll > file.toml
+
+Reading and updating a list of files in place:
+  tomll a.toml b.toml c.toml
+
+When given a list of files, tomll will modify all files in place without asking.
+`
+
+func main() {
+	p := cli.Program{
+		Usage:   usage,
+		Fn:      convert,
+		Inplace: true,
+	}
+	p.Execute()
+}
+
+func convert(r io.Reader, w io.Writer) error {
+	var v interface{}
+
+	d := toml.NewDecoder(r)
+	err := d.Decode(&v)
+	if err != nil {
+		return err
+	}
+
+	e := toml.NewEncoder(w)
+	return e.Encode(v)
+}
@@ -0,0 +1,45 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestConvert(t *testing.T) {
+	examples := []struct {
+		name     string
+		input    string
+		expected string
+		errors   bool
+	}{
+		{
+			name: "valid toml",
+			input: `
+mytoml.a = 42.0
+`,
+			expected: `[mytoml]
+a = 42.0
+`,
+		},
+		{
+			name:   "invalid toml",
+			input:  `[what`,
+			errors: true,
+		},
+	}
+
+	for _, e := range examples {
+		b := new(bytes.Buffer)
+		err := convert(strings.NewReader(e.input), b)
+		if e.errors {
+			require.Error(t, err)
+		} else {
+			assert.NoError(t, err)
+			assert.Equal(t, e.expected, b.String())
+		}
+	}
+}
@@ -3,7 +3,7 @@
 //
 // Within the go-toml package, run `go generate`.  Otherwise, use:
 //
-//     go run github.com/pelletier/go-toml/cmd/tomltestgen -o toml_testgen_test.go
+//	go run github.com/pelletier/go-toml/cmd/tomltestgen -o toml_testgen_test.go
 package main

 import (
@@ -130,7 +130,11 @@ func parseDateTime(b []byte) (time.Time, error) {
 		}

 		seconds := direction * (hours*3600 + minutes*60)
-		zone = time.FixedZone("", seconds)
+		if seconds == 0 {
+			zone = time.UTC
+		} else {
+			zone = time.FixedZone("", seconds)
+		}
 		b = b[dateTimeByteLen:]
 	}

@@ -309,10 +313,10 @@ func parseFloat(b []byte) (float64, error) {
 	}

 	start := 0
-	if b[0] == '+' || b[0] == '-' {
+	if cleaned[0] == '+' || cleaned[0] == '-' {
 		start = 1
 	}
-	if b[start] == '0' && isDigit(b[start+1]) {
+	if cleaned[start] == '0' && isDigit(cleaned[start+1]) {
 		return 0, newDecodeError(b, "float integer part cannot have leading zeroes")
 	}

@@ -27,7 +27,7 @@ type DecodeError struct {
 // corresponding field in the target value. It contains all the missing fields
 // in Errors.
 //
-// Emitted by Decoder when SetStrict(true) was called.
+// Emitted by Decoder when DisallowUnknownFields() was called.
 type StrictMissingError struct {
 	// One error per field that could not be found.
 	Errors []DecodeError
@@ -103,6 +103,7 @@ func (e *DecodeError) Key() Key {
 //
 // The function copies all bytes used in DecodeError, so that document and
 // highlight can be freely deallocated.
+//
 //nolint:funlen
 func wrapDecodeError(document []byte, de *decodeError) *DecodeError {
 	offset := danger.SubsliceOffset(document, de.highlight)
@@ -0,0 +1,56 @@
+//go:build go1.18 || go1.19
+// +build go1.18 go1.19
+
+package toml_test
+
+import (
+	"io/ioutil"
+	"strings"
+	"testing"
+
+	"github.com/pelletier/go-toml/v2"
+	"github.com/stretchr/testify/require"
+)
+
+func FuzzUnmarshal(f *testing.F) {
+	file, err := ioutil.ReadFile("benchmark/benchmark.toml")
+	if err != nil {
+		panic(err)
+	}
+	f.Add(file)
+
+	f.Fuzz(func(t *testing.T, b []byte) {
+		if strings.Contains(string(b), "nan") {
+			// Current limitation of testify.
+			// https://github.com/stretchr/testify/issues/624
+			t.Skip("can't compare NaNs")
+		}
+
+		t.Log("INITIAL DOCUMENT ===========================")
+		t.Log(string(b))
+
+		var v interface{}
+		err := toml.Unmarshal(b, &v)
+		if err != nil {
+			return
+		}
+
+		t.Log("DECODED VALUE ===========================")
+		t.Logf("%#+v", v)
+
+		encoded, err := toml.Marshal(v)
+		if err != nil {
+			t.Fatalf("cannot marshal unmarshaled document: %s", err)
+		}
+
+		t.Log("ENCODED DOCUMENT ===========================")
+		t.Log(string(encoded))
+
+		var v2 interface{}
+		err = toml.Unmarshal(encoded, &v2)
+		if err != nil {
+			t.Fatalf("failed round trip: %s", err)
+		}
+		require.Equal(t, v, v2)
+	})
+}
@@ -2,5 +2,4 @@ module github.com/pelletier/go-toml/v2

 go 1.16

-// latest (v1.7.0) doesn't have the fix for time.Time
-require github.com/stretchr/testify v1.7.1-0.20210427113832-6241f9ab9942
+require github.com/stretchr/testify v1.8.0
@@ -1,11 +1,15 @@
-github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 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/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.7.1-0.20210427113832-6241f9ab9942 h1:t0lM6y/M5IiUZyvbBTcngso8SZEZICH7is9B6g/obVU=
-github.com/stretchr/testify v1.7.1-0.20210427113832-6241f9ab9942/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 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/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -11,10 +11,10 @@ import (
 //
 // For example:
 //
-// it := n.Children()
-// for it.Next() {
-// 		it.Node()
-// }
+//	it := n.Children()
+//	for it.Next() {
+//			it.Node()
+//	}
 type Iterator struct {
 	started bool
 	node    *Node
@@ -0,0 +1,88 @@
+package cli
+
+import (
+	"bytes"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+
+	"github.com/pelletier/go-toml/v2"
+)
+
+type ConvertFn func(r io.Reader, w io.Writer) error
+
+type Program struct {
+	Usage string
+	Fn    ConvertFn
+	// Inplace allows the command to take more than one file as argument and
+	// perform convertion in place on each provided file.
+	Inplace bool
+}
+
+func (p *Program) Execute() {
+	flag.Usage = func() { fmt.Fprintf(os.Stderr, p.Usage) }
+	flag.Parse()
+	os.Exit(p.main(flag.Args(), os.Stdin, os.Stdout, os.Stderr))
+}
+
+func (p *Program) main(files []string, input io.Reader, output, error io.Writer) int {
+	err := p.run(files, input, output)
+	if err != nil {
+
+		var derr *toml.DecodeError
+		if errors.As(err, &derr) {
+			fmt.Fprintln(error, derr.String())
+			row, col := derr.Position()
+			fmt.Fprintln(error, "error occurred at row", row, "column", col)
+		} else {
+			fmt.Fprintln(error, err.Error())
+		}
+
+		return -1
+	}
+	return 0
+}
+
+func (p *Program) run(files []string, input io.Reader, output io.Writer) error {
+	if len(files) > 0 {
+		if p.Inplace {
+			return p.runAllFilesInPlace(files)
+		}
+		f, err := os.Open(files[0])
+		if err != nil {
+			return err
+		}
+		defer f.Close()
+		input = f
+	}
+	return p.Fn(input, output)
+}
+
+func (p *Program) runAllFilesInPlace(files []string) error {
+	for _, path := range files {
+		err := p.runFileInPlace(path)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (p *Program) runFileInPlace(path string) error {
+	in, err := ioutil.ReadFile(path)
+	if err != nil {
+		return err
+	}
+
+	out := new(bytes.Buffer)
+
+	err = p.Fn(bytes.NewReader(in), out)
+	if err != nil {
+		return err
+	}
+
+	return ioutil.WriteFile(path, out.Bytes(), 0600)
+}
@@ -0,0 +1,172 @@
+package cli
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path"
+	"strings"
+	"testing"
+
+	"github.com/pelletier/go-toml/v2"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func processMain(args []string, input io.Reader, stdout, stderr io.Writer, f ConvertFn) int {
+	p := Program{Fn: f}
+	return p.main(args, input, stdout, stderr)
+}
+
+func TestProcessMainStdin(t *testing.T) {
+	stdout := new(bytes.Buffer)
+	stderr := new(bytes.Buffer)
+	input := strings.NewReader("this is the input")
+
+	exit := processMain([]string{}, input, stdout, stderr, func(r io.Reader, w io.Writer) error {
+		return nil
+	})
+
+	assert.Equal(t, 0, exit)
+	assert.Empty(t, stdout.String())
+	assert.Empty(t, stderr.String())
+}
+
+func TestProcessMainStdinErr(t *testing.T) {
+	stdout := new(bytes.Buffer)
+	stderr := new(bytes.Buffer)
+	input := strings.NewReader("this is the input")
+
+	exit := processMain([]string{}, input, stdout, stderr, func(r io.Reader, w io.Writer) error {
+		return fmt.Errorf("something bad")
+	})
+
+	assert.Equal(t, -1, exit)
+	assert.Empty(t, stdout.String())
+	assert.NotEmpty(t, stderr.String())
+}
+
+func TestProcessMainStdinDecodeErr(t *testing.T) {
+	stdout := new(bytes.Buffer)
+	stderr := new(bytes.Buffer)
+	input := strings.NewReader("this is the input")
+
+	exit := processMain([]string{}, input, stdout, stderr, func(r io.Reader, w io.Writer) error {
+		var v interface{}
+		return toml.Unmarshal([]byte(`qwe = 001`), &v)
+	})
+
+	assert.Equal(t, -1, exit)
+	assert.Empty(t, stdout.String())
+	assert.Contains(t, stderr.String(), "error occurred at")
+}
+
+func TestProcessMainFileExists(t *testing.T) {
+	tmpfile, err := ioutil.TempFile("", "example")
+	require.NoError(t, err)
+	defer os.Remove(tmpfile.Name())
+	_, err = tmpfile.Write([]byte(`some data`))
+	require.NoError(t, err)
+
+	stdout := new(bytes.Buffer)
+	stderr := new(bytes.Buffer)
+
+	exit := processMain([]string{tmpfile.Name()}, nil, stdout, stderr, func(r io.Reader, w io.Writer) error {
+		return nil
+	})
+
+	assert.Equal(t, 0, exit)
+	assert.Empty(t, stdout.String())
+	assert.Empty(t, stderr.String())
+}
+
+func TestProcessMainFileDoesNotExist(t *testing.T) {
+	stdout := new(bytes.Buffer)
+	stderr := new(bytes.Buffer)
+
+	exit := processMain([]string{"/lets/hope/this/does/not/exist"}, nil, stdout, stderr, func(r io.Reader, w io.Writer) error {
+		return nil
+	})
+
+	assert.Equal(t, -1, exit)
+	assert.Empty(t, stdout.String())
+	assert.NotEmpty(t, stderr.String())
+}
+
+func TestProcessMainFilesInPlace(t *testing.T) {
+	dir, err := ioutil.TempDir("", "")
+	require.NoError(t, err)
+	defer os.RemoveAll(dir)
+
+	path1 := path.Join(dir, "file1")
+	path2 := path.Join(dir, "file2")
+
+	err = ioutil.WriteFile(path1, []byte("content 1"), 0600)
+	require.NoError(t, err)
+	err = ioutil.WriteFile(path2, []byte("content 2"), 0600)
+	require.NoError(t, err)
+
+	p := Program{
+		Fn:      dummyFileFn,
+		Inplace: true,
+	}
+
+	exit := p.main([]string{path1, path2}, os.Stdin, os.Stdout, os.Stderr)
+
+	require.Equal(t, 0, exit)
+
+	v1, err := ioutil.ReadFile(path1)
+	require.NoError(t, err)
+	require.Equal(t, "1", string(v1))
+
+	v2, err := ioutil.ReadFile(path2)
+	require.NoError(t, err)
+	require.Equal(t, "2", string(v2))
+}
+
+func TestProcessMainFilesInPlaceErrRead(t *testing.T) {
+	p := Program{
+		Fn:      dummyFileFn,
+		Inplace: true,
+	}
+
+	exit := p.main([]string{"/this/path/is/invalid"}, os.Stdin, os.Stdout, os.Stderr)
+
+	require.Equal(t, -1, exit)
+}
+
+func TestProcessMainFilesInPlaceFailFn(t *testing.T) {
+	dir, err := ioutil.TempDir("", "")
+	require.NoError(t, err)
+	defer os.RemoveAll(dir)
+
+	path1 := path.Join(dir, "file1")
+
+	err = ioutil.WriteFile(path1, []byte("content 1"), 0600)
+	require.NoError(t, err)
+
+	p := Program{
+		Fn:      func(io.Reader, io.Writer) error { return fmt.Errorf("oh no") },
+		Inplace: true,
+	}
+
+	exit := p.main([]string{path1}, os.Stdin, os.Stdout, os.Stderr)
+
+	require.Equal(t, -1, exit)
+
+	v1, err := ioutil.ReadFile(path1)
+	require.NoError(t, err)
+	require.Equal(t, "content 1", string(v1))
+}
+
+func dummyFileFn(r io.Reader, w io.Writer) error {
+	b, err := ioutil.ReadAll(r)
+	if err != nil {
+		return err
+	}
+	v := strings.SplitN(string(b), " ", 2)[1]
+	_, err = w.Write([]byte(v))
+	return err
+}
@@ -67,6 +67,7 @@ func TestDocMarshal(t *testing.T) {
 	}

 	marshalTestToml := `title = 'TOML Marshal Testing'
+
 [basic_lists]
 floats = [12.3, 45.6, 78.9]
 bools = [true, false, true]
@@ -89,7 +90,6 @@ name = 'Second'
 [subdoc.first]
 name = 'First'

-
 [basic]
 uint = 5001
 bool = true
@@ -101,9 +101,9 @@ date = 1979-05-27T07:32:00Z

 [[subdoclist]]
 name = 'List.First'
+
 [[subdoclist]]
 name = 'List.Second'
-
 `

 	result, err := toml.Marshal(docData)
@@ -117,14 +117,15 @@ func TestBasicMarshalQuotedKey(t *testing.T) {

 	expected := `'Z.string-àéù' = 'Hello'
 'Yfloat-𝟘' = 3.5
+
 ['Xsubdoc-àéù']
 String2 = 'One'

 [['W.sublist-𝟘']]
 String2 = 'Two'
+
 [['W.sublist-𝟘']]
 String2 = 'Three'
-
 `

 	require.Equal(t, string(expected), string(result))
@@ -159,8 +160,8 @@ bool = false
 int = 0
 string = ''
 stringlist = []
-[map]

+[map]
 `

 	require.Equal(t, string(expected), string(result))
@@ -151,6 +151,7 @@ type quotedKeyMarshalTestStruct struct {
 }

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused,varcheck
 var quotedKeyMarshalTestData = quotedKeyMarshalTestStruct{
 	String:  "Hello",
@@ -160,6 +161,7 @@ var quotedKeyMarshalTestData = quotedKeyMarshalTestStruct{
 }

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused,varcheck
 var quotedKeyMarshalTestToml = []byte(`"Yfloat-𝟘" = 3.5
 "Z.string-àéù" = "Hello"
@@ -272,6 +274,7 @@ var docData = testDoc{
 }

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused,varcheck
 var mapTestDoc = testMapDoc{
 	Title: "TOML Marshal Testing",
@@ -559,10 +562,12 @@ func (c customMarshaler) MarshalTOML() ([]byte, error) {
 var customMarshalerData = customMarshaler{FirstName: "Sally", LastName: "Fields"}

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused,varcheck
 var customMarshalerToml = []byte(`Sally Fields`)

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused,varcheck
 var nestedCustomMarshalerData = customMarshalerParent{
 	Self:    customMarshaler{FirstName: "Maiku", LastName: "Suteda"},
@@ -570,6 +575,7 @@ var nestedCustomMarshalerData = customMarshalerParent{
 }

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused,varcheck
 var nestedCustomMarshalerToml = []byte(`friends = ["Sally Fields"]
 me = "Maiku Suteda"
@@ -611,6 +617,7 @@ func TestUnmarshalTextMarshaler(t *testing.T) {
 }

 // TODO: Remove nolint once type and methods are used by a test
+//
 //nolint:unused
 type precedentMarshaler struct {
 	FirstName string
@@ -629,6 +636,7 @@ func (m precedentMarshaler) MarshalTOML() ([]byte, error) {
 }

 // TODO: Remove nolint once type and method are used by a test
+//
 //nolint:unused
 type customPointerMarshaler struct {
 	FirstName string
@@ -641,6 +649,7 @@ func (m *customPointerMarshaler) MarshalTOML() ([]byte, error) {
 }

 // TODO: Remove nolint once type and method are used by a test
+//
 //nolint:unused
 type textPointerMarshaler struct {
 	FirstName string
@@ -653,6 +662,7 @@ func (m *textPointerMarshaler) MarshalText() ([]byte, error) {
 }

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused,varcheck
 var commentTestToml = []byte(`
 # it's a comment on type
@@ -690,6 +700,7 @@ type mapsTestStruct struct {
 }

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused,varcheck
 var mapsTestData = mapsTestStruct{
 	Simple: map[string]string{
@@ -713,6 +724,7 @@ var mapsTestData = mapsTestStruct{
 }

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused,varcheck
 var mapsTestToml = []byte(`
 [Other]
@@ -735,6 +747,7 @@ var mapsTestToml = []byte(`
 `)

 // TODO: Remove nolint once type is used by a test
+//
 //nolint:deadcode,unused
 type structArrayNoTag struct {
 	A struct {
@@ -744,6 +757,7 @@ type structArrayNoTag struct {
 }

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused,varcheck
 var customTagTestToml = []byte(`
 [postgres]
@@ -758,6 +772,7 @@ var customTagTestToml = []byte(`
 `)

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused,varcheck
 var customCommentTagTestToml = []byte(`
 # db connection
@@ -771,6 +786,7 @@ var customCommentTagTestToml = []byte(`
 `)

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused,varcheck
 var customCommentedTagTestToml = []byte(`
 [postgres]
@@ -825,6 +841,7 @@ func TestUnmarshalTabInStringAndQuotedKey(t *testing.T) {
 }

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused,varcheck
 var customMultilineTagTestToml = []byte(`int_slice = [
  1,
@@ -834,6 +851,7 @@ var customMultilineTagTestToml = []byte(`int_slice = [
 `)

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused,varcheck
 var testDocBasicToml = []byte(`
 [document]
@@ -846,12 +864,14 @@ var testDocBasicToml = []byte(`
 `)

 // TODO: Remove nolint once type is used by a test
+//
 //nolint:deadcode
 type testDocCustomTag struct {
 	Doc testDocBasicsCustomTag `file:"document"`
 }

 // TODO: Remove nolint once type is used by a test
+//
 //nolint:deadcode
 type testDocBasicsCustomTag struct {
 	Bool       bool      `file:"bool_val"`
@@ -864,6 +884,7 @@ type testDocBasicsCustomTag struct {
 }

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,varcheck
 var testDocCustomTagData = testDocCustomTag{
 	Doc: testDocBasicsCustomTag{
@@ -927,6 +948,29 @@ func TestUnmarshalMapWithTypedKey(t *testing.T) {
 	}
 }

+func TestUnmarshalTypeTableHeader(t *testing.T) {
+	testToml := []byte(`
+		[test]
+		a = 1
+		`)
+
+	type header string
+	var result map[header]map[string]int
+	err := toml.Unmarshal(testToml, &result)
+	if err != nil {
+		t.Errorf("Received unexpected error: %s", err)
+		return
+	}
+
+	expected := map[header]map[string]int{
+		"test": map[string]int{"a": 1},
+	}
+
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Bad unmarshal: expected %v, got %v", expected, result)
+	}
+}
+
 func TestUnmarshalNonPointer(t *testing.T) {
 	a := 1
 	err := toml.Unmarshal([]byte{}, a)
@@ -943,6 +987,7 @@ func TestUnmarshalInvalidPointerKind(t *testing.T) {
 }

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused
 type testDuration struct {
 	Nanosec   time.Duration  `toml:"nanosec"`
@@ -957,6 +1002,7 @@ type testDuration struct {
 }

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused,varcheck
 var testDurationToml = []byte(`
 nanosec = "1ns"
@@ -971,6 +1017,7 @@ a_string = "15s"
 `)

 // TODO: Remove nolint once var is used by a test
+//
 //nolint:deadcode,unused,varcheck
 var testDurationToml2 = []byte(`a_string = "15s"
 hour = "1h0m0s"
@@ -984,6 +1031,7 @@ sec = "1s"
 `)

 // TODO: Remove nolint once type is used by a test
+//
 //nolint:deadcode,unused
 type testBadDuration struct {
 	Val time.Duration `toml:"val"`
@@ -1925,7 +1973,7 @@ func decoder(doc string) *toml.Decoder {

 func strictDecoder(doc string) *toml.Decoder {
 	d := decoder(doc)
-	d.SetStrict(true)
+	d.DisallowUnknownFields()
 	return d
 }

@@ -79,6 +79,7 @@ type entry struct {
 	name     []byte
 	kind     keyKind
 	explicit bool
+	kv       bool
 }

 // Find the index of the child of parentIdx with key k. Returns -1 if
@@ -111,7 +112,7 @@ func (s *SeenTracker) clear(idx int) {
 	s.entries[idx].child = -1
 }

-func (s *SeenTracker) create(parentIdx int, name []byte, kind keyKind, explicit bool) int {
+func (s *SeenTracker) create(parentIdx int, name []byte, kind keyKind, explicit bool, kv bool) int {
 	e := entry{
 		child: -1,
 		next:  s.entries[parentIdx].child,
@@ -119,6 +120,7 @@ func (s *SeenTracker) create(parentIdx int, name []byte, kind keyKind, explicit
 		name:     name,
 		kind:     kind,
 		explicit: explicit,
+		kv:       kv,
 	}
 	var idx int
 	if s.entries[0].next >= 0 {
@@ -137,7 +139,10 @@ func (s *SeenTracker) create(parentIdx int, name []byte, kind keyKind, explicit

 func (s *SeenTracker) setExplicitFlag(parentIdx int) {
 	for i := s.entries[parentIdx].child; i >= 0; i = s.entries[i].next {
-		s.entries[i].explicit = true
+		if s.entries[i].kv {
+			s.entries[i].explicit = true
+			s.entries[i].kv = false
+		}
 		s.setExplicitFlag(i)
 	}
 }
@@ -183,7 +188,7 @@ func (s *SeenTracker) checkTable(node *ast.Node) error {
 		idx := s.find(parentIdx, k)

 		if idx < 0 {
-			idx = s.create(parentIdx, k, tableKind, false)
+			idx = s.create(parentIdx, k, tableKind, false, false)
 		} else {
 			entry := s.entries[idx]
 			if entry.kind == valueKind {
@@ -206,7 +211,7 @@ func (s *SeenTracker) checkTable(node *ast.Node) error {
 		}
 		s.entries[idx].explicit = true
 	} else {
-		idx = s.create(parentIdx, k, tableKind, true)
+		idx = s.create(parentIdx, k, tableKind, true, false)
 	}

 	s.currentIdx = idx
@@ -233,7 +238,7 @@ func (s *SeenTracker) checkArrayTable(node *ast.Node) error {
 		idx := s.find(parentIdx, k)

 		if idx < 0 {
-			idx = s.create(parentIdx, k, tableKind, false)
+			idx = s.create(parentIdx, k, tableKind, false, false)
 		} else {
 			entry := s.entries[idx]
 			if entry.kind == valueKind {
@@ -254,7 +259,7 @@ func (s *SeenTracker) checkArrayTable(node *ast.Node) error {
 		}
 		s.clear(idx)
 	} else {
-		idx = s.create(parentIdx, k, arrayTableKind, true)
+		idx = s.create(parentIdx, k, arrayTableKind, true, false)
 	}

 	s.currentIdx = idx
@@ -272,7 +277,7 @@ func (s *SeenTracker) checkKeyValue(node *ast.Node) error {
 		idx := s.find(parentIdx, k)

 		if idx < 0 {
-			idx = s.create(parentIdx, k, tableKind, false)
+			idx = s.create(parentIdx, k, tableKind, false, true)
 		} else {
 			entry := s.entries[idx]
 			if it.IsLast() {
@@ -0,0 +1,16 @@
+package tracker
+
+import (
+	"testing"
+	"unsafe"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestEntrySize(t *testing.T) {
+	// Validate no regression on the size of entry{}. This is a critical bit for
+	// performance of unmarshaling documents. Should only be increased with care
+	// and a very good reason.
+	maxExpectedEntrySize := 48
+	require.LessOrEqual(t, int(unsafe.Sizeof(entry{})), maxExpectedEntrySize)
+}
@@ -54,7 +54,7 @@ func NewEncoder(w io.Writer) *Encoder {
 // This behavior can be controlled on an individual struct field basis with the
 // inline tag:
 //
-//   MyField `inline:"true"`
+//	MyField `toml:",inline"`
 func (enc *Encoder) SetTablesInline(inline bool) *Encoder {
 	enc.tablesInline = inline
 	return enc
@@ -65,7 +65,7 @@ func (enc *Encoder) SetTablesInline(inline bool) *Encoder {
 //
 // This behavior can be controlled on an individual struct field basis with the multiline tag:
 //
-//   MyField `multiline:"true"`
+//	MyField `multiline:"true"`
 func (enc *Encoder) SetArraysMultiline(multiline bool) *Encoder {
 	enc.arraysMultiline = multiline
 	return enc
@@ -89,7 +89,7 @@ func (enc *Encoder) SetIndentTables(indent bool) *Encoder {
 //
 // If v cannot be represented to TOML it returns an error.
 //
-// Encoding rules
+// # Encoding rules
 //
 // A top level slice containing only maps or structs is encoded as [[table
 // array]].
@@ -107,10 +107,30 @@ func (enc *Encoder) SetIndentTables(indent bool) *Encoder {
 // a newline character or a single quote. In that case they are emitted as
 // quoted strings.
 //
+// Unsigned integers larger than math.MaxInt64 cannot be encoded. Doing so
+// results in an error. This rule exists because the TOML specification only
+// requires parsers to support at least the 64 bits integer range. Allowing
+// larger numbers would create non-standard TOML documents, which may not be
+// readable (at best) by other implementations. To encode such numbers, a
+// solution is a custom type that implements encoding.TextMarshaler.
+//
 // When encoding structs, fields are encoded in order of definition, with their
 // exact name.
 //
-// Struct tags
+// Tables and array tables are separated by empty lines. However, consecutive
+// subtables definitions are not. For example:
+//
+//	[top1]
+//
+//	[top2]
+//	[top2.child1]
+//
+//	[[array]]
+//
+//	[[array]]
+//	[array.child2]
+//
+// # Struct tags
 //
 // The encoding of each public struct field can be customized by the format
 // string in the "toml" key of the struct field's tag. This follows
@@ -128,7 +148,8 @@ func (enc *Encoder) SetIndentTables(indent bool) *Encoder {
 //
 // In addition to the "toml" tag struct tag, a "comment" tag can be used to emit
 // a TOML comment before the value being annotated. Comments are ignored inside
-// inline tables.
+// inline tables. For array tables, the comment is only present before the first
+// element of the array.
 func (enc *Encoder) Encode(v interface{}) error {
 	var (
 		b   []byte
@@ -208,11 +229,20 @@ func (ctx *encoderCtx) isRoot() bool {
 }

 func (enc *Encoder) encode(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, error) {
-	if !v.IsZero() {
-		i, ok := v.Interface().(time.Time)
-		if ok {
-			return i.AppendFormat(b, time.RFC3339), nil
+	i := v.Interface()
+
+	switch x := i.(type) {
+	case time.Time:
+		if x.Nanosecond() > 0 {
+			return x.AppendFormat(b, time.RFC3339Nano), nil
 		}
+		return x.AppendFormat(b, time.RFC3339), nil
+	case LocalTime:
+		return append(b, x.String()...), nil
+	case LocalDate:
+		return append(b, x.String()...), nil
+	case LocalDateTime:
+		return append(b, x.String()...), nil
 	}

 	hasTextMarshaler := v.Type().Implements(textMarshalerType)
@@ -260,16 +290,31 @@ func (enc *Encoder) encode(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, e
 	case reflect.String:
 		b = enc.encodeString(b, v.String(), ctx.options)
 	case reflect.Float32:
-		if math.Trunc(v.Float()) == v.Float() {
-			b = strconv.AppendFloat(b, v.Float(), 'f', 1, 32)
+		f := v.Float()
+
+		if math.IsNaN(f) {
+			b = append(b, "nan"...)
+		} else if f > math.MaxFloat32 {
+			b = append(b, "inf"...)
+		} else if f < -math.MaxFloat32 {
+			b = append(b, "-inf"...)
+		} else if math.Trunc(f) == f {
+			b = strconv.AppendFloat(b, f, 'f', 1, 32)
 		} else {
-			b = strconv.AppendFloat(b, v.Float(), 'f', -1, 32)
+			b = strconv.AppendFloat(b, f, 'f', -1, 32)
 		}
 	case reflect.Float64:
-		if math.Trunc(v.Float()) == v.Float() {
-			b = strconv.AppendFloat(b, v.Float(), 'f', 1, 64)
+		f := v.Float()
+		if math.IsNaN(f) {
+			b = append(b, "nan"...)
+		} else if f > math.MaxFloat64 {
+			b = append(b, "inf"...)
+		} else if f < -math.MaxFloat64 {
+			b = append(b, "-inf"...)
+		} else if math.Trunc(f) == f {
+			b = strconv.AppendFloat(b, f, 'f', 1, 64)
 		} else {
-			b = strconv.AppendFloat(b, v.Float(), 'f', -1, 64)
+			b = strconv.AppendFloat(b, f, 'f', -1, 64)
 		}
 	case reflect.Bool:
 		if v.Bool() {
@@ -278,7 +323,11 @@ func (enc *Encoder) encode(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, e
 			b = append(b, "false"...)
 		}
 	case reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8, reflect.Uint:
-		b = strconv.AppendUint(b, v.Uint(), 10)
+		x := v.Uint()
+		if x > uint64(math.MaxInt64) {
+			return nil, fmt.Errorf("toml: not encoding uint (%d) greater than max int64 (%d)", x, int64(math.MaxInt64))
+		}
+		b = strconv.AppendUint(b, x, 10)
 	case reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8, reflect.Int:
 		b = strconv.AppendInt(b, v.Int(), 10)
 	default:
@@ -297,28 +346,19 @@ func isNil(v reflect.Value) bool {
 	}
 }

+func shouldOmitEmpty(options valueOptions, v reflect.Value) bool {
+	return options.omitempty && isEmptyValue(v)
+}
+
 func (enc *Encoder) encodeKv(b []byte, ctx encoderCtx, options valueOptions, v reflect.Value) ([]byte, error) {
 	var err error

-	if !ctx.hasKey {
-		panic("caller of encodeKv should have set the key in the context")
-	}
-
-	if (ctx.options.omitempty || options.omitempty) && isEmptyValue(v) {
-		return b, nil
-	}
-
 	if !ctx.inline {
 		b = enc.encodeComment(ctx.indent, options.comment, b)
 	}

 	b = enc.indent(ctx.indent, b)
-
-	b, err = enc.encodeKey(b, ctx.key)
-	if err != nil {
-		return nil, err
-	}
-
+	b = enc.encodeKey(b, ctx.key)
 	b = append(b, " = "...)

 	// create a copy of the context because the value of a KV shouldn't
@@ -338,6 +378,8 @@ func (enc *Encoder) encodeKv(b []byte, ctx encoderCtx, options valueOptions, v r

 func isEmptyValue(v reflect.Value) bool {
 	switch v.Kind() {
+	case reflect.Struct:
+		return isEmptyStruct(v)
 	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
 		return v.Len() == 0
 	case reflect.Bool:
@@ -354,6 +396,34 @@ func isEmptyValue(v reflect.Value) bool {
 	return false
 }

+func isEmptyStruct(v reflect.Value) bool {
+	// TODO: merge with walkStruct and cache.
+	typ := v.Type()
+	for i := 0; i < typ.NumField(); i++ {
+		fieldType := typ.Field(i)
+
+		// only consider exported fields
+		if fieldType.PkgPath != "" {
+			continue
+		}
+
+		tag := fieldType.Tag.Get("toml")
+
+		// special field name to skip field
+		if tag == "-" {
+			continue
+		}
+
+		f := v.Field(i)
+
+		if !isEmptyValue(f) {
+			return false
+		}
+	}
+
+	return true
+}
+
 const literalQuote = '\''

 func (enc *Encoder) encodeString(b []byte, v string, options valueOptions) []byte {
@@ -365,7 +435,13 @@ func (enc *Encoder) encodeString(b []byte, v string, options valueOptions) []byt
 }

 func needsQuoting(v string) bool {
-	return strings.ContainsAny(v, "'\b\f\n\r\t")
+	// TODO: vectorize
+	for _, b := range []byte(v) {
+		if b == '\'' || b == '\r' || b == '\n' || invalidAscii(b) {
+			return true
+		}
+	}
+	return false
 }

 // caller should have checked that the string does not contain new lines or ' .
@@ -377,7 +453,6 @@ func (enc *Encoder) encodeLiteralString(b []byte, v string) []byte {
 	return b
 }

-//nolint:cyclop
 func (enc *Encoder) encodeQuotedString(multiline bool, b []byte, v string) []byte {
 	stringQuote := `"`

@@ -437,7 +512,7 @@ func (enc *Encoder) encodeQuotedString(multiline bool, b []byte, v string) []byt
 	return b
 }

-// called should have checked that the string is in A-Z / a-z / 0-9 / - / _ .
+// caller should have checked that the string is in A-Z / a-z / 0-9 / - / _ .
 func (enc *Encoder) encodeUnquotedKey(b []byte, v string) []byte {
 	return append(b, v...)
 }
@@ -453,20 +528,11 @@ func (enc *Encoder) encodeTableHeader(ctx encoderCtx, b []byte) ([]byte, error)

 	b = append(b, '[')

-	var err error
-
-	b, err = enc.encodeKey(b, ctx.parentKey[0])
-	if err != nil {
-		return nil, err
-	}
+	b = enc.encodeKey(b, ctx.parentKey[0])

 	for _, k := range ctx.parentKey[1:] {
 		b = append(b, '.')
-
-		b, err = enc.encodeKey(b, k)
-		if err != nil {
-			return nil, err
-		}
+		b = enc.encodeKey(b, k)
 	}

 	b = append(b, "]\n"...)
@@ -475,19 +541,19 @@ func (enc *Encoder) encodeTableHeader(ctx encoderCtx, b []byte) ([]byte, error)
 }

 //nolint:cyclop
-func (enc *Encoder) encodeKey(b []byte, k string) ([]byte, error) {
+func (enc *Encoder) encodeKey(b []byte, k string) []byte {
 	needsQuotation := false
 	cannotUseLiteral := false

+	if len(k) == 0 {
+		return append(b, "''"...)
+	}
+
 	for _, c := range k {
 		if (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '-' || c == '_' {
 			continue
 		}

-		if c == '\n' {
-			return nil, fmt.Errorf("toml: new line characters in keys are not supported")
-		}
-
 		if c == literalQuote {
 			cannotUseLiteral = true
 		}
@@ -495,13 +561,17 @@ func (enc *Encoder) encodeKey(b []byte, k string) ([]byte, error) {
 		needsQuotation = true
 	}

+	if needsQuotation && needsQuoting(k) {
+		cannotUseLiteral = true
+	}
+
 	switch {
 	case cannotUseLiteral:
-		return enc.encodeQuotedString(false, b, k), nil
+		return enc.encodeQuotedString(false, b, k)
 	case needsQuotation:
-		return enc.encodeLiteralString(b, k), nil
+		return enc.encodeLiteralString(b, k)
 	default:
-		return enc.encodeUnquotedKey(b, k), nil
+		return enc.encodeUnquotedKey(b, k)
 	}
 }

@@ -555,16 +625,25 @@ type table struct {
 }

 func (t *table) pushKV(k string, v reflect.Value, options valueOptions) {
+	for _, e := range t.kvs {
+		if e.Key == k {
+			return
+		}
+	}
+
 	t.kvs = append(t.kvs, entry{Key: k, Value: v, Options: options})
 }

 func (t *table) pushTable(k string, v reflect.Value, options valueOptions) {
+	for _, e := range t.tables {
+		if e.Key == k {
+			return
+		}
+	}
 	t.tables = append(t.tables, entry{Key: k, Value: v, Options: options})
 }

-func (enc *Encoder) encodeStruct(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, error) {
-	var t table
-
+func walkStruct(ctx encoderCtx, t *table, v reflect.Value) {
 	// TODO: cache this
 	typ := v.Type()
 	for i := 0; i < typ.NumField(); i++ {
@@ -575,8 +654,6 @@ func (enc *Encoder) encodeStruct(b []byte, ctx encoderCtx, v reflect.Value) ([]b
 			continue
 		}

-		k := fieldType.Name
-
 		tag := fieldType.Tag.Get("toml")

 		// special field name to skip field
@@ -584,13 +661,24 @@ func (enc *Encoder) encodeStruct(b []byte, ctx encoderCtx, v reflect.Value) ([]b
 			continue
 		}

-		name, opts := parseTag(tag)
-		if isValidName(name) {
-			k = name
+		k, opts := parseTag(tag)
+		if !isValidName(k) {
+			k = ""
 		}

 		f := v.Field(i)

+		if k == "" {
+			if fieldType.Anonymous {
+				if fieldType.Type.Kind() == reflect.Struct {
+					walkStruct(ctx, t, f)
+				}
+				continue
+			} else {
+				k = fieldType.Name
+			}
+		}
+
 		if isNil(f) {
 			continue
 		}
@@ -607,15 +695,30 @@ func (enc *Encoder) encodeStruct(b []byte, ctx encoderCtx, v reflect.Value) ([]b
 			t.pushTable(k, f, options)
 		}
 	}
+}
+
+func (enc *Encoder) encodeStruct(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, error) {
+	var t table
+
+	walkStruct(ctx, &t, v)

 	return enc.encodeTable(b, ctx, t)
 }

 func (enc *Encoder) encodeComment(indent int, comment string, b []byte) []byte {
-	if comment != "" {
+	for len(comment) > 0 {
+		var line string
+		idx := strings.IndexByte(comment, '\n')
+		if idx >= 0 {
+			line = comment[:idx]
+			comment = comment[idx+1:]
+		} else {
+			line = comment
+			comment = ""
+		}
 		b = enc.indent(indent, b)
 		b = append(b, "# "...)
-		b = append(b, comment...)
+		b = append(b, line...)
 		b = append(b, '\n')
 	}
 	return b
@@ -696,7 +799,13 @@ func (enc *Encoder) encodeTable(b []byte, ctx encoderCtx, t table) ([]byte, erro
 	}
 	ctx.skipTableHeader = false

+	hasNonEmptyKV := false
 	for _, kv := range t.kvs {
+		if shouldOmitEmpty(kv.Options, kv.Value) {
+			continue
+		}
+		hasNonEmptyKV = true
+
 		ctx.setKey(kv.Key)

 		b, err = enc.encodeKv(b, ctx, kv.Options, kv.Value)
@@ -707,7 +816,20 @@ func (enc *Encoder) encodeTable(b []byte, ctx encoderCtx, t table) ([]byte, erro
 		b = append(b, '\n')
 	}

+	first := true
 	for _, table := range t.tables {
+		if shouldOmitEmpty(table.Options, table.Value) {
+			continue
+		}
+		if first {
+			first = false
+			if hasNonEmptyKV {
+				b = append(b, '\n')
+			}
+		} else {
+			b = append(b, "\n"...)
+		}
+
 		ctx.setKey(table.Key)

 		ctx.options = table.Options
@@ -716,8 +838,6 @@ func (enc *Encoder) encodeTable(b []byte, ctx encoderCtx, t table) ([]byte, erro
 		if err != nil {
 			return nil, err
 		}
-
-		b = append(b, '\n')
 	}

 	return b, nil
@@ -730,6 +850,10 @@ func (enc *Encoder) encodeTableInline(b []byte, ctx encoderCtx, t table) ([]byte

 	first := true
 	for _, kv := range t.kvs {
+		if shouldOmitEmpty(kv.Options, kv.Value) {
+			continue
+		}
+
 		if first {
 			first = false
 		} else {
@@ -745,7 +869,7 @@ func (enc *Encoder) encodeTableInline(b []byte, ctx encoderCtx, t table) ([]byte
 	}

 	if len(t.tables) > 0 {
-		panic("inline table cannot contain nested tables, online key-values")
+		panic("inline table cannot contain nested tables, only key-values")
 	}

 	b = append(b, "}"...)
@@ -779,6 +903,9 @@ func willConvertToTable(ctx encoderCtx, v reflect.Value) bool {
 }

 func willConvertToTableOrArrayTable(ctx encoderCtx, v reflect.Value) bool {
+	if ctx.insideKv {
+		return false
+	}
 	t := v.Type()

 	if t.Kind() == reflect.Interface {
@@ -824,7 +951,6 @@ func (enc *Encoder) encodeSlice(b []byte, ctx encoderCtx, v reflect.Value) ([]by
 func (enc *Encoder) encodeSliceAsArrayTable(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, error) {
 	ctx.shiftKey()

-	var err error
 	scratch := make([]byte, 0, 64)
 	scratch = append(scratch, "[["...)

@@ -833,18 +959,22 @@ func (enc *Encoder) encodeSliceAsArrayTable(b []byte, ctx encoderCtx, v reflect.
 			scratch = append(scratch, '.')
 		}

-		scratch, err = enc.encodeKey(scratch, k)
-		if err != nil {
-			return nil, err
-		}
+		scratch = enc.encodeKey(scratch, k)
 	}

 	scratch = append(scratch, "]]\n"...)
 	ctx.skipTableHeader = true

+	b = enc.encodeComment(ctx.indent, ctx.options.comment, b)
+
 	for i := 0; i < v.Len(); i++ {
+		if i != 0 {
+			b = append(b, "\n"...)
+		}
+
 		b = append(b, scratch...)

+		var err error
 		b, err = enc.encode(b, ctx, v.Index(i))
 		if err != nil {
 			return nil, err
@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"math"
 	"math/big"
 	"strings"
 	"testing"
@@ -38,21 +39,21 @@ func TestMarshal(t *testing.T) {
 			v: map[string]string{
 				"hello": "world",
 			},
-			expected: "hello = 'world'",
+			expected: "hello = 'world'\n",
 		},
 		{
 			desc: "map with new line in key",
 			v: map[string]string{
 				"hel\nlo": "world",
 			},
-			err: true,
+			expected: "\"hel\\nlo\" = 'world'\n",
 		},
 		{
 			desc: `map with " in key`,
 			v: map[string]string{
 				`hel"lo`: "world",
 			},
-			expected: `'hel"lo' = 'world'`,
+			expected: "'hel\"lo' = 'world'\n",
 		},
 		{
 			desc: "map in map and string",
@@ -61,9 +62,9 @@ func TestMarshal(t *testing.T) {
 					"hello": "world",
 				},
 			},
-			expected: `
-[table]
-hello = 'world'`,
+			expected: `[table]
+hello = 'world'
+`,
 		},
 		{
 			desc: "map in map in map and string",
@@ -74,10 +75,10 @@ hello = 'world'`,
 					},
 				},
 			},
-			expected: `
-[this]
+			expected: `[this]
 [this.is]
-a = 'test'`,
+a = 'test'
+`,
 		},
 		{
 			desc: "map in map in map and string with values",
@@ -89,18 +90,20 @@ a = 'test'`,
 					"also": "that",
 				},
 			},
-			expected: `
-[this]
+			expected: `[this]
 also = 'that'
+
 [this.is]
-a = 'test'`,
+a = 'test'
+`,
 		},
 		{
 			desc: "simple string array",
 			v: map[string][]string{
 				"array": {"one", "two", "three"},
 			},
-			expected: `array = ['one', 'two', 'three']`,
+			expected: `array = ['one', 'two', 'three']
+`,
 		},
 		{
 			desc:     "empty string array",
@@ -117,14 +120,16 @@ a = 'test'`,
 			v: map[string][][]string{
 				"array": {{"one", "two"}, {"three"}},
 			},
-			expected: `array = [['one', 'two'], ['three']]`,
+			expected: `array = [['one', 'two'], ['three']]
+`,
 		},
 		{
 			desc: "mixed strings and nested string arrays",
 			v: map[string][]interface{}{
 				"array": {"a string", []string{"one", "two"}, "last"},
 			},
-			expected: `array = ['a string', ['one', 'two'], 'last']`,
+			expected: `array = ['a string', ['one', 'two'], 'last']
+`,
 		},
 		{
 			desc: "array of maps",
@@ -134,9 +139,9 @@ a = 'test'`,
 					{"map2.1": "v2.1"},
 				},
 			},
-			expected: `
-[[top]]
+			expected: `[[top]]
 'map1.1' = 'v1.1'
+
 [[top]]
 'map2.1' = 'v2.1'
 `,
@@ -147,9 +152,9 @@ a = 'test'`,
 				"key1": "value1",
 				"key2": "value2",
 			},
-			expected: `
-key1 = 'value1'
-key2 = 'value2'`,
+			expected: `key1 = 'value1'
+key2 = 'value2'
+`,
 		},
 		{
 			desc: "simple struct",
@@ -158,7 +163,8 @@ key2 = 'value2'`,
 			}{
 				A: "foo",
 			},
-			expected: `A = 'foo'`,
+			expected: `A = 'foo'
+`,
 		},
 		{
 			desc: "one level of structs within structs",
@@ -173,8 +179,7 @@ key2 = 'value2'`,
 					K2: "v2",
 				},
 			},
-			expected: `
-[A]
+			expected: `[A]
 K1 = 'v1'
 K2 = 'v2'
 `,
@@ -189,10 +194,10 @@ K2 = 'v2'
 					},
 				},
 			},
-			expected: `
-[root]
+			expected: `[root]
 [[root.nested]]
 name = 'Bob'
+
 [[root.nested]]
 name = 'Alice'
 `,
@@ -202,49 +207,53 @@ name = 'Alice'
 			v: map[string]interface{}{
 				"a": "'\b\f\r\t\"\\",
 			},
-			expected: `a = "'\b\f\r\t\"\\"`,
+			expected: `a = "'\b\f\r\t\"\\"
+`,
 		},
 		{
 			desc: "string utf8 low",
 			v: map[string]interface{}{
 				"a": "'Ę",
 			},
-			expected: `a = "'Ę"`,
+			expected: `a = "'Ę"
+`,
 		},
 		{
 			desc: "string utf8 low 2",
 			v: map[string]interface{}{
 				"a": "'\u10A85",
 			},
-			expected: "a = \"'\u10A85\"",
+			expected: "a = \"'\u10A85\"\n",
 		},
 		{
 			desc: "string utf8 low 2",
 			v: map[string]interface{}{
 				"a": "'\u10A85",
 			},
-			expected: "a = \"'\u10A85\"",
+			expected: "a = \"'\u10A85\"\n",
 		},
 		{
 			desc: "emoji",
 			v: map[string]interface{}{
 				"a": "'😀",
 			},
-			expected: "a = \"'😀\"",
+			expected: "a = \"'😀\"\n",
 		},
 		{
 			desc: "control char",
 			v: map[string]interface{}{
 				"a": "'\u001A",
 			},
-			expected: `a = "'\u001A"`,
+			expected: `a = "'\u001A"
+`,
 		},
 		{
 			desc: "multi-line string",
 			v: map[string]interface{}{
 				"a": "hello\nworld",
 			},
-			expected: `a = "hello\nworld"`,
+			expected: `a = "hello\nworld"
+`,
 		},
 		{
 			desc: "multi-line forced",
@@ -255,7 +264,8 @@ name = 'Alice'
 			},
 			expected: `A = """
 hello
-world"""`,
+world"""
+`,
 		},
 		{
 			desc: "inline field",
@@ -270,8 +280,8 @@ world"""`,
 					"isinline": "no",
 				},
 			},
-			expected: `
-A = {isinline = 'yes'}
+			expected: `A = {isinline = 'yes'}
+
 [B]
 isinline = 'no'
 `,
@@ -285,8 +295,7 @@ isinline = 'no'
 				A: []int{1, 2, 3, 4},
 				B: []int{1, 2, 3, 4},
 			},
-			expected: `
-A = [
+			expected: `A = [
  1,
  2,
  3,
@@ -302,8 +311,7 @@ B = [1, 2, 3, 4]
 			}{
 				A: [][]int{{1, 2}, {3, 4}},
 			},
-			expected: `
-A = [
+			expected: `A = [
  [1, 2],
  [3, 4]
 ]
@@ -328,7 +336,8 @@ A = [
 			}{
 				A: []*int{nil},
 			},
-			expected: `A = [0]`,
+			expected: `A = [0]
+`,
 		},
 		{
 			desc: "nil pointer in slice uses zero value",
@@ -337,7 +346,8 @@ A = [
 			}{
 				A: []*int{nil},
 			},
-			expected: `A = [0]`,
+			expected: `A = [0]
+`,
 		},
 		{
 			desc: "pointer in slice",
@@ -346,7 +356,8 @@ A = [
 			}{
 				A: []*int{&someInt},
 			},
-			expected: `A = [42]`,
+			expected: `A = [42]
+`,
 		},
 		{
 			desc: "inline table in inline table",
@@ -357,30 +368,34 @@ A = [
 					},
 				},
 			},
-			expected: `A = {A = {A = 'hello'}}`,
+			expected: `A = {A = {A = 'hello'}}
+`,
 		},
 		{
 			desc: "empty slice in map",
 			v: map[string][]string{
 				"a": {},
 			},
-			expected: `a = []`,
+			expected: `a = []
+`,
 		},
 		{
 			desc: "map in slice",
 			v: map[string][]map[string]string{
 				"a": {{"hello": "world"}},
 			},
-			expected: `
-[[a]]
-hello = 'world'`,
+			expected: `[[a]]
+hello = 'world'
+`,
 		},
 		{
 			desc: "newline in map in slice",
 			v: map[string][]map[string]string{
 				"a\n": {{"hello": "world"}},
 			},
-			err: true,
+			expected: `[["a\n"]]
+hello = 'world'
+`,
 		},
 		{
 			desc: "newline in map in slice",
@@ -396,7 +411,8 @@ hello = 'world'`,
 			}{
 				A: []struct{}{},
 			},
-			expected: `A = []`,
+			expected: `A = []
+`,
 		},
 		{
 			desc: "nil field is ignored",
@@ -416,7 +432,8 @@ hello = 'world'`,
 				Public:  "shown",
 				private: "hidden",
 			},
-			expected: `Public = 'shown'`,
+			expected: `Public = 'shown'
+`,
 		},
 		{
 			desc: "fields tagged - are ignored",
@@ -440,7 +457,8 @@ hello = 'world'`,
 			v: map[string]interface{}{
 				"hello\nworld": 42,
 			},
-			err: true,
+			expected: `"hello\nworld" = 42
+`,
 		},
 		{
 			desc: "new line in parent of nested table key",
@@ -449,7 +467,9 @@ hello = 'world'`,
 					"inner": 42,
 				},
 			},
-			err: true,
+			expected: `["hello\nworld"]
+inner = 42
+`,
 		},
 		{
 			desc: "new line in nested table key",
@@ -460,7 +480,10 @@ hello = 'world'`,
 					},
 				},
 			},
-			err: true,
+			expected: `[parent]
+[parent."in\ner"]
+foo = 42
+`,
 		},
 		{
 			desc: "invalid map key",
@@ -483,7 +506,18 @@ hello = 'world'`,
 			}{
 				T: time.Time{},
 			},
-			expected: `T = '0001-01-01T00:00:00Z'`,
+			expected: `T = 0001-01-01T00:00:00Z
+`,
+		},
+		{
+			desc: "time nano",
+			v: struct {
+				T time.Time
+			}{
+				T: time.Date(1979, time.May, 27, 0, 32, 0, 999999000, time.UTC),
+			},
+			expected: `T = 1979-05-27T00:32:00.999999Z
+`,
 		},
 		{
 			desc: "bool",
@@ -494,9 +528,9 @@ hello = 'world'`,
 				A: false,
 				B: true,
 			},
-			expected: `
-A = false
-B = true`,
+			expected: `A = false
+B = true
+`,
 		},
 		{
 			desc: "numbers",
@@ -527,8 +561,7 @@ B = true`,
 				K: 42,
 				L: 2.2,
 			},
-			expected: `
-A = 1.1
+			expected: `A = 1.1
 B = 42
 C = 42
 D = 42
@@ -539,7 +572,8 @@ H = 42
 I = 42
 J = 42
 K = 42
-L = 2.2`,
+L = 2.2
+`,
 		},
 		{
 			desc: "comments",
@@ -552,8 +586,7 @@ L = 2.2`,
 					Three: []int{1, 2, 3},
 				},
 			},
-			expected: `
-# Before table
+			expected: `# Before table
 [Table]
 One = 1
 # Before kv
@@ -575,7 +608,7 @@ Three = [1, 2, 3]
 			}

 			require.NoError(t, err)
-			equalStringsIgnoreNewlines(t, e.expected, string(b))
+			assert.Equal(t, e.expected, string(b))

 			// make sure the output is always valid TOML
 			defaultMap := map[string]interface{}{}
@@ -650,10 +683,31 @@ func testWithFlags(t *testing.T, flags int, setters flagsSetters, testfn func(t
 	}
 }

-func equalStringsIgnoreNewlines(t *testing.T, expected string, actual string) {
-	t.Helper()
-	cutset := "\n"
-	assert.Equal(t, strings.Trim(expected, cutset), strings.Trim(actual, cutset))
+func TestMarshalFloats(t *testing.T) {
+	v := map[string]float32{
+		"nan":  float32(math.NaN()),
+		"+inf": float32(math.Inf(1)),
+		"-inf": float32(math.Inf(-1)),
+	}
+
+	expected := `'+inf' = inf
+-inf = -inf
+nan = nan
+`
+
+	actual, err := toml.Marshal(v)
+	require.NoError(t, err)
+	require.Equal(t, expected, string(actual))
+
+	v64 := map[string]float64{
+		"nan":  math.NaN(),
+		"+inf": math.Inf(1),
+		"-inf": math.Inf(-1),
+	}
+
+	actual, err = toml.Marshal(v64)
+	require.NoError(t, err)
+	require.Equal(t, expected, string(actual))
 }

 //nolint:funlen
@@ -668,7 +722,8 @@ func TestMarshalIndentTables(t *testing.T) {
 			v: map[string]interface{}{
 				"foo": "bar",
 			},
-			expected: `foo = 'bar'`,
+			expected: `foo = 'bar'
+`,
 		},
 		{
 			desc: "one level table",
@@ -678,8 +733,7 @@ func TestMarshalIndentTables(t *testing.T) {
 					"two": "value2",
 				},
 			},
-			expected: `
-[foo]
+			expected: `[foo]
  one = 'value1'
  two = 'value2'
 `,
@@ -695,10 +749,11 @@ func TestMarshalIndentTables(t *testing.T) {
 					},
 				},
 			},
-			expected: `
-root = 'value0'
+			expected: `root = 'value0'
+
 [level1]
  one = 'value1'
+
  [level1.level2]
    two = 'value2'
 `,
@@ -713,7 +768,7 @@ root = 'value0'
 			enc.SetIndentTables(true)
 			err := enc.Encode(e.v)
 			require.NoError(t, err)
-			equalStringsIgnoreNewlines(t, e.expected, buf.String())
+			assert.Equal(t, e.expected, buf.String())
 		})
 	}
 }
@@ -758,7 +813,7 @@ func TestMarshalTextMarshaler(t *testing.T) {
 	m := map[string]interface{}{"a": &customTextMarshaler{value: 2}}
 	r, err := toml.Marshal(m)
 	require.NoError(t, err)
-	equalStringsIgnoreNewlines(t, "a = '::2'", string(r))
+	assert.Equal(t, "a = '::2'\n", string(r))
 }

 type brokenWriter struct{}
@@ -781,10 +836,10 @@ func TestEncoderSetIndentSymbol(t *testing.T) {
 	enc.SetIndentSymbol(">>>")
 	err := enc.Encode(map[string]map[string]string{"parent": {"hello": "world"}})
 	require.NoError(t, err)
-	expected := `
-[parent]
->>>hello = 'world'`
-	equalStringsIgnoreNewlines(t, expected, w.String())
+	expected := `[parent]
+>>>hello = 'world'
+`
+	assert.Equal(t, expected, w.String())
 }

 func TestEncoderOmitempty(t *testing.T) {
@@ -815,9 +870,9 @@ func TestEncoderOmitempty(t *testing.T) {
 	b, err := toml.Marshal(d)
 	require.NoError(t, err)

-	expected := `[Struct]`
+	expected := ``

-	equalStringsIgnoreNewlines(t, expected, string(b))
+	assert.Equal(t, expected, string(b))
 }

 func TestEncoderTagFieldName(t *testing.T) {
@@ -832,13 +887,12 @@ func TestEncoderTagFieldName(t *testing.T) {
 	b, err := toml.Marshal(d)
 	require.NoError(t, err)

-	expected := `
-hello = 'world'
+	expected := `hello = 'world'
 '#' = ''
 Bad = ''
 `

-	equalStringsIgnoreNewlines(t, expected, string(b))
+	assert.Equal(t, expected, string(b))
 }

 func TestIssue436(t *testing.T) {
@@ -852,12 +906,11 @@ func TestIssue436(t *testing.T) {
 	err = toml.NewEncoder(&buf).Encode(v)
 	require.NoError(t, err)

-	expected := `
-[[a]]
+	expected := `[[a]]
 [a.b]
 c = 'd'
 `
-	equalStringsIgnoreNewlines(t, expected, buf.String())
+	assert.Equal(t, expected, buf.String())
 }

 func TestIssue424(t *testing.T) {
@@ -939,7 +992,7 @@ func TestIssue678(t *testing.T) {

 	out, err := toml.Marshal(cfg)
 	require.NoError(t, err)
-	equalStringsIgnoreNewlines(t, "BigInt = '123'", string(out))
+	assert.Equal(t, "BigInt = '123'\n", string(out))

 	cfg2 := &Config{}
 	err = toml.Unmarshal(out, cfg2)
@@ -947,6 +1000,196 @@ func TestIssue678(t *testing.T) {
 	require.Equal(t, cfg, cfg2)
 }

+func TestIssue752(t *testing.T) {
+	type Fooer interface {
+		Foo() string
+	}
+
+	type Container struct {
+		Fooer
+	}
+
+	c := Container{}
+
+	out, err := toml.Marshal(c)
+	require.NoError(t, err)
+	require.Equal(t, "", string(out))
+}
+
+func TestIssue768(t *testing.T) {
+	type cfg struct {
+		Name string `comment:"This is a multiline comment.\nThis is line 2."`
+	}
+
+	out, err := toml.Marshal(&cfg{})
+	require.NoError(t, err)
+
+	expected := `# This is a multiline comment.
+# This is line 2.
+Name = ''
+`
+
+	require.Equal(t, expected, string(out))
+}
+
+func TestIssue786(t *testing.T) {
+	type Dependencies struct {
+		Dependencies         []string `toml:"dependencies,multiline,omitempty"`
+		BuildDependencies    []string `toml:"buildDependencies,multiline,omitempty"`
+		OptionalDependencies []string `toml:"optionalDependencies,multiline,omitempty"`
+	}
+
+	type Test struct {
+		Dependencies Dependencies `toml:"dependencies,omitempty"`
+	}
+
+	x := Test{}
+	b, err := toml.Marshal(x)
+	require.NoError(t, err)
+
+	require.Equal(t, "", string(b))
+
+	type General struct {
+		From      string `toml:"from,omitempty" json:"from,omitempty" comment:"from in graphite-web format, the local TZ is used"`
+		Randomize bool   `toml:"randomize" json:"randomize" comment:"randomize starting time with [0,step)"`
+	}
+
+	type Custom struct {
+		Name string `toml:"name" json:"name,omitempty" comment:"names for generator, braces are expanded like in shell"`
+		Type string `toml:"type,omitempty" json:"type,omitempty" comment:"type of generator"`
+		General
+	}
+	type Config struct {
+		General
+		Custom []Custom `toml:"custom,omitempty" json:"custom,omitempty" comment:"generators with custom parameters can be specified separately"`
+	}
+
+	buf := new(bytes.Buffer)
+	config := &Config{General: General{From: "-2d", Randomize: true}}
+	config.Custom = []Custom{{Name: "omit", General: General{Randomize: false}}}
+	config.Custom = append(config.Custom, Custom{Name: "present", General: General{From: "-2d", Randomize: true}})
+	encoder := toml.NewEncoder(buf)
+	encoder.Encode(config)
+
+	expected := `# from in graphite-web format, the local TZ is used
+from = '-2d'
+# randomize starting time with [0,step)
+randomize = true
+
+# generators with custom parameters can be specified separately
+[[custom]]
+# names for generator, braces are expanded like in shell
+name = 'omit'
+# randomize starting time with [0,step)
+randomize = false
+
+[[custom]]
+# names for generator, braces are expanded like in shell
+name = 'present'
+# from in graphite-web format, the local TZ is used
+from = '-2d'
+# randomize starting time with [0,step)
+randomize = true
+`
+
+	require.Equal(t, expected, buf.String())
+}
+
+func TestMarshalNestedAnonymousStructs(t *testing.T) {
+	type Embedded struct {
+		Value string `toml:"value" json:"value"`
+		Top   struct {
+			Value string `toml:"value" json:"value"`
+		} `toml:"top" json:"top"`
+	}
+
+	type Named struct {
+		Value string `toml:"value" json:"value"`
+	}
+
+	var doc struct {
+		Embedded
+		Named     `toml:"named" json:"named"`
+		Anonymous struct {
+			Value string `toml:"value" json:"value"`
+		} `toml:"anonymous" json:"anonymous"`
+	}
+
+	expected := `value = ''
+
+[top]
+value = ''
+
+[named]
+value = ''
+
+[anonymous]
+value = ''
+`
+
+	result, err := toml.Marshal(doc)
+	require.NoError(t, err)
+	require.Equal(t, expected, string(result))
+}
+
+func TestMarshalNestedAnonymousStructs_DuplicateField(t *testing.T) {
+	type Embedded struct {
+		Value string `toml:"value" json:"value"`
+		Top   struct {
+			Value string `toml:"value" json:"value"`
+		} `toml:"top" json:"top"`
+	}
+
+	var doc struct {
+		Value string `toml:"value" json:"value"`
+		Embedded
+	}
+	doc.Embedded.Value = "shadowed"
+	doc.Value = "shadows"
+
+	expected := `value = 'shadows'
+
+[top]
+value = ''
+`
+
+	result, err := toml.Marshal(doc)
+	require.NoError(t, err)
+	require.NoError(t, err)
+	require.Equal(t, expected, string(result))
+}
+
+func TestLocalTime(t *testing.T) {
+	v := map[string]toml.LocalTime{
+		"a": {
+			Hour:       1,
+			Minute:     2,
+			Second:     3,
+			Nanosecond: 4,
+		},
+	}
+
+	expected := `a = 01:02:03.000000004
+`
+
+	out, err := toml.Marshal(v)
+	require.NoError(t, err)
+	require.Equal(t, expected, string(out))
+}
+
+func TestMarshalUint64Overflow(t *testing.T) {
+	// The TOML spec only requires implementation to provide support for the
+	// int64 range. To avoid generating TOML documents that would not be
+	// supported by standard-compliant parsers, uint64 > max int64 cannot be
+	// marshaled.
+	x := map[string]interface{}{
+		"foo": uint64(math.MaxInt64) + 1,
+	}
+
+	_, err := toml.Marshal(x)
+	require.Error(t, err)
+}
+
 func ExampleMarshal() {
 	type MyConfig struct {
 		Version int
@@ -617,6 +617,8 @@ func (p *parser) parseMultilineBasicString(b []byte) ([]byte, []byte, []byte, er
 				builder.WriteByte('\r')
 			case 't':
 				builder.WriteByte('\t')
+			case 'e':
+				builder.WriteByte(0x1B)
 			case 'u':
 				x, err := hexToRune(atmost(token[i+1:], 4), 4)
 				if err != nil {
@@ -774,6 +776,8 @@ func (p *parser) parseBasicString(b []byte) ([]byte, []byte, []byte, error) {
 				builder.WriteByte('\r')
 			case 't':
 				builder.WriteByte('\t')
+			case 'e':
+				builder.WriteByte(0x1B)
 			case 'u':
 				x, err := hexToRune(token[i+1:len(token)-1], 4)
 				if err != nil {
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0=0000-01-01 00:00:00")
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("\"\\n\"=\"\"")
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("''=0")
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0=0000-01-01")
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0=\"\"\"\\U00000000\"\"\"")
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0=[[{}]]")
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("\"\\b\"=\"\"")
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0=inf")
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0=0000-01-01 00:00:00+00:00")
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0=[{}]")
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0=nan")
@@ -8,7 +8,7 @@ import (
 	"testing"

 	"github.com/pelletier/go-toml/v2"
-	"github.com/pelletier/go-toml/v2/testsuite"
+	"github.com/pelletier/go-toml/v2/internal/testsuite"
 	"github.com/stretchr/testify/require"
 )

@@ -1,4 +1,4 @@
-// Generated by tomltestgen for toml-test ref master on 2021-11-08T22:33:24-05:00
+// Generated by tomltestgen for toml-test ref master on 2022-04-07T20:09:42-04:00
 package toml_test

 import (
@@ -55,11 +55,51 @@ func TestTOMLTest_Invalid_Array_TextInArray(t *testing.T) {
 	testgenInvalid(t, input)
 }

+func TestTOMLTest_Invalid_Bool_AlmostFalseWithExtra(t *testing.T) {
+	input := "a = falsify\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Bool_AlmostFalse(t *testing.T) {
+	input := "a = fals\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Bool_AlmostTrueWithExtra(t *testing.T) {
+	input := "a = truthy\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Bool_AlmostTrue(t *testing.T) {
+	input := "a = tru\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Bool_JustF(t *testing.T) {
+	input := "a = f\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Bool_JustT(t *testing.T) {
+	input := "a = t\n"
+	testgenInvalid(t, input)
+}
+
 func TestTOMLTest_Invalid_Bool_MixedCase(t *testing.T) {
 	input := "valid = False\n"
 	testgenInvalid(t, input)
 }

+func TestTOMLTest_Invalid_Bool_StartingSameFalse(t *testing.T) {
+	input := "a = falsey\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Bool_StartingSameTrue(t *testing.T) {
+	input := "a = truer\n"
+	testgenInvalid(t, input)
+}
+
 func TestTOMLTest_Invalid_Bool_WrongCaseFalse(t *testing.T) {
 	input := "b = FALSE\n"
 	testgenInvalid(t, input)
@@ -70,6 +110,31 @@ func TestTOMLTest_Invalid_Bool_WrongCaseTrue(t *testing.T) {
 	testgenInvalid(t, input)
 }

+func TestTOMLTest_Invalid_Control_BareCr(t *testing.T) {
+	input := "# The following line contains a single carriage return control character\r\n\r"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Control_BareFormfeed(t *testing.T) {
+	input := "bare-formfeed = \f\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Control_BareNull(t *testing.T) {
+	input := "bare-null = \"some value\" \x00\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Control_BareVerticalTab(t *testing.T) {
+	input := "bare-vertical-tab = \v\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Control_CommentCr(t *testing.T) {
+	input := "comment-cr = \"Carriage return in comment\" # \ra=1\n"
+	testgenInvalid(t, input)
+}
+
 func TestTOMLTest_Invalid_Control_CommentDel(t *testing.T) {
 	input := "comment-del = \"0x7f\" # \u007f\n"
 	testgenInvalid(t, input)
@@ -175,33 +240,73 @@ func TestTOMLTest_Invalid_Control_StringUs(t *testing.T) {
 	testgenInvalid(t, input)
 }

-func TestTOMLTest_Invalid_Datetime_ImpossibleDate(t *testing.T) {
-	input := "d = 2006-01-50T00:00:00Z\n"
+func TestTOMLTest_Invalid_Datetime_HourOver(t *testing.T) {
+	input := "# time-hour       = 2DIGIT  ; 00-23\nd = 2006-01-01T24:00:00-00:00\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Datetime_MdayOver(t *testing.T) {
+	input := "# date-mday       = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31 based on\n#                           ; month/year\nd = 2006-01-32T00:00:00-00:00\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Datetime_MdayUnder(t *testing.T) {
+	input := "# date-mday       = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31 based on\n#                           ; month/year\nd = 2006-01-00T00:00:00-00:00\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Datetime_MinuteOver(t *testing.T) {
+	input := "# time-minute     = 2DIGIT  ; 00-59\nd = 2006-01-01T00:60:00-00:00\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Datetime_MonthOver(t *testing.T) {
+	input := "# date-month      = 2DIGIT  ; 01-12\nd = 2006-13-01T00:00:00-00:00\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Datetime_MonthUnder(t *testing.T) {
+	input := "# date-month      = 2DIGIT  ; 01-12\nd = 2007-00-01T00:00:00-00:00\n"
 	testgenInvalid(t, input)
 }

 func TestTOMLTest_Invalid_Datetime_NoLeadsWithMilli(t *testing.T) {
-	input := "with-milli = 1987-07-5T17:45:00.12Z\n"
+	input := "# Day \"5\" instead of \"05\"; the leading zero is required.\nwith-milli = 1987-07-5T17:45:00.12Z\n"
 	testgenInvalid(t, input)
 }

 func TestTOMLTest_Invalid_Datetime_NoLeads(t *testing.T) {
-	input := "no-leads = 1987-7-05T17:45:00Z\n"
+	input := "# Month \"7\" instead of \"07\"; the leading zero is required.\nno-leads = 1987-7-05T17:45:00Z\n"
 	testgenInvalid(t, input)
 }

 func TestTOMLTest_Invalid_Datetime_NoSecs(t *testing.T) {
-	input := "no-secs = 1987-07-05T17:45Z\n"
+	input := "# No seconds in time.\nno-secs = 1987-07-05T17:45Z\n"
 	testgenInvalid(t, input)
 }

 func TestTOMLTest_Invalid_Datetime_NoT(t *testing.T) {
-	input := "no-t = 1987-07-0517:45:00Z\n"
+	input := "# No \"t\" or \"T\" between the date and time.\nno-t = 1987-07-0517:45:00Z\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Datetime_SecondOver(t *testing.T) {
+	input := "# time-second     = 2DIGIT  ; 00-58, 00-59, 00-60 based on leap second\n#                           ; rules\nd = 2006-01-01T00:00:61-00:00\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Datetime_TimeNoLeads2(t *testing.T) {
+	input := "# Leading 0 is always required.\nd = 01:32:0\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Datetime_TimeNoLeads(t *testing.T) {
+	input := "# Leading 0 is always required.\nd = 1:32:00\n"
 	testgenInvalid(t, input)
 }

 func TestTOMLTest_Invalid_Datetime_TrailingT(t *testing.T) {
-	input := "d = 2006-01-30T\n"
+	input := "# Date cannot end with trailing T\nd = 2006-01-30T\n"
 	testgenInvalid(t, input)
 }

@@ -395,6 +500,11 @@ func TestTOMLTest_Invalid_Float_UsBeforePoint(t *testing.T) {
 	testgenInvalid(t, input)
 }

+func TestTOMLTest_Invalid_InlineTable_Add(t *testing.T) {
+	input := "a={}\n# Inline tables are immutable and can't be extended\n[a.b]\n"
+	testgenInvalid(t, input)
+}
+
 func TestTOMLTest_Invalid_InlineTable_DoubleComma(t *testing.T) {
 	input := "t = {x=3,,y=4}\n"
 	testgenInvalid(t, input)
@@ -435,6 +545,11 @@ func TestTOMLTest_Invalid_InlineTable_NoComma(t *testing.T) {
 	testgenInvalid(t, input)
 }

+func TestTOMLTest_Invalid_InlineTable_Overwrite(t *testing.T) {
+	input := "a.b=0\n# Since table \"a\" is already defined, it can't be replaced by an inline table.\na={}\n"
+	testgenInvalid(t, input)
+}
+
 func TestTOMLTest_Invalid_InlineTable_TrailingComma(t *testing.T) {
 	input := "# A terminating comma (also called trailing comma) is not permitted after the\n# last key/value pair in an inline table\nabc = { abc = 123, }\n"
 	testgenInvalid(t, input)
@@ -470,6 +585,21 @@ func TestTOMLTest_Invalid_Integer_DoubleUs(t *testing.T) {
 	testgenInvalid(t, input)
 }

+func TestTOMLTest_Invalid_Integer_IncompleteBin(t *testing.T) {
+	input := "incomplete-bin = 0b\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Integer_IncompleteHex(t *testing.T) {
+	input := "incomplete-hex = 0x\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Integer_IncompleteOct(t *testing.T) {
+	input := "incomplete-oct = 0o\n"
+	testgenInvalid(t, input)
+}
+
 func TestTOMLTest_Invalid_Integer_InvalidBin(t *testing.T) {
 	input := "invalid-bin = 0b0012\n"
 	testgenInvalid(t, input)
@@ -515,6 +645,11 @@ func TestTOMLTest_Invalid_Integer_LeadingZero2(t *testing.T) {
 	testgenInvalid(t, input)
 }

+func TestTOMLTest_Invalid_Integer_LeadingZero3(t *testing.T) {
+	input := "leading-zero-3 = 0_0\n"
+	testgenInvalid(t, input)
+}
+
 func TestTOMLTest_Invalid_Integer_LeadingZeroSign1(t *testing.T) {
 	input := "leading-zero-sign-1 = -01\n"
 	testgenInvalid(t, input)
@@ -525,6 +660,11 @@ func TestTOMLTest_Invalid_Integer_LeadingZeroSign2(t *testing.T) {
 	testgenInvalid(t, input)
 }

+func TestTOMLTest_Invalid_Integer_LeadingZeroSign3(t *testing.T) {
+	input := "leading-zero-sign-3 = +0_1\n"
+	testgenInvalid(t, input)
+}
+
 func TestTOMLTest_Invalid_Integer_NegativeBin(t *testing.T) {
 	input := "negative-bin = -0b11010110\n"
 	testgenInvalid(t, input)
@@ -730,11 +870,16 @@ func TestTOMLTest_Invalid_String_BadConcat(t *testing.T) {
 	testgenInvalid(t, input)
 }

-func TestTOMLTest_Invalid_String_BadEscape(t *testing.T) {
+func TestTOMLTest_Invalid_String_BadEscape1(t *testing.T) {
 	input := "invalid-escape = \"This string has a bad \\a escape character.\"\n"
 	testgenInvalid(t, input)
 }

+func TestTOMLTest_Invalid_String_BadEscape2(t *testing.T) {
+	input := "invalid-escape = \"This string has a bad \\  escape character.\"\n\n"
+	testgenInvalid(t, input)
+}
+
 func TestTOMLTest_Invalid_String_BadMultiline(t *testing.T) {
 	input := "multi = \"first line\nsecond line\"\n"
 	testgenInvalid(t, input)
@@ -805,6 +950,21 @@ func TestTOMLTest_Invalid_String_MissingQuotes(t *testing.T) {
 	testgenInvalid(t, input)
 }

+func TestTOMLTest_Invalid_String_MultilineBadEscape1(t *testing.T) {
+	input := "k = \"\"\"t\\a\"\"\"\n\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_String_MultilineBadEscape2(t *testing.T) {
+	input := "# \\<Space> is not a valid escape.\nk = \"\"\"t\\ t\"\"\"\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_String_MultilineBadEscape3(t *testing.T) {
+	input := "# \\<Space> is not a valid escape.\nk = \"\"\"t\\ \"\"\"\n\n"
+	testgenInvalid(t, input)
+}
+
 func TestTOMLTest_Invalid_String_MultilineEscapeSpace(t *testing.T) {
 	input := "a = \"\"\"\n  foo \\ \\n\n  bar\"\"\"\n"
 	testgenInvalid(t, input)
@@ -825,11 +985,6 @@ func TestTOMLTest_Invalid_String_MultilineQuotes1(t *testing.T) {
 	testgenInvalid(t, input)
 }

-func TestTOMLTest_Invalid_String_MultilineQuotes2(t *testing.T) {
-	input := "a = \"\"\"6 quotes: \"\"\"\"\"\"\n"
-	testgenInvalid(t, input)
-}
-
 func TestTOMLTest_Invalid_String_NoClose(t *testing.T) {
 	input := "no-ending-quote = \"One time, at band camp\n"
 	testgenInvalid(t, input)
@@ -845,6 +1000,16 @@ func TestTOMLTest_Invalid_String_WrongClose(t *testing.T) {
 	testgenInvalid(t, input)
 }

+func TestTOMLTest_Invalid_Table_AppendWithDottedKeys1(t *testing.T) {
+	input := "# First a.b.c defines a table: a.b.c = {z=9}\n#\n# Then we define a.b.c.t = \"str\" to add a str to the above table, making it:\n#\n#   a.b.c = {z=9, t=\"...\"}\n#\n# While this makes sense, logically, it was decided this is not valid TOML as\n# it's too confusing/convoluted.\n# \n# See: https://github.com/toml-lang/toml/issues/846\n#      https://github.com/toml-lang/toml/pull/859\n\n[a.b.c]\n  z = 9\n\n[a]\n  b.c.t = \"Using dotted keys to add to [a.b.c] after explicitly defining it above is not allowed\"\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Table_AppendWithDottedKeys2(t *testing.T) {
+	input := "# This is the same issue as in injection-1.toml, except that nests one level\n# deeper. See that file for a more complete description.\n\n[a.b.c.d]\n  z = 9\n\n[a]\n  b.c.d.k.t = \"Using dotted keys to add to [a.b.c.d] after explicitly defining it above is not allowed\"\n"
+	testgenInvalid(t, input)
+}
+
 func TestTOMLTest_Invalid_Table_ArrayEmpty(t *testing.T) {
 	input := "[[]]\nname = \"Born to Run\"\n"
 	testgenInvalid(t, input)
@@ -860,6 +1025,16 @@ func TestTOMLTest_Invalid_Table_ArrayMissingBracket(t *testing.T) {
 	testgenInvalid(t, input)
 }

+func TestTOMLTest_Invalid_Table_DuplicateKeyDottedTable(t *testing.T) {
+	input := "[fruit]\napple.color = \"red\"\n\n[fruit.apple] # INVALID\n"
+	testgenInvalid(t, input)
+}
+
+func TestTOMLTest_Invalid_Table_DuplicateKeyDottedTable2(t *testing.T) {
+	input := "[fruit]\napple.taste.sweet = true\n\n[fruit.apple.taste] # INVALID\n"
+	testgenInvalid(t, input)
+}
+
 func TestTOMLTest_Invalid_Table_DuplicateKeyTable(t *testing.T) {
 	input := "[fruit]\ntype = \"apple\"\n\n[fruit.type]\napple = \"yes\"\n"
 	testgenInvalid(t, input)
@@ -895,16 +1070,6 @@ func TestTOMLTest_Invalid_Table_EqualsSign(t *testing.T) {
 	testgenInvalid(t, input)
 }

-func TestTOMLTest_Invalid_Table_Injection1(t *testing.T) {
-	input := "[a.b.c]\n  z = 9\n[a]\n  b.c.t = \"Using dotted keys to add to [a.b.c] after explicitly defining it above is not allowed\"\n  \n# see https://github.com/toml-lang/toml/issues/846\n"
-	testgenInvalid(t, input)
-}
-
-func TestTOMLTest_Invalid_Table_Injection2(t *testing.T) {
-	input := "[a.b.c.d]\n  z = 9\n[a]\n  b.c.d.k.t = \"Using dotted keys to add to [a.b.c.d] after explicitly defining it above is not allowed\"\n  \n# see https://github.com/toml-lang/toml/issues/846\n"
-	testgenInvalid(t, input)
-}
-
 func TestTOMLTest_Invalid_Table_Llbrace(t *testing.T) {
 	input := "[ [table]]\n"
 	testgenInvalid(t, input)
@@ -1071,8 +1236,14 @@ func TestTOMLTest_Valid_Comment_AtEof2(t *testing.T) {
 }

 func TestTOMLTest_Valid_Comment_Everywhere(t *testing.T) {
-	input := "# Top comment.\n  # Top comment.\n# Top comment.\n\n# [no-extraneous-groups-please]\n\n[group] # Comment\nanswer = 42 # Comment\n# no-extraneous-keys-please = 999\n# Inbetween comment.\nmore = [ # Comment\n  # What about multiple # comments?\n  # Can you handle it?\n  #\n          # Evil.\n# Evil.\n  42, 42, # Comments within arrays are fun.\n  # What about multiple # comments?\n  # Can you handle it?\n  #\n          # Evil.\n# Evil.\n# ] Did I fool you?\n] # Hopefully not.\n\n# Make sure the space between the datetime and \"#\" isn't lexed.\nd = 1979-05-27T07:32:12-07:00  # c\n"
-	jsonRef := "{\n  \"group\": {\n    \"answer\": {\n      \"type\": \"integer\",\n      \"value\": \"42\"\n    },\n    \"d\": {\n      \"type\": \"datetime\",\n      \"value\": \"1979-05-27T07:32:12-07:00\"\n    },\n    \"more\": [\n      {\n        \"type\": \"integer\",\n        \"value\": \"42\"\n      },\n      {\n        \"type\": \"integer\",\n        \"value\": \"42\"\n      }\n    ]\n  }\n}\n"
+	input := "# Top comment.\n  # Top comment.\n# Top comment.\n\n# [no-extraneous-groups-please]\n\n[group] # Comment\nanswer = 42 # Comment\n# no-extraneous-keys-please = 999\n# Inbetween comment.\nmore = [ # Comment\n  # What about multiple # comments?\n  # Can you handle it?\n  #\n          # Evil.\n# Evil.\n  42, 42, # Comments within arrays are fun.\n  # What about multiple # comments?\n  # Can you handle it?\n  #\n          # Evil.\n# Evil.\n# ] Did I fool you?\n] # Hopefully not.\n\n# Make sure the space between the datetime and \"#\" isn't lexed.\ndt = 1979-05-27T07:32:12-07:00  # c\nd = 1979-05-27 # Comment\n"
+	jsonRef := "{\n  \"group\": {\n    \"answer\": {\n      \"type\": \"integer\",\n      \"value\": \"42\"\n    },\n    \"dt\": {\n      \"type\": \"datetime\",\n      \"value\": \"1979-05-27T07:32:12-07:00\"\n    },\n    \"d\": {\n      \"type\": \"date-local\",\n      \"value\": \"1979-05-27\"\n    },\n    \"more\": [\n      {\n        \"type\": \"integer\",\n        \"value\": \"42\"\n      },\n      {\n        \"type\": \"integer\",\n        \"value\": \"42\"\n      }\n    ]\n  }\n}\n"
+	testgenValid(t, input, jsonRef)
+}
+
+func TestTOMLTest_Valid_Comment_Noeol(t *testing.T) {
+	input := "# single comment without any eol characters"
+	jsonRef := "{}\n"
 	testgenValid(t, input, jsonRef)
 }

@@ -1107,8 +1278,8 @@ func TestTOMLTest_Valid_Datetime_Local(t *testing.T) {
 }

 func TestTOMLTest_Valid_Datetime_Milliseconds(t *testing.T) {
-	input := "utc1  = 1987-07-05T17:45:56.123456Z\nutc2  = 1987-07-05T17:45:56.6Z\nwita1 = 1987-07-05T17:45:56.123456+08:00\nwita2 = 1987-07-05T17:45:56.6+08:00\n"
-	jsonRef := "{\n  \"utc1\": {\n    \"type\": \"datetime\",\n    \"value\": \"1987-07-05T17:45:56.123456Z\"\n  },\n  \"utc2\": {\n    \"type\": \"datetime\",\n    \"value\": \"1987-07-05T17:45:56.600000Z\"\n  },\n  \"wita1\": {\n    \"type\": \"datetime\",\n    \"value\": \"1987-07-05T17:45:56.123456+08:00\"\n  },\n  \"wita2\": {\n    \"type\": \"datetime\",\n    \"value\": \"1987-07-05T17:45:56.600000+08:00\"\n  }\n}\n"
+	input := "utc1  = 1987-07-05T17:45:56.1234Z\nutc2  = 1987-07-05T17:45:56.6Z\nwita1 = 1987-07-05T17:45:56.1234+08:00\nwita2 = 1987-07-05T17:45:56.6+08:00\n"
+	jsonRef := "{\n  \"utc1\": {\n    \"type\": \"datetime\",\n    \"value\": \"1987-07-05T17:45:56.1234Z\"\n  },\n  \"utc2\": {\n    \"type\": \"datetime\",\n    \"value\": \"1987-07-05T17:45:56.6000Z\"\n  },\n  \"wita1\": {\n    \"type\": \"datetime\",\n    \"value\": \"1987-07-05T17:45:56.1234+08:00\"\n  },\n  \"wita2\": {\n    \"type\": \"datetime\",\n    \"value\": \"1987-07-05T17:45:56.6000+08:00\"\n  }\n}\n"
 	testgenValid(t, input, jsonRef)
 }

@@ -1370,6 +1541,12 @@ func TestTOMLTest_Valid_String_Empty(t *testing.T) {
 	testgenValid(t, input, jsonRef)
 }

+func TestTOMLTest_Valid_String_EscapeEsc(t *testing.T) {
+	input := "esc = \"\\e There is no escape! \\e\"\n"
+	jsonRef := "{\n  \"esc\": {\n    \"type\": \"string\",\n    \"value\": \"\\u001b There is no escape! \\u001b\"\n  }\n}\n"
+	testgenValid(t, input, jsonRef)
+}
+
 func TestTOMLTest_Valid_String_EscapeTricky(t *testing.T) {
 	input := "end_esc = \"String does not end here\\\" but ends here\\\\\"\nlit_end_esc = 'String ends here\\'\n\nmultiline_unicode = \"\"\"\n\\u00a0\"\"\"\n\nmultiline_not_unicode = \"\"\"\n\\\\u0041\"\"\"\n\nmultiline_end_esc = \"\"\"When will it end? \\\"\"\"...\"\"\\\" should be here\\\"\"\"\"\n\nlit_multiline_not_unicode = '''\n\\u007f'''\n\nlit_multiline_end = '''There is no escape\\'''\n"
 	jsonRef := "{\n  \"end_esc\": {\n    \"type\": \"string\",\n    \"value\": \"String does not end here\\\" but ends here\\\\\"\n  },\n  \"lit_end_esc\": {\n    \"type\": \"string\",\n    \"value\": \"String ends here\\\\\"\n  },\n  \"lit_multiline_end\": {\n    \"type\": \"string\",\n    \"value\": \"There is no escape\\\\\"\n  },\n  \"lit_multiline_not_unicode\": {\n    \"type\": \"string\",\n    \"value\": \"\\\\u007f\"\n  },\n  \"multiline_end_esc\": {\n    \"type\": \"string\",\n    \"value\": \"When will it end? \\\"\\\"\\\"...\\\"\\\"\\\" should be here\\\"\"\n  },\n  \"multiline_not_unicode\": {\n    \"type\": \"string\",\n    \"value\": \"\\\\u0041\"\n  },\n  \"multiline_unicode\": {\n    \"type\": \"string\",\n    \"value\": \"\u00a0\"\n  }\n}\n"
@@ -1388,14 +1565,20 @@ func TestTOMLTest_Valid_String_Escapes(t *testing.T) {
 	testgenValid(t, input, jsonRef)
 }

+func TestTOMLTest_Valid_String_MultilineEscapedCrlf(t *testing.T) {
+	input := "# The following line should be an unescaped backslash followed by a Windows\r\n# newline sequence (\"\\r\\n\")\r\n0=\"\"\"\\\r\n\"\"\"\r\n"
+	jsonRef := "{\n  \"0\": {\n    \"type\": \"string\",\n    \"value\": \"\"\n  }\n}\n"
+	testgenValid(t, input, jsonRef)
+}
+
 func TestTOMLTest_Valid_String_MultilineQuotes(t *testing.T) {
-	input := "# Make sure that quotes inside multiline strings are allowed, including right\n# after the opening '''/\"\"\" and before the closing '''/\"\"\"\n\nlit_one = ''''one quote''''\nlit_two = '''''two quotes'''''\nlit_one_space = ''' 'one quote' '''\nlit_two_space = ''' ''two quotes'' '''\n\none = \"\"\"\"one quote\"\"\"\"\ntwo = \"\"\"\"\"two quotes\"\"\"\"\"\none_space = \"\"\" \"one quote\" \"\"\"\ntwo_space = \"\"\" \"\"two quotes\"\" \"\"\"\n\nmismatch1 = \"\"\"aaa'''bbb\"\"\"\nmismatch2 = '''aaa\"\"\"bbb'''\n"
-	jsonRef := "{\n  \"lit_one\": {\n    \"type\": \"string\",\n    \"value\": \"'one quote'\"\n  },\n  \"lit_one_space\": {\n    \"type\": \"string\",\n    \"value\": \" 'one quote' \"\n  },\n  \"lit_two\": {\n    \"type\": \"string\",\n    \"value\": \"''two quotes''\"\n  },\n  \"lit_two_space\": {\n    \"type\": \"string\",\n    \"value\": \" ''two quotes'' \"\n  },\n  \"mismatch1\": {\n    \"type\": \"string\",\n    \"value\": \"aaa'''bbb\"\n  },\n  \"mismatch2\": {\n    \"type\": \"string\",\n    \"value\": \"aaa\\\"\\\"\\\"bbb\"\n  },\n  \"one\": {\n    \"type\": \"string\",\n    \"value\": \"\\\"one quote\\\"\"\n  },\n  \"one_space\": {\n    \"type\": \"string\",\n    \"value\": \" \\\"one quote\\\" \"\n  },\n  \"two\": {\n    \"type\": \"string\",\n    \"value\": \"\\\"\\\"two quotes\\\"\\\"\"\n  },\n  \"two_space\": {\n    \"type\": \"string\",\n    \"value\": \" \\\"\\\"two quotes\\\"\\\" \"\n  }\n}\n"
+	input := "# Make sure that quotes inside multiline strings are allowed, including right\n# after the opening '''/\"\"\" and before the closing '''/\"\"\"\n\nlit_one = ''''one quote''''\nlit_two = '''''two quotes'''''\nlit_one_space = ''' 'one quote' '''\nlit_two_space = ''' ''two quotes'' '''\n\none = \"\"\"\"one quote\"\"\"\"\ntwo = \"\"\"\"\"two quotes\"\"\"\"\"\none_space = \"\"\" \"one quote\" \"\"\"\ntwo_space = \"\"\" \"\"two quotes\"\" \"\"\"\n\nmismatch1 = \"\"\"aaa'''bbb\"\"\"\nmismatch2 = '''aaa\"\"\"bbb'''\n\n# Three opening \"\"\", then one escaped \", then two \"\" (allowed), and then three\n# closing \"\"\"\nescaped = \"\"\"lol\\\"\"\"\"\"\"\n"
+	jsonRef := "{\n  \"escaped\": {\n    \"type\": \"string\",\n    \"value\": \"lol\\\"\\\"\\\"\"\n  },\n  \"lit_one\": {\n    \"type\": \"string\",\n    \"value\": \"'one quote'\"\n  },\n  \"lit_one_space\": {\n    \"type\": \"string\",\n    \"value\": \" 'one quote' \"\n  },\n  \"lit_two\": {\n    \"type\": \"string\",\n    \"value\": \"''two quotes''\"\n  },\n  \"lit_two_space\": {\n    \"type\": \"string\",\n    \"value\": \" ''two quotes'' \"\n  },\n  \"mismatch1\": {\n    \"type\": \"string\",\n    \"value\": \"aaa'''bbb\"\n  },\n  \"mismatch2\": {\n    \"type\": \"string\",\n    \"value\": \"aaa\\\"\\\"\\\"bbb\"\n  },\n  \"one\": {\n    \"type\": \"string\",\n    \"value\": \"\\\"one quote\\\"\"\n  },\n  \"one_space\": {\n    \"type\": \"string\",\n    \"value\": \" \\\"one quote\\\" \"\n  },\n  \"two\": {\n    \"type\": \"string\",\n    \"value\": \"\\\"\\\"two quotes\\\"\\\"\"\n  },\n  \"two_space\": {\n    \"type\": \"string\",\n    \"value\": \" \\\"\\\"two quotes\\\"\\\" \"\n  }\n}\n"
 	testgenValid(t, input, jsonRef)
 }

 func TestTOMLTest_Valid_String_Multiline(t *testing.T) {
-	input := "# NOTE: this file includes some literal tab characters.\n\nmultiline_empty_one = \"\"\"\"\"\"\nmultiline_empty_two = \"\"\"\n\"\"\"\nmultiline_empty_three = \"\"\"\\\n    \"\"\"\nmultiline_empty_four = \"\"\"\\\n   \\\n   \\  \n   \"\"\"\n\nequivalent_one = \"The quick brown fox jumps over the lazy dog.\"\nequivalent_two = \"\"\"\nThe quick brown \\\n\n\n  fox jumps over \\\n    the lazy dog.\"\"\"\n\nequivalent_three = \"\"\"\\\n       The quick brown \\\n       fox jumps over \\\n       the lazy dog.\\\n       \"\"\"\n\nwhitespace-after-bs = \"\"\"\\\n       The quick brown \\\n       fox jumps over \\   \n       the lazy dog.\\\t\n       \"\"\"\n\nno-space = \"\"\"a\\\n    b\"\"\"\n\nkeep-ws-before = \"\"\"a   \t\\\n   b\"\"\"\n\nescape-bs-1 = \"\"\"a \\\\\nb\"\"\"\n\nescape-bs-2 = \"\"\"a \\\\\\\nb\"\"\"\n\nescape-bs-3 = \"\"\"a \\\\\\\\\n  b\"\"\"\n"
+	input := "# NOTE: this file includes some literal tab characters.\n\nmultiline_empty_one = \"\"\"\"\"\"\n\n# A newline immediately following the opening delimiter will be trimmed.\nmultiline_empty_two = \"\"\"\n\"\"\"\n\n# \\ at the end of line trims newlines as well; note that last \\ is followed by\n# two spaces, which are ignored.\nmultiline_empty_three = \"\"\"\\\n    \"\"\"\nmultiline_empty_four = \"\"\"\\\n   \\\n   \\  \n   \"\"\"\n\nequivalent_one = \"The quick brown fox jumps over the lazy dog.\"\nequivalent_two = \"\"\"\nThe quick brown \\\n\n\n  fox jumps over \\\n    the lazy dog.\"\"\"\n\nequivalent_three = \"\"\"\\\n       The quick brown \\\n       fox jumps over \\\n       the lazy dog.\\\n       \"\"\"\n\nwhitespace-after-bs = \"\"\"\\\n       The quick brown \\\n       fox jumps over \\   \n       the lazy dog.\\\t\n       \"\"\"\n\nno-space = \"\"\"a\\\n    b\"\"\"\n\n# Has tab character.\nkeep-ws-before = \"\"\"a   \t\\\n   b\"\"\"\n\nescape-bs-1 = \"\"\"a \\\\\nb\"\"\"\n\nescape-bs-2 = \"\"\"a \\\\\\\nb\"\"\"\n\nescape-bs-3 = \"\"\"a \\\\\\\\\n  b\"\"\"\n"
 	jsonRef := "{\n  \"equivalent_one\": {\n    \"type\": \"string\",\n    \"value\": \"The quick brown fox jumps over the lazy dog.\"\n  },\n  \"equivalent_three\": {\n    \"type\": \"string\",\n    \"value\": \"The quick brown fox jumps over the lazy dog.\"\n  },\n  \"equivalent_two\": {\n    \"type\": \"string\",\n    \"value\": \"The quick brown fox jumps over the lazy dog.\"\n  },\n  \"escape-bs-1\": {\n    \"type\": \"string\",\n    \"value\": \"a \\\\\\nb\"\n  },\n  \"escape-bs-2\": {\n    \"type\": \"string\",\n    \"value\": \"a \\\\b\"\n  },\n  \"escape-bs-3\": {\n    \"type\": \"string\",\n    \"value\": \"a \\\\\\\\\\n  b\"\n  },\n  \"keep-ws-before\": {\n    \"type\": \"string\",\n    \"value\": \"a   \\tb\"\n  },\n  \"multiline_empty_four\": {\n    \"type\": \"string\",\n    \"value\": \"\"\n  },\n  \"multiline_empty_one\": {\n    \"type\": \"string\",\n    \"value\": \"\"\n  },\n  \"multiline_empty_three\": {\n    \"type\": \"string\",\n    \"value\": \"\"\n  },\n  \"multiline_empty_two\": {\n    \"type\": \"string\",\n    \"value\": \"\"\n  },\n  \"no-space\": {\n    \"type\": \"string\",\n    \"value\": \"ab\"\n  },\n  \"whitespace-after-bs\": {\n    \"type\": \"string\",\n    \"value\": \"The quick brown fox jumps over the lazy dog.\"\n  }\n}\n"
 	testgenValid(t, input, jsonRef)
 }
@@ -1407,7 +1590,7 @@ func TestTOMLTest_Valid_String_Nl(t *testing.T) {
 }

 func TestTOMLTest_Valid_String_RawMultiline(t *testing.T) {
-	input := "oneline = '''This string has a ' quote character.'''\nfirstnl = '''\nThis string has a ' quote character.'''\nmultiline = '''\nThis string\nhas ' a quote character\nand more than\none newline\nin it.'''\n"
+	input := "# Single ' should be allowed.\noneline = '''This string has a ' quote character.'''\n\n# A newline immediately following the opening delimiter will be trimmed.\nfirstnl = '''\nThis string has a ' quote character.'''\n\n# All other whitespace and newline characters remain intact.\nmultiline = '''\nThis string\nhas ' a quote character\nand more than\none newline\nin it.'''\n"
 	jsonRef := "{\n  \"firstnl\": {\n    \"type\": \"string\",\n    \"value\": \"This string has a ' quote character.\"\n  },\n  \"multiline\": {\n    \"type\": \"string\",\n    \"value\": \"This string\\nhas ' a quote character\\nand more than\\none newline\\nin it.\"\n  },\n  \"oneline\": {\n    \"type\": \"string\",\n    \"value\": \"This string has a ' quote character.\"\n  }\n}\n"
 	testgenValid(t, input, jsonRef)
 }
@@ -42,21 +42,22 @@ func NewDecoder(r io.Reader) *Decoder {
 	return &Decoder{r: r}
 }

-// SetStrict toggles decoding in stict mode.
+// DisallowUnknownFields causes the Decoder to return an error when the
+// destination is a struct and the input contains a key that does not match a
+// non-ignored field.
 //
-// When the decoder is in strict mode, it will record fields from the document
-// that could not be set on the target value. In that case, the decoder returns
-// a StrictMissingError that can be used to retrieve the individual errors as
-// well as generate a human readable description of the missing fields.
-func (d *Decoder) SetStrict(strict bool) *Decoder {
-	d.strict = strict
+// In that case, the Decoder returns a StrictMissingError that can be used to
+// retrieve the individual errors as well as generate a human readable
+// description of the missing fields.
+func (d *Decoder) DisallowUnknownFields() *Decoder {
+	d.strict = true
 	return d
 }

 // Decode the whole content of r into v.
 //
 // By default, values in the document that don't exist in the target Go value
-// are ignored. See Decoder.SetStrict() to change this behavior.
+// are ignored. See Decoder.DisallowUnknownFields() to change this behavior.
 //
 // When a TOML local date, time, or date-time is decoded into a time.Time, its
 // value is represented in time.Local timezone. Otherwise the approriate Local*
@@ -78,22 +79,22 @@ func (d *Decoder) SetStrict(strict bool) *Decoder {
 // strict mode and a field is missing, a `toml.StrictMissingError` is
 // returned. In any other case, this function returns a standard Go error.
 //
-// Type mapping
+// # Type mapping
 //
 // List of supported TOML types and their associated accepted Go types:
 //
-//   String           -> string
-//   Integer          -> uint*, int*, depending on size
-//   Float            -> float*, depending on size
-//   Boolean          -> bool
-//   Offset Date-Time -> time.Time
-//   Local Date-time  -> LocalDateTime, time.Time
-//   Local Date       -> LocalDate, time.Time
-//   Local Time       -> LocalTime, time.Time
-//   Array            -> slice and array, depending on elements types
-//   Table            -> map and struct
-//   Inline Table     -> same as Table
-//   Array of Tables  -> same as Array and Table
+//	String           -> string
+//	Integer          -> uint*, int*, depending on size
+//	Float            -> float*, depending on size
+//	Boolean          -> bool
+//	Offset Date-Time -> time.Time
+//	Local Date-time  -> LocalDateTime, time.Time
+//	Local Date       -> LocalDate, time.Time
+//	Local Time       -> LocalTime, time.Time
+//	Array            -> slice and array, depending on elements types
+//	Table            -> map and struct
+//	Inline Table     -> same as Table
+//	Array of Tables  -> same as Array and Table
 func (d *Decoder) Decode(v interface{}) error {
 	b, err := ioutil.ReadAll(d.r)
 	if err != nil {
@@ -122,7 +123,7 @@ type decoder struct {
 	stashedExpr bool

 	// Skip expressions until a table is found. This is set to true when a
-	// table could not be create (missing field in map), so all KV expressions
+	// table could not be created (missing field in map), so all KV expressions
 	// need to be skipped.
 	skipUntilTable bool

@@ -321,10 +322,12 @@ func (d *decoder) handleArrayTableCollectionLast(key ast.Iterator, v reflect.Val
 		return v, nil
 	case reflect.Slice:
 		elemType := v.Type().Elem()
+		var elem reflect.Value
 		if elemType.Kind() == reflect.Interface {
-			elemType = mapStringInterfaceType
+			elem = makeMapStringInterface()
+		} else {
+			elem = reflect.New(elemType).Elem()
 		}
-		elem := reflect.New(elemType).Elem()
 		elem2, err := d.handleArrayTable(key, elem)
 		if err != nil {
 			return reflect.Value{}, err
@@ -341,9 +344,9 @@ func (d *decoder) handleArrayTableCollectionLast(key ast.Iterator, v reflect.Val
 		elem := v.Index(idx)
 		_, err := d.handleArrayTable(key, elem)
 		return v, err
+	default:
+		return reflect.Value{}, fmt.Errorf("toml: cannot decode array table into a %s", v.Type())
 	}
-
-	return d.handleArrayTable(key, v)
 }

 // When parsing an array table expression, each part of the key needs to be
@@ -411,9 +414,10 @@ func (d *decoder) handleKeyPart(key ast.Iterator, v reflect.Value, nextFn handle
 		elem = v.Elem()
 		return d.handleKeyPart(key, elem, nextFn, makeFn)
 	case reflect.Map:
+		vt := v.Type()

-		// Create the key for the map element. For now assume it's a string.
-		mk := reflect.ValueOf(string(key.Node().Data))
+		// Create the key for the map element. Convert to key type.
+		mk := reflect.ValueOf(string(key.Node().Data)).Convert(vt.Key())

 		// If the map does not exist, create it.
 		if v.IsNil() {
@@ -430,7 +434,6 @@ func (d *decoder) handleKeyPart(key ast.Iterator, v reflect.Value, nextFn handle
 			// map[string]interface{} or a []interface{} depending on whether
 			// this is the last part of the array table key.

-			vt := v.Type()
 			t := vt.Elem()
 			if t.Kind() == reflect.Interface {
 				mv = makeFn()
@@ -480,7 +483,7 @@ func (d *decoder) handleKeyPart(key ast.Iterator, v reflect.Value, nextFn handle
 		d.errorContext.Struct = t
 		d.errorContext.Field = path

-		f := v.FieldByIndex(path)
+		f := fieldByIndex(v, path)
 		x, err := nextFn(key, f)
 		if err != nil || d.skipUntilTable {
 			return reflect.Value{}, err
@@ -610,7 +613,7 @@ func (d *decoder) tryTextUnmarshaler(node *ast.Node, v reflect.Value) (bool, err
 	if v.CanAddr() && v.Addr().Type().Implements(textUnmarshalerType) {
 		err := v.Addr().Interface().(encoding.TextUnmarshaler).UnmarshalText(node.Data)
 		if err != nil {
-			return false, newDecodeError(d.p.Raw(node.Raw), "error calling UnmarshalText: %w", err)
+			return false, newDecodeError(d.p.Raw(node.Raw), "%w", err)
 		}

 		return true, nil
@@ -863,12 +866,27 @@ func (d *decoder) unmarshalFloat(value *ast.Node, v reflect.Value) error {
 	return nil
 }

-func (d *decoder) unmarshalInteger(value *ast.Node, v reflect.Value) error {
-	const (
-		maxInt = int64(^uint(0) >> 1)
-		minInt = -maxInt - 1
-	)
+const (
+	maxInt = int64(^uint(0) >> 1)
+	minInt = -maxInt - 1
+)

+// Maximum value of uint for decoding. Currently the decoder parses the integer
+// into an int64. As a result, on architectures where uint is 64 bits, the
+// effective maximum uint we can decode is the maximum of int64. On
+// architectures where uint is 32 bits, the maximum value we can decode is
+// lower: the maximum of uint32. I didn't find a way to figure out this value at
+// compile time, so it is computed during initialization.
+var maxUint int64 = math.MaxInt64
+
+func init() {
+	m := uint64(^uint(0))
+	if m < uint64(maxUint) {
+		maxUint = int64(m)
+	}
+}
+
+func (d *decoder) unmarshalInteger(value *ast.Node, v reflect.Value) error {
 	i, err := parseInteger(value.Data)
 	if err != nil {
 		return err
@@ -929,7 +947,7 @@ func (d *decoder) unmarshalInteger(value *ast.Node, v reflect.Value) error {

 		r = reflect.ValueOf(uint8(i))
 	case reflect.Uint:
-		if i < 0 {
+		if i < 0 || i > maxUint {
 			return fmt.Errorf("toml: negative number %d does not fit in an uint", i)
 		}

@@ -1053,7 +1071,7 @@ func (d *decoder) handleKeyValuePart(key ast.Iterator, value *ast.Node, v reflec
 		d.errorContext.Struct = t
 		d.errorContext.Field = path

-		f := v.FieldByIndex(path)
+		f := fieldByIndex(v, path)
 		x, err := d.handleKeyValueInner(key, value, f)
 		if err != nil {
 			return reflect.Value{}, err
@@ -1117,6 +1135,21 @@ func initAndDereferencePointer(v reflect.Value) reflect.Value {
 	return elem
 }

+// Same as reflect.Value.FieldByIndex, but creates pointers if needed.
+func fieldByIndex(v reflect.Value, path []int) reflect.Value {
+	for i, x := range path {
+		v = v.Field(x)
+
+		if i < len(path)-1 && v.Kind() == reflect.Ptr {
+			if v.IsNil() {
+				v.Set(reflect.New(v.Type().Elem()))
+			}
+			v = v.Elem()
+		}
+	}
+	return v
+}
+
 type fieldPathsMap = map[string][]int

 var globalFieldPathsCache atomic.Value // map[danger.TypeID]fieldPathsMap
@@ -1164,11 +1197,6 @@ func forEachField(t reflect.Type, path []int, do func(name string, path []int))
 		fieldPath := append(path, i)
 		fieldPath = fieldPath[:len(fieldPath):len(fieldPath)]

-		if f.Anonymous {
-			forEachField(f.Type, fieldPath, do)
-			continue
-		}
-
 		name := f.Tag.Get("toml")
 		if name == "-" {
 			continue
@@ -1177,6 +1205,19 @@ func forEachField(t reflect.Type, path []int, do func(name string, path []int))
 		if i := strings.IndexByte(name, ','); i >= 0 {
 			name = name[:i]
 		}
+
+		if f.Anonymous && name == "" {
+			t2 := f.Type
+			if t2.Kind() == reflect.Ptr {
+				t2 = t2.Elem()
+			}
+
+			if t2.Kind() == reflect.Struct {
+				forEachField(t2, fieldPath, do)
+			}
+			continue
+		}
+
 		if name == "" {
 			name = f.Name
 		}
@@ -16,7 +16,7 @@ import (
 	"github.com/stretchr/testify/require"
 )

-func ExampleDecoder_SetStrict() {
+func ExampleDecoder_DisallowUnknownFields() {
 	type S struct {
 		Key1 string
 		Key3 string
@@ -28,7 +28,7 @@ key3 = "value3"
 `
 	r := strings.NewReader(doc)
 	d := toml.NewDecoder(r)
-	d.SetStrict(true)
+	d.DisallowUnknownFields()
 	s := S{}
 	err := d.Decode(&s)

@@ -279,6 +279,11 @@ func TestUnmarshal_Floats(t *testing.T) {
 			input: `1.0_e2`,
 			err:   true,
 		},
+		{
+			desc:  "leading zero in positive float",
+			input: `+0_0.0`,
+			err:   true,
+		},
 	}

 	type doc struct {
@@ -540,6 +545,35 @@ func TestUnmarshal(t *testing.T) {
 				}
 			},
 		},
+		{
+			desc: "issue 739 - table redefinition",
+			input: `
+[foo.bar.baz]
+wibble = 'wobble'
+
+[foo]
+
+[foo.bar]
+huey = 'dewey'
+			`,
+			gen: func() test {
+				m := map[string]interface{}{}
+
+				return test{
+					target: &m,
+					expected: &map[string]interface{}{
+						`foo`: map[string]interface{}{
+							"bar": map[string]interface{}{
+								"huey": "dewey",
+								"baz": map[string]interface{}{
+									"wibble": "wobble",
+								},
+							},
+						},
+					},
+				}
+			},
+		},
 		{
 			desc: "multiline basic string",
 			input: `A = """\
@@ -937,7 +971,7 @@ B = "data"`,
 								"Name": "Hammer",
 								"Sku":  int64(738594937),
 							},
-							map[string]interface{}(nil),
+							map[string]interface{}{},
 							map[string]interface{}{
 								"Name":  "Nail",
 								"Sku":   int64(284758393),
@@ -1471,7 +1505,7 @@ B = "data"`,
 					target: &map[string]interface{}{},
 					expected: &map[string]interface{}{
 						"products": []interface{}{
-							map[string]interface{}(nil),
+							map[string]interface{}{},
 						},
 					},
 				}
@@ -1701,6 +1735,28 @@ B = "data"`,
 				}
 			},
 		},
+		{
+			desc:  "kv that points to a slice",
+			input: "a.b.c = 'foo'",
+			gen: func() test {
+				doc := map[string][]string{}
+				return test{
+					target: &doc,
+					err:    true,
+				}
+			},
+		},
+		{
+			desc:  "kv that points to a pointer to a slice",
+			input: "a.b.c = 'foo'",
+			gen: func() test {
+				doc := map[string]*[]string{}
+				return test{
+					target: &doc,
+					err:    true,
+				}
+			},
+		},
 	}

 	for _, e := range examples {
@@ -1842,8 +1898,7 @@ key2 = "missing2"
 key3 = "missing3"
 key4 = "value4"
 `,
-			expected: `
-2| key1 = "value1"
+			expected: `2| key1 = "value1"
 3| key2 = "missing2"
 | ~~~~ missing field
 4| key3 = "missing3"
@@ -1853,8 +1908,7 @@ key4 = "value4"
 3| key2 = "missing2"
 4| key3 = "missing3"
 | ~~~~ missing field
-5| key4 = "value4"
-`,
+5| key4 = "value4"`,
 			target: &struct {
 				Key1 string
 				Key4 string
@@ -1863,10 +1917,8 @@ key4 = "value4"
 		{
 			desc:  "multi-part key",
 			input: `a.short.key="foo"`,
-			expected: `
-1| a.short.key="foo"
- | ~~~~~~~~~~~ missing field
-`,
+			expected: `1| a.short.key="foo"
+ | ~~~~~~~~~~~ missing field`,
 		},
 		{
 			desc: "missing table",
@@ -1874,24 +1926,19 @@ key4 = "value4"
 [foo]
 bar = 42
 `,
-			expected: `
-2| [foo]
+			expected: `2| [foo]
 |  ~~~ missing table
-3| bar = 42
-`,
+3| bar = 42`,
 		},

 		{
 			desc: "missing array table",
 			input: `
 [[foo]]
-bar = 42
-`,
-			expected: `
-2| [[foo]]
+bar = 42`,
+			expected: `2| [[foo]]
 |   ~~~ missing table
-3| bar = 42
-`,
+3| bar = 42`,
 		},
 	}

@@ -1901,7 +1948,7 @@ bar = 42
 			t.Run("strict", func(t *testing.T) {
 				r := strings.NewReader(e.input)
 				d := toml.NewDecoder(r)
-				d.SetStrict(true)
+				d.DisallowUnknownFields()
 				x := e.target
 				if x == nil {
 					x = &struct{}{}
@@ -1910,7 +1957,7 @@ bar = 42

 				var tsm *toml.StrictMissingError
 				if errors.As(err, &tsm) {
-					equalStringsIgnoreNewlines(t, e.expected, tsm.String())
+					assert.Equal(t, e.expected, tsm.String())
 				} else {
 					t.Fatalf("err should have been a *toml.StrictMissingError, but got %s (%T)", err, err)
 				}
@@ -1919,7 +1966,6 @@ bar = 42
 			t.Run("default", func(t *testing.T) {
 				r := strings.NewReader(e.input)
 				d := toml.NewDecoder(r)
-				d.SetStrict(false)
 				x := e.target
 				if x == nil {
 					x = &struct{}{}
@@ -2347,6 +2393,79 @@ func TestIssue714(t *testing.T) {
 	require.Error(t, err)
 }

+func TestIssue772(t *testing.T) {
+	type FileHandling struct {
+		FilePattern string `toml:"pattern"`
+	}
+
+	type Config struct {
+		FileHandling `toml:"filehandling"`
+	}
+
+	var defaultConfigFile = []byte(`
+		[filehandling]
+		pattern = "reach-masterdev-"`)
+
+	config := Config{}
+	err := toml.Unmarshal(defaultConfigFile, &config)
+	require.NoError(t, err)
+	require.Equal(t, "reach-masterdev-", config.FileHandling.FilePattern)
+}
+
+func TestIssue774(t *testing.T) {
+	type ScpData struct {
+		Host string `json:"host"`
+	}
+
+	type GenConfig struct {
+		SCP []ScpData `toml:"scp" comment:"Array of Secure Copy Configurations"`
+	}
+
+	c := &GenConfig{}
+	c.SCP = []ScpData{{Host: "main.domain.com"}}
+
+	b, err := toml.Marshal(c)
+	require.NoError(t, err)
+
+	expected := `# Array of Secure Copy Configurations
+[[scp]]
+Host = 'main.domain.com'
+`
+
+	require.Equal(t, expected, string(b))
+}
+
+func TestIssue799(t *testing.T) {
+	const testTOML = `
+# notice the double brackets
+[[test]]
+answer = 42
+`
+
+	var s struct {
+		// should be []map[string]int
+		Test map[string]int `toml:"test"`
+	}
+
+	err := toml.Unmarshal([]byte(testTOML), &s)
+	require.Error(t, err)
+}
+
+func TestIssue807(t *testing.T) {
+	type A struct {
+		Name string `toml:"name"`
+	}
+
+	type M struct {
+		*A
+	}
+
+	var m M
+	err := toml.Unmarshal([]byte(`name = 'foo'`), &m)
+	require.NoError(t, err)
+	require.Equal(t, "foo", m.Name)
+}
+
 func TestUnmarshalDecodeErrors(t *testing.T) {
 	examples := []struct {
 		desc string
@@ -2798,6 +2917,36 @@ world'`,
 	}
 }

+func TestOmitEmpty(t *testing.T) {
+	type inner struct {
+		private string
+		Skip    string `toml:"-"`
+		V       string
+	}
+
+	type elem struct {
+		Foo   string `toml:",omitempty"`
+		Bar   string `toml:",omitempty"`
+		Inner inner  `toml:",omitempty"`
+	}
+
+	type doc struct {
+		X []elem `toml:",inline"`
+	}
+
+	d := doc{X: []elem{elem{
+		Foo: "test",
+		Inner: inner{
+			V: "alue",
+		},
+	}}}
+
+	b, err := toml.Marshal(d)
+	require.NoError(t, err)
+
+	require.Equal(t, "X = [{Foo = 'test', Inner = {V = 'alue'}}]\n", string(b))
+}
+
 func TestUnmarshalTags(t *testing.T) {
 	type doc struct {
 		Dash   string `toml:"-,"`
@@ -3139,3 +3288,16 @@ func TestUnmarshal_RecursiveTableArray(t *testing.T) {
 		})
 	}
 }
+
+func TestUnmarshalEmbedNonString(t *testing.T) {
+	type Foo []byte
+	type doc struct {
+		Foo
+	}
+
+	d := doc{}
+
+	err := toml.Unmarshal([]byte(`foo = 'bar'`), &d)
+	require.NoError(t, err)
+	require.Nil(t, d.Foo)
+}
Author	SHA1	Message	Date
Thomas Pelletier	3077a406a1	ci: linux/386	2022-09-09 19:58:56 -04:00
Thomas Pelletier	48ca06a23c	ci: add tinygo test	2022-09-09 19:58:47 -04:00
Thomas Pelletier	942841787a	Fix reflect.Pointer backward compatibility (#813 ) Though we don't officially support older versions of Go, this is an easy fix to unblock people. Fixes #812	2022-08-26 09:15:03 -04:00
Thomas Pelletier	28f1efc7d3	Decode: don't break on non-struct embed field (#810 )	2022-08-22 18:39:11 -04:00
Piotr Buliński	7d69e4a728	Add missing '+build' comment to fuzz_test.go (#809 )	2022-08-22 14:05:37 -04:00
Thomas Pelletier	e46d245c09	Decode: don't crash on embedded nil pointers (#808 ) Also has the perks of reducing the overhead of FindByIndex: ``` name old time/op new time/op delta UnmarshalDataset/config-32 17.0ms ± 1% 17.0ms ± 1% ~ (p=1.000 n=5+5) UnmarshalDataset/canada-32 71.6ms ± 1% 71.4ms ± 1% ~ (p=1.000 n=5+5) UnmarshalDataset/citm_catalog-32 24.2ms ± 3% 23.5ms ± 2% -3.03% (p=0.032 n=5+5) UnmarshalDataset/twitter-32 9.37ms ± 1% 9.09ms ± 2% -2.97% (p=0.032 n=5+5) UnmarshalDataset/code-32 75.4ms ± 2% 74.9ms ± 0% ~ (p=0.222 n=5+5) UnmarshalDataset/example-32 147µs ±10% 136µs ± 1% -7.14% (p=0.008 n=5+5) Unmarshal/SimpleDocument/struct-32 512ns ± 2% 500ns ± 0% -2.35% (p=0.008 n=5+5) Unmarshal/SimpleDocument/map-32 721ns ± 2% 702ns ± 1% -2.68% (p=0.008 n=5+5) Unmarshal/ReferenceFile/struct-32 40.1µs ± 0% 39.6µs ± 0% -1.30% (p=0.008 n=5+5) Unmarshal/ReferenceFile/map-32 62.3µs ± 1% 60.6µs ± 0% -2.83% (p=0.008 n=5+5) Unmarshal/HugoFrontMatter-32 10.8µs ± 1% 10.5µs ± 1% -2.86% (p=0.008 n=5+5) name old speed new speed delta UnmarshalDataset/config-32 61.8MB/s ± 1% 61.8MB/s ± 1% ~ (p=1.000 n=5+5) UnmarshalDataset/canada-32 30.8MB/s ± 1% 30.8MB/s ± 1% ~ (p=1.000 n=5+5) UnmarshalDataset/citm_catalog-32 23.0MB/s ± 3% 23.8MB/s ± 2% +3.09% (p=0.032 n=5+5) UnmarshalDataset/twitter-32 47.2MB/s ± 1% 48.6MB/s ± 2% +3.09% (p=0.032 n=5+5) UnmarshalDataset/code-32 35.6MB/s ± 2% 35.9MB/s ± 0% ~ (p=0.222 n=5+5) UnmarshalDataset/example-32 55.3MB/s ±10% 59.4MB/s ± 1% +7.36% (p=0.008 n=5+5) Unmarshal/SimpleDocument/struct-32 21.5MB/s ± 2% 22.0MB/s ± 0% +2.41% (p=0.008 n=5+5) Unmarshal/SimpleDocument/map-32 15.2MB/s ± 2% 15.7MB/s ± 1% +2.74% (p=0.008 n=5+5) Unmarshal/ReferenceFile/struct-32 131MB/s ± 0% 132MB/s ± 0% +1.31% (p=0.008 n=5+5) Unmarshal/ReferenceFile/map-32 84.1MB/s ± 1% 86.6MB/s ± 0% +2.91% (p=0.008 n=5+5) Unmarshal/HugoFrontMatter-32 50.6MB/s ± 1% 52.1MB/s ± 1% +2.93% (p=0.008 n=5+5) name old alloc/op new alloc/op delta UnmarshalDataset/config-32 5.86MB ± 0% 5.86MB ± 0% ~ (p=0.579 n=5+5) UnmarshalDataset/canada-32 83.0MB ± 0% 83.0MB ± 0% ~ (p=0.651 n=5+5) UnmarshalDataset/citm_catalog-32 34.7MB ± 0% 34.7MB ± 0% ~ (p=0.548 n=5+5) UnmarshalDataset/twitter-32 12.7MB ± 0% 12.7MB ± 0% ~ (p=1.000 n=5+5) UnmarshalDataset/code-32 22.2MB ± 0% 22.2MB ± 0% ~ (p=0.841 n=5+5) UnmarshalDataset/example-32 186kB ± 0% 186kB ± 0% ~ (p=0.111 n=5+5) Unmarshal/SimpleDocument/struct-32 805B ± 0% 805B ± 0% ~ (all equal) Unmarshal/SimpleDocument/map-32 1.13kB ± 0% 1.13kB ± 0% ~ (all equal) Unmarshal/ReferenceFile/struct-32 20.9kB ± 0% 20.9kB ± 0% ~ (p=0.643 n=5+5) Unmarshal/ReferenceFile/map-32 38.3kB ± 0% 38.3kB ± 0% ~ (p=0.397 n=5+5) Unmarshal/HugoFrontMatter-32 7.44kB ± 0% 7.44kB ± 0% ~ (all equal) name old allocs/op new allocs/op delta UnmarshalDataset/config-32 227k ± 0% 227k ± 0% ~ (p=1.000 n=5+5) UnmarshalDataset/canada-32 782k ± 0% 782k ± 0% ~ (all equal) UnmarshalDataset/citm_catalog-32 192k ± 0% 192k ± 0% ~ (p=0.968 n=4+5) UnmarshalDataset/twitter-32 56.9k ± 0% 56.9k ± 0% ~ (p=0.429 n=4+5) UnmarshalDataset/code-32 1.05M ± 0% 1.05M ± 0% ~ (p=0.556 n=4+5) UnmarshalDataset/example-32 1.36k ± 0% 1.36k ± 0% ~ (all equal) Unmarshal/SimpleDocument/struct-32 9.00 ± 0% 9.00 ± 0% ~ (all equal) Unmarshal/SimpleDocument/map-32 13.0 ± 0% 13.0 ± 0% ~ (all equal) Unmarshal/ReferenceFile/struct-32 183 ± 0% 183 ± 0% ~ (all equal) Unmarshal/ReferenceFile/map-32 642 ± 0% 642 ± 0% ~ (all equal) Unmarshal/HugoFrontMatter-32 141 ± 0% 141 ± 0% ~ (all equal) ``` Fixes #807	2022-08-20 21:24:03 -04:00
Thomas Pelletier	7baa23f493	Decode: error on array table mismatched type (#804 ) Prevent the decoder from continuing if it encounters a type it cannot decode an array table into. Fixes #799	2022-08-15 16:38:07 -04:00
Thomas Pelletier	2d8433b69e	Encode: don't inherit omitempty (#803 ) Fixes #786.	2022-08-15 11:29:46 -04:00
Thomas Pelletier	67bc5422f3	Go 1.19 (#802 )	2022-08-15 10:56:33 -04:00
Thomas Pelletier	fb6d1d6c2b	Marshal: define and fix newlines behavior when using omitempty (#798 ) Ref #786	2022-07-24 15:40:20 -04:00
dependabot[bot]	d017a6dc89	build(deps): bump github.com/stretchr/testify from 1.7.5 to 1.8.0 (#795 )	2022-06-29 09:51:28 -04:00
dependabot[bot]	d6d3196163	build(deps): bump github.com/stretchr/testify from 1.7.4 to 1.7.5 (#794 )	2022-06-24 12:49:56 -04:00
dependabot[bot]	41718a6db3	build(deps): bump github.com/stretchr/testify from 1.7.2 to 1.7.4 (#793 ) Bumps [github.com/stretchr/testify](https://github.com/stretchr/testify) from 1.7.2 to 1.7.4. - [Release notes](https://github.com/stretchr/testify/releases) - [Commits](https://github.com/stretchr/testify/compare/v1.7.2...v1.7.4) --- updated-dependencies: - dependency-name: github.com/stretchr/testify dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2022-06-21 08:32:13 -04:00
Thomas Pelletier	216628222f	Build arm + arm64 binaries for linux and windows (#790 ) * Build arm + arm64 binaries for linux and windows * Type MaxInt64 to avoid overflow on 32 bits arch On a 32 bits arch, math.MaxIn64 is interpreted as an int, and therefore overflows. This causes compilation to build on those platforms.	2022-06-08 18:05:42 -04:00
dependabot[bot]	322e0b15d2	build(deps): bump github.com/stretchr/testify from 1.7.1 to 1.7.2 (#788 ) Bumps [github.com/stretchr/testify](https://github.com/stretchr/testify) from 1.7.1 to 1.7.2. - [Release notes](https://github.com/stretchr/testify/releases) - [Commits](https://github.com/stretchr/testify/compare/v1.7.1...v1.7.2) --- updated-dependencies: - dependency-name: github.com/stretchr/testify dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2022-06-08 17:44:59 -04:00
Thomas Pelletier	85bfc0ed51	Encode: add bound check for uint64 > math.Int64 (#785 ) As brought up on #782, there is an asymetry between numbers go-toml can encode and decode. Specifically, unsigned numbers larger than `math.Int64` could be encoded but not decoded. We considered two options: allow decoding of those numbers, or prevent those numbers to be decoded. Ultimately we decided to narrow the range of numbers to be encoded. The TOML specification only requires parsers to support at least the 64 bits integer range. Allowing larger numbers would create non-standard TOML documents, which may not be readable (at best) by other implementations. It is a safer default to generate documents valid by default. People who wish to deal with larger numbers can provide a custom type implementing `encoding.TextMarshaler`. Refs #781	2022-05-31 22:10:41 -04:00
dependabot[bot]	295a720dfb	build(deps): bump goreleaser/goreleaser-action from 2 to 3 (#783 ) Bumps [goreleaser/goreleaser-action](https://github.com/goreleaser/goreleaser-action) from 2 to 3. - [Release notes](https://github.com/goreleaser/goreleaser-action/releases) - [Commits](https://github.com/goreleaser/goreleaser-action/compare/v2...v3) --- updated-dependencies: - dependency-name: goreleaser/goreleaser-action dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2022-05-23 15:05:00 +02:00
Thomas Pelletier	0a422e3dbd	Decoder: check max uint on 32 bit platforms (#778 ) Fixes #777	2022-05-10 15:43:26 +02:00
Thomas Pelletier	627dade0c7	Encode: support comment on array tables (#776 ) Fixes #774	2022-05-10 15:17:36 +02:00
Thomas Pelletier	b2e0231cc9	Encode: fix multiline comment (#775 ) Fixes #768	2022-05-10 14:53:26 +02:00
dependabot[bot]	ba95863cd3	build(deps): bump docker/login-action from 1 to 2 (#771 ) Bumps [docker/login-action](https://github.com/docker/login-action) from 1 to 2. - [Release notes](https://github.com/docker/login-action/releases) - [Commits](https://github.com/docker/login-action/compare/v1...v2) --- updated-dependencies: - dependency-name: docker/login-action dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2022-05-09 18:59:02 +02:00
Erik Hartwig	db679df765	Typo in README.md fix (#770 ) Change "document was not prevent in the target structure" to "document was not present in the target structure".	2022-05-09 18:46:46 +02:00
Thomas Pelletier	c5ca2c682b	Fix embedded struct with explicit field name (#773 ) Fixes #772	2022-05-09 18:45:02 +02:00
Thomas Pelletier	ed80712cb4	Copy version policy from v1	2022-04-28 11:55:39 -04:00
dependabot[bot]	b24772942d	build(deps): bump github/codeql-action from 1 to 2 (#764 ) Bumps [github/codeql-action](https://github.com/github/codeql-action) from 1 to 2. - [Release notes](https://github.com/github/codeql-action/releases) - [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md) - [Commits](https://github.com/github/codeql-action/compare/v1...v2) --- updated-dependencies: - dependency-name: github/codeql-action dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2022-04-28 08:24:14 -04:00
dependabot[bot]	9501a05ed7	build(deps): bump actions/checkout from 2 to 3 (#765 ) Bumps [actions/checkout](https://github.com/actions/checkout) from 2 to 3. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/v2...v3) --- updated-dependencies: - dependency-name: actions/checkout dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2022-04-28 08:23:56 -04:00
Thomas Pelletier	171a592663	Prepare repository for v2.0.0 (#762 )	2022-04-27 21:29:16 -04:00
Thomas Pelletier	5aaf5ef13b	Fix internal entry size test (#761 ) The test meant to assert that the size of entry does not grow beyond what it is today. 48 is the current size in bytes on x64. On 32-bit platform that value should be less. As written the test was doing the opposite comparison. Fixes #760	2022-04-24 18:50:54 -04:00
Thomas Pelletier	adacebd8c7	Update benchmarks in README (#756 )	2022-04-10 22:24:19 -04:00
Thomas Pelletier	8bbb673431	Fuzzing setup and fixes (#755 ) * encode: fix localdate formatting * encode: fix empty key marshaling * encode: fix invalid quotation of time.Time * encode: ensure control chars are escaped * decode: always use UTC for zero tz * encode: check for invalid characters in keys * encode: always construct map for empty array tables * fuzz: add go 1.18 fuzz test * encode: handle NaNs * encode: allow new lines in quoted keys * encode: never emit table inside array * encode: don't capitalize inf	2022-04-10 21:37:12 -04:00
Thomas Pelletier	2377ac4bc0	encode: fix embedded interfaces (#753 ) Resolve marshaling regression when handling an embedded interface in a struct. Fixes #752	2022-04-08 09:25:54 -04:00
Thomas Pelletier	f5cc8c49eb	decoder: remove mention of UnmarshalText in errors (#751 ) Fixes #737	2022-04-07 21:58:19 -04:00
Thomas Pelletier	89d7b412d8	decode: allow subtables to be defined later (#750 ) Fixes #739	2022-04-07 21:49:16 -04:00
Thomas Pelletier	88a8aecdd4	tools: display error context when it exists (#749 ) For example when failing to decode toml, display the context around the error and the location of the problem.	2022-04-07 20:33:09 -04:00
Thomas Pelletier	9804fc57e0	decoder: support \e escape sequence (#748 )	2022-04-07 20:18:30 -04:00
Thomas Pelletier	068279f13b	encode: respect stdlib rules for embedded structs (#747 )	2022-04-07 19:51:09 -04:00
Thomas Pelletier	b9edbeb611	Update testify dependency (#746 )	2022-03-30 15:10:57 -04:00
Thomas Pelletier	a97c9317d4	Go 1.18 (#745 )	2022-03-23 10:26:12 -04:00
Gregory Oschwald	3229a0abfb	Decode: convert table key to correct type (#741 ) Fixes #740.	2022-03-02 09:24:01 -05:00
Thomas Pelletier	3f5d8a6b06	Mention removal of go-toml/query (#736 ) Fixes #722	2022-01-07 18:58:33 -05:00
Cameron Moore	146f70ea8a	Decode: use cleaned byte slice throughout parseFloat (#735 ) Fixes #734	2022-01-06 14:34:27 -05:00
Thomas Pelletier	e83cf535f5	Decoder: rename SetStrict to DisallowUnknownFields (#731 )	2022-01-02 14:32:34 -05:00
Thomas Pelletier	c3ba3ef97a	readme: add docker image	2022-01-01 09:53:14 -05:00
Thomas Pelletier	7ee3c8ff25	build: login to github repository	2022-01-01 09:24:52 -05:00
Thomas Pelletier	1e85aa6d78	build: add contents permissions	2021-12-31 20:47:50 -05:00
Thomas Pelletier	46fa3225e2	build: allows the token to write packages	2021-12-31 20:25:11 -05:00
Thomas Pelletier	4d51831dab	build: replace grc.io with ghcr.io	2021-12-31 20:10:36 -05:00
Thomas Pelletier	5a1a96cb2d	build: pass the github token to goreleaser	2021-12-31 20:03:18 -05:00
Thomas Pelletier	ea9040ae83	build: change workflow reference to v2	2021-12-31 19:57:41 -05:00
Thomas Pelletier	2373685f1e	Docker + goreleaser (#729 )	2021-12-31 19:55:31 -05:00
Thomas Pelletier	f1391952d4	Update and move testsuite to internal package (#730 ) * Regenerate test suite * Move test suite to /internal	2021-12-31 18:52:26 -05:00
Thomas Pelletier	4a73a200ed	Clean up tools godoc	2021-12-31 15:56:40 -05:00
Thomas Pelletier	4807229e94	tomll: port to v2 (#727 ) Fixes #721	2021-12-31 15:40:18 -05:00
Thomas Pelletier	d8ddc00c61	jsontoml: port to v2 (#726 ) Fixes #719	2021-12-31 14:40:20 -05:00
Thomas Pelletier	82f8dad811	tomljson: port to v2 (#725 )	2021-12-31 13:25:53 -05:00
Thomas Pelletier	75db1016e8	Remove extra words from CONTRIBUTING	2021-12-29 10:26:22 -05:00
Thomas Pelletier	de6d715bd2	Update CONTRIBUTING.md	2021-12-29 10:25:28 -05:00
Thomas Pelletier	3ab2fc2b87	Update release proces documentation	2021-12-29 10:24:01 -05:00