fix parser error highlight offsets for non-suffix slices

Co-authored-by: Thomas Pelletier <thomas@pelletier.dev>

.gitattributes

@@ -0,0 +1,4 @@
+* text=auto
+
+benchmark/benchmark.toml text eol=lf
+testdata/** text eol=lf

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,5 +1,19 @@
-**Issue:** add link to pelletier/go-toml issue here
+<!--
+
+Thank you for your pull request!
+
+Please read the Code changes section of the CONTRIBUTING.md file,
+and make sure you have followed the instructions.
+
+https://github.com/pelletier/go-toml/blob/v2/CONTRIBUTING.md#code-changes
+
+-->
 
 Explanation of what this pull request does.
 
-More detailed description of the decisions being made and the reasons why (if the patch is non-trivial).
+More detailed description of the decisions being made and the reasons why (if
+the patch is non-trivial).
+
+---
+
+Paste `benchstat` results here

.github/dependabot.yml

@@ -1,6 +1,17 @@
 version: 2
 updates:
-  - package-ecosystem: "gomod"
+- package-ecosystem: gomod
-    directory: "/" # Location of package manifests
+  directory: /
-    schedule:
+  schedule:
-      interval: "daily"
+    interval: daily
+  open-pull-requests-limit: 10
+- package-ecosystem: github-actions
+  directory: /
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10
+- package-ecosystem: docker
+  directory: /
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10

.github/release.yml

@@ -0,0 +1,21 @@
+changelog:
+  exclude:
+    labels:
+      - build
+      - testing
+  categories:
+    - title: What's new
+      labels:
+        - feature
+    - title: Performance
+      labels:
+        - performance
+    - title: Fixed bugs
+      labels:
+        - bug
+    - title: Documentation
+      labels:
+        - doc
+    - title: Other changes
+      labels:
+        - "*"

.github/workflows/cifuzz.yml

@@ -0,0 +1,26 @@
+name: CIFuzz
+on: [pull_request]
+jobs:
+  Fuzzing:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Build Fuzzers
+      id: build
+      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'go-toml'
+        dry-run: false
+        language: go
+    - name: Run Fuzzers
+      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'go-toml'
+        fuzz-seconds: 300
+        dry-run: false
+        language: go
+    - name: Upload Crash
+      uses: actions/upload-artifact@v7
+      if: failure() && steps.build.outcome == 'success'
+      with:
+        name: artifacts
+        path: ./out/artifacts

.github/workflows/codeql-analysis.yml

@@ -35,11 +35,11 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v6
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v4
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -47,10 +47,10 @@ jobs:
         # Prefix the list here with "+" to use these queries and those in the config file.
         # queries: ./path/to/local/query, your-org/your-repo/queries@main
 
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # 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@v4
 
     # ℹ️ 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@v4

.github/workflows/coverage.yml

@@ -0,0 +1,20 @@
+name: coverage
+on:
+  pull_request:
+    branches:
+      - v2
+
+jobs:
+  report:
+    runs-on: "ubuntu-latest"
+    name: report
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: Setup go
+        uses: actions/setup-go@v6
+        with:
+          go-version: "1.26"
+      - name: Run tests with coverage
+        run: ./ci.sh coverage -d "${GITHUB_BASE_REF-HEAD}"

.github/workflows/go-versions-test.yml

@@ -0,0 +1,36 @@
+name: Go Versions Compatibility Test
+
+on:
+  workflow_dispatch:
+    inputs:
+      go_versions:
+        description: 'Go versions to test (space-separated, e.g., "1.21 1.22 1.23")'
+        required: false
+        default: ''
+        type: string
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
+
+      - name: Run Go versions compatibility test
+        run: |
+          VERSIONS="${{ github.event.inputs.go_versions }}"
+          ./test-go-versions.sh --output ./test-results $VERSIONS
+
+      - name: Upload test results
+        uses: actions/upload-artifact@v7
+        with:
+          name: go-versions-test-results
+          path: |
+            test-results/
+          retention-days: 30

.github/workflows/lint.yml

@@ -0,0 +1,22 @@
+name: lint
+on:
+  pull_request:
+    branches:
+      - v2
+
+jobs:
+  golangci:
+    name: lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: Setup go
+        uses: actions/setup-go@v6
+        with:
+          go-version: "1.26"
+      - name: Run golangci-lint
+        uses: golangci/golangci-lint-action@v9
+        with:
+          version: v2.8.0

.github/workflows/release.yml

@@ -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@v6
+        with:
+          fetch-depth: 0
+      - name: Set up Go
+        uses: actions/setup-go@v6
+        with:
+          go-version: "1.26"
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v4
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v7
+        with:
+          distribution: goreleaser
+          version: '~> v2'
+          args: release ${{ inputs.args }} --clean
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/workflow.yml

@@ -10,19 +10,24 @@ on:
 jobs:
   build:
     strategy:
+      fail-fast: false
       matrix:
-        os: [ 'ubuntu-latest', 'windows-latest', 'macos-latest']
+        os: [ 'ubuntu-latest', 'windows-latest', 'macos-latest', 'macos-14' ]
-        go: [ '1.15', '1.16' ]
+        go: [ '1.25', '1.26' ]
     runs-on: ${{ matrix.os }}
     name: ${{ matrix.go }}/${{ matrix.os }}
     steps:
-      - uses: actions/checkout@master
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
       - name: Setup go ${{ matrix.go }}
-        uses: actions/setup-go@master
+        uses: actions/setup-go@v6
         with:
           go-version: ${{ matrix.go }}
       - name: Run unit tests
         run: go test -race ./...
-      - name: Run benchmark tests
+  release-check:
-        run: go test -race ./...
+    if: ${{ github.ref != 'refs/heads/v2' }}
-        working-directory: benchmark
+    uses: ./.github/workflows/release.yml
+    with:
+      args: --snapshot

.gitignore

@@ -3,3 +3,6 @@ fuzz/
 cmd/tomll/tomll
 cmd/tomljson/tomljson
 cmd/tomltestgen/tomltestgen
+dist
+tests/
+test-results

.golangci.toml

@@ -1,81 +1,76 @@
-[service]
+version = "2"
-golangci-lint-version =  "1.39.0"
-
-[linters-settings.wsl]
-allow-assign-and-anything = true
 
 [linters]
-disable-all = true
+default = "none"
 enable = [
     "asciicheck",
     "bodyclose",
-    "cyclop",
-    "deadcode",
-    "depguard",
     "dogsled",
     "dupl",
     "durationcheck",
     "errcheck",
     "errorlint",
     "exhaustive",
-    "exhaustivestruct",
-    "exportloopref",
     "forbidigo",
-    "forcetypeassert",
-    "funlen",
-    "gci",
-    "gochecknoglobals",
     "gochecknoinits",
-    "gocognit",
     "goconst",
     "gocritic",
-    "gocyclo",
+    "godoclint",
-    "godot",
-    "godox",
-    "goerr113",
-    "gofmt",
-    "gofumpt",
     "goheader",
-    "goimports",
-    "golint",
-    "gomnd",
-    # "gomoddirectives",
     "gomodguard",
     "goprintffuncname",
     "gosec",
-    "gosimple",
     "govet",
-    "ifshort",
     "importas",
     "ineffassign",
     "lll",
     "makezero",
+    "mirror",
     "misspell",
     "nakedret",
-    "nestif",
     "nilerr",
-    "nlreturn",
     "noctx",
     "nolintlint",
-    "paralleltest",
+    "perfsprint",
     "prealloc",
     "predeclared",
     "revive",
     "rowserrcheck",
     "sqlclosecheck",
     "staticcheck",
-    "structcheck",
-    "stylecheck",
-    # "testpackage",
     "thelper",
     "tparallel",
-    "typecheck",
     "unconvert",
     "unparam",
     "unused",
-    "varcheck",
+    "usetesting",
     "wastedassign",
     "whitespace",
-    "wrapcheck",
+]
-    "wsl"
+
+[linters.settings.exhaustive]
+default-signifies-exhaustive = true
+
+[linters.settings.lll]
+line-length = 150
+
+[[linters.exclusions.rules]]
+path = ".test.go"
+linters = ["goconst", "gosec"]
+
+[[linters.exclusions.rules]]
+path = "main.go"
+linters = ["forbidigo"]
+
+[[linters.exclusions.rules]]
+path = "internal"
+linters = ["revive"]
+text = "(exported|indent-error-flow): "
+
+[formatters]
+enable = [
+    "gci",
+    "gofmt",
+    "gofumpt",
+    "goimports",
 ]

.goreleaser.yaml

@@ -0,0 +1,124 @@
+version: 2
+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
+      - linux_riscv64
+      - windows_amd64
+      - windows_arm64
+      - 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
+      - linux_riscv64
+      - windows_amd64
+      - windows_arm64
+      - 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_riscv64
+      - linux_arm
+      - windows_amd64
+      - windows_arm64
+      - 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:
+  version_template: "{{ incpatch .Version }}-next"
+release:
+  github:
+    owner: pelletier
+    name: go-toml
+  draft: true
+  prerelease: auto
+  mode: replace
+changelog:
+  use: github-native
+announce:
+  skip: true

AGENTS.md

@@ -0,0 +1,64 @@
+# Agent Guidelines for go-toml
+
+This file provides guidelines for AI agents contributing to go-toml. All agents must follow these rules derived from [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+## Project Overview
+
+go-toml is a TOML library for Go. The goal is to provide an easy-to-use and efficient TOML implementation that gets the job done without getting in the way.
+
+## Code Change Rules
+
+### Backward Compatibility
+
+- **No backward-incompatible changes** unless explicitly discussed and approved
+- Avoid breaking people's programs unless absolutely necessary
+
+### Testing Requirements
+
+- **All bug fixes must include regression tests**
+- **All new code must be tested**
+- Run tests before submitting: `go test -race ./...`
+- Test coverage must not decrease. Check with:
+  ```bash
+  go test -covermode=atomic -coverprofile=coverage.out
+  go tool cover -func=coverage.out
+  ```
+- All lines of code touched by changes should be covered by tests
+
+### Performance Requirements
+
+- go-toml aims to stay efficient; avoid performance regressions
+- Run benchmarks to verify: `go test ./... -bench=. -count=10`
+- Compare results using [benchstat](https://pkg.go.dev/golang.org/x/perf/cmd/benchstat)
+
+### Documentation
+
+- New features or feature extensions must include documentation
+- Documentation lives in [README.md](./README.md) and throughout source code
+
+### Code Style
+
+- Follow existing code format and structure
+- Code must pass `go fmt`
+- Code must pass linting with the same golangci-lint version as CI (see version in `.github/workflows/lint.yml`):
+  ```bash
+  # Install specific version (check lint.yml for current version)
+  curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/HEAD/install.sh | sh -s -- -b $(go env GOPATH)/bin <version>
+  # Run linter
+  golangci-lint run ./...
+  ```
+
+### Commit Messages
+
+- Commit messages must explain **why** the change is needed
+- Keep messages clear and informative even if details are in the PR description
+
+## Pull Request Checklist
+
+Before submitting:
+
+1. Tests pass (`go test -race ./...`)
+2. No backward-incompatible changes (unless discussed)
+3. Relevant documentation added/updated
+4. No performance regression (verify with benchmarks)
+5. Title is clear and understandable for changelog

CONTRIBUTING.md

@@ -1,74 +1,74 @@
-## Contributing
+# Contributing
 
 Thank you for your interest in go-toml! We appreciate you considering
 contributing to go-toml!
 
-The main goal is the project is to provide an easy-to-use TOML
+The main goal is the project is to provide an easy-to-use and efficient TOML
-implementation for Go that gets the job done and gets out of your way –
+implementation for Go that gets the job done and gets out of your way – dealing
-dealing with TOML is probably not the central piece of your project.
+with TOML is probably not the central piece of your project.
 
-As the single maintainer of go-toml, time is scarce. All help, big or
+As the single maintainer of go-toml, time is scarce. All help, big or small, is
-small, is more than welcomed!
+more than welcomed!
 
-### Ask questions
+## Ask questions
 
-Any question you may have, somebody else might have it too. Always feel
+Any question you may have, somebody else might have it too. Always feel free to
-free to ask them on the [issues tracker][issues-tracker].  We will try to
+ask them on the [discussion board][discussions]. We will try to answer them as
-answer them as clearly and quickly as possible, time permitting.
+clearly and quickly as possible, time permitting.
 
 Asking questions also helps us identify areas where the documentation needs
 improvement, or new features that weren't envisioned before. Sometimes, a
-seemingly innocent question leads to the fix of a bug. Don't hesitate and
+seemingly innocent question leads to the fix of a bug. Don't hesitate and ask
-ask away!
+away!
 
-### Improve the documentation
+[discussions]: https://github.com/pelletier/go-toml/discussions
 
-The best way to share your knowledge and experience with go-toml is to
+## Improve the documentation
-improve the documentation. Fix a typo, clarify an interface, add an
-example, anything goes!
 
-The documentation is present in the [README][readme] and thorough the
+The best way to share your knowledge and experience with go-toml is to improve
-source code. On release, it gets updated on [pkg.go.dev][pkg.go.dev]. To make a
+the documentation. Fix a typo, clarify an interface, add an example, anything
-change to the documentation, create a pull request with your proposed
+goes!
-changes. For simple changes like that, the easiest way to go is probably
-the "Fork this project and edit the file" button on Github, displayed at
-the top right of the file. Unless it's a trivial change (for example a
-typo), provide a little bit of context in your pull request description or
-commit message.
 
-### Report a bug
+The documentation is present in the [README][readme] and thorough the source
+code. On release, it gets updated on [pkg.go.dev][pkg.go.dev]. To make a change
+to the documentation, create a pull request with your proposed changes. For
+simple changes like that, the easiest way to go is probably the "Fork this
+project and edit the file" button on GitHub, displayed at the top right of the
+file. Unless it's a trivial change (for example a typo), provide a little bit of
+context in your pull request description or commit message.
 
-Found a bug! Sorry to hear that :(. Help us and other track them down and
+## Report a bug
-fix by reporting it. [File a new bug report][bug-report] on the [issues
-tracker][issues-tracker]. The template should provide enough guidance on
-what to include. When in doubt: add more details! By reducing ambiguity and
-providing more information, it decreases back and forth and saves everyone
-time.
 
-### Code changes
+Found a bug! Sorry to hear that :(. Help us and other track them down and fix by
+reporting it. [File a new bug report][bug-report] on the [issues
+tracker][issues-tracker]. The template should provide enough guidance on what to
+include. When in doubt: add more details! By reducing ambiguity and providing
+more information, it decreases back and forth and saves everyone time.
+
+## Code changes
 
 Want to contribute a patch? Very happy to hear that!
 
 First, some high-level rules:
 
-* A short proposal with some POC code is better than a lengthy piece of
+- A short proposal with some POC code is better than a lengthy piece of text
-  text with no code. Code speaks louder than words.
+  with no code. Code speaks louder than words. That being said, bigger changes
-* No backward-incompatible patch will be accepted unless discussed.
+  should probably start with a [discussion][discussions].
-  Sometimes it's hard, and Go's lack of versioning by default does not
+- No backward-incompatible patch will be accepted unless discussed. Sometimes
-  help, but we try not to break people's programs unless we absolutely have
+  it's hard, but we try not to break people's programs unless we absolutely have
   to.
-* If you are writing a new feature or extending an existing one, make sure
+- If you are writing a new feature or extending an existing one, make sure to
-  to write some documentation.
+  write some documentation.
-* Bug fixes need to be accompanied with regression tests.
+- Bug fixes need to be accompanied with regression tests.
-* New code needs to be tested.
+- New code needs to be tested.
-* Your commit messages need to explain why the change is needed, even if
+- Your commit messages need to explain why the change is needed, even if already
-  already included in the PR description.
+  included in the PR description.
 
-It does sound like a lot, but those best practices are here to save time
+It does sound like a lot, but those best practices are here to save time overall
-overall and continuously improve the quality of the project, which is
+and continuously improve the quality of the project, which is something everyone
-something everyone benefits from.
+benefits from.
 
-#### Get started
+### Get started
 
 The fairly standard code contribution process looks like that:
 
@@ -76,50 +76,153 @@ The fairly standard code contribution process looks like that:
 2. Make your changes, commit on any branch you like.
 3. [Open up a pull request][pull-request]
 4. Review, potential ask for changes.
-5. Merge. You're in!
+5. Merge.
 
 Feel free to ask for help! You can create draft pull requests to gather
 some early feedback!
 
-#### Run the tests
+### Run the tests
 
-You can run tests for go-toml using Go's test tool: `go test ./...`.
+You can run tests for go-toml using Go's test tool: `go test -race ./...`.
-When creating a pull requests, all tests will be ran on Linux on a few Go
-versions (Travis CI), and on Windows using the latest Go version
-(AppVeyor).
 
-#### Style
+During the pull request process, all tests will be ran on Linux, Windows, and
+MacOS on the last two versions of Go.
 
-Try to look around and follow the same format and structure as the rest of
+However, given GitHub's new policy to _not_ run Actions on pull requests until a
-the code. We enforce using `go fmt` on the whole code base.
+maintainer clicks on button, it is highly recommended that you run them locally
+as you make changes.
+
+### Test across Go versions
+
+The repository includes tooling to test go-toml across multiple Go versions
+(1.11 through 1.25) both locally and in GitHub Actions.
+
+#### Local testing with Docker
+
+Prerequisites: Docker installed and running, Bash shell, `rsync` command.
+
+```bash
+# Test all Go versions in parallel (default)
+./test-go-versions.sh
+
+# Test specific versions
+./test-go-versions.sh 1.21 1.22 1.23
+
+# Test sequentially (slower but uses less resources)
+./test-go-versions.sh --sequential
+
+# Verbose output with custom results directory
+./test-go-versions.sh --verbose --output ./my-results 1.24 1.25
+
+# Show all options
+./test-go-versions.sh --help
+```
+
+The script creates Docker containers for each Go version and runs the full test
+suite. Results are saved to a `test-results/` directory with individual logs and
+a comprehensive summary report.
+
+The script only exits with a non-zero status code if either of the two most
+recent Go versions fail.
+
+#### GitHub Actions testing (maintainers)
+
+1. Go to the **Actions** tab in the GitHub repository
+2. Select **"Go Versions Compatibility Test"** from the workflow list
+3. Click **"Run workflow"**
+4. Optionally customize:
+   - **Go versions**: Space-separated list (e.g., `1.21 1.22 1.23`)
+   - **Execution mode**: Parallel (faster) or sequential (more stable)
+
+### Check coverage
+
+We use `go tool cover` to compute test coverage. Most code editors have a way to
+run and display code coverage, but at the end of the day, we do this:
+
+```
+go test -covermode=atomic -coverprofile=coverage.out
+go tool cover -func=coverage.out
+```
+
+and verify that the overall percentage of tested code does not go down. This is
+a requirement. As a rule of thumb, all lines of code touched by your changes
+should be covered. On Unix you can use `./ci.sh coverage -d v2` to check if your
+code lowers the coverage.
+
+### Verify performance
+
+Go-toml aims to stay efficient. We rely on a set of scenarios executed with Go's
+builtin benchmark systems. Because of their noisy nature, containers provided by
+GitHub Actions cannot be reliably used for benchmarking. As a result, you are
+responsible for checking that your changes do not incur a performance penalty.
+You can run their following to execute benchmarks:
+
+```
+go test ./... -bench=. -count=10
+```
+
+Benchmark results should be compared against each other with
+[benchstat][benchstat]. Typical flow looks like this:
+
+1. On the `v2` branch, run `go test ./... -bench=. -count 10` and save output to
+   a file (for example `old.txt`).
+2. Make some code changes.
+3. Run `go test ....` again, and save the output to an other file (for example
+   `new.txt`).
+4. Run `benchstat old.txt new.txt` to check that time/op does not go up in any
+   test.
+
+On Unix you can use `./ci.sh benchmark -d v2` to verify how your code impacts
+performance.
+
+It is highly encouraged to add the benchstat results to your pull request
+description. Pull requests that lower performance will receive more scrutiny.
+
+[benchstat]: https://pkg.go.dev/golang.org/x/perf/cmd/benchstat
+
+### Style
+
+Try to look around and follow the same format and structure as the rest of the
+code. We enforce using `go fmt` on the whole code base.
 
 ---
 
-### Maintainers-only
+## Maintainers-only
 
-#### Merge pull request
+### Merge pull request
 
 Checklist:
 
-* Passing CI.
+- Passing CI.
-* Does not introduce backward-incompatible changes (unless discussed).
+- Does not introduce backward-incompatible changes (unless discussed).
-* Has relevant doc changes.
+- Has relevant doc changes.
-* Has relevant unit tests.
+- 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
    nice and clean.
 3. Make sure the commit title is clear and contains the PR number (#123).
 
-#### New release
+### New release
+
+1. Decide on the next version number. Use semver. Review commits since last
+   version to assess.
+2. Tag release. For example:
+   ```
+   git checkout v2
+   git pull
+   git tag v2.2.0
+   git push --tags
+   ```
+3. CI automatically builds a draft GitHub release. Review it and edit as
+   necessary. 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. Check "create discussion" box, in the "Releases" category.
+5. If new version is an alpha or beta only, check pre-release box.
 
-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].
 
 [issues-tracker]: https://github.com/pelletier/go-toml/issues
 [bug-report]: https://github.com/pelletier/go-toml/issues/new?template=bug_report.md
@@ -127,6 +230,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

Dockerfile

@@ -0,0 +1,5 @@
+FROM scratch
+ENV PATH "$PATH:/bin"
+COPY tomll /bin/tomll
+COPY tomljson /bin/tomljson
+COPY jsontoml /bin/jsontoml

LICENSE

@@ -1,6 +1,7 @@
 The MIT License (MIT)
 
-Copyright (c) 2013 - 2021 Thomas Pelletier, Eric Anderton
+go-toml v2
+Copyright (c) 2021 - 2023 Thomas Pelletier
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,57 +1,635 @@
-# go-toml V2
+# go-toml v2
 
-Development branch. Use at your own risk.
+Go library for the [TOML](https://toml.io/en/) format.
 
-[👉 Discussion on github](https://github.com/pelletier/go-toml/discussions/471).
+This library supports [TOML v1.0.0](https://toml.io/en/v1.0.0).
 
-* `toml.Unmarshal()` should work as well as v1.
+[🐞 Bug Reports](https://github.com/pelletier/go-toml/issues)
 
-## Must do
+[💬 Anything else](https://github.com/pelletier/go-toml/discussions)
 
-### Unmarshal
+## Documentation
 
-- [x] Unmarshal into maps.
+Full API, examples, and implementation notes are available in the Go
-- [x] Support Array Tables.
+documentation.
-- [x] Unmarshal into pointers.
-- [x] Support Date / times.
-- [x] Support struct tags annotations.
-- [x] Support Arrays.
-- [x] Support Unmarshaler interface.
-- [x] Original go-toml unmarshal tests pass.
-- [x] Benchmark!
-- [x] Abstract AST.
-- [x] Original go-toml testgen tests pass.
-- [x] Track file position (line, column) for errors.
-- [ ] Strict mode.
-- [ ] Document Unmarshal / Decode
 
-### Marshal
+[![Go Reference](https://pkg.go.dev/badge/github.com/pelletier/go-toml/v2.svg)](https://pkg.go.dev/github.com/pelletier/go-toml/v2)
 
-- [x] Minimal implementation
+## Import
-- [x] Multiline strings
-- [ ] Multiline arrays
-- [ ] `inline` tag for tables
-- [ ] Optional indentation
-- [ ] Option to pick default quotes
 
-### Document
+```go
+import "github.com/pelletier/go-toml/v2"
+```
 
-- [ ] Gather requirements and design API.
+See [Modules](#Modules).
 
-## Ideas
+## Features
 
-- [ ] Allow types to implement a `ASTUnmarshaler` interface to unmarshal
+### Stdlib behavior
-      straight from the AST?
-- [x] Rewrite AST to use a single array as storage instead of one allocation per
-      node.
-- [ ] Provide "minimal allocations" option that uses `unsafe` to reuse the input
-      byte array as storage for strings.
-- [x] Cache reflection operations per type.
-- [ ] Optimize tracker pass.
 
-## Differences with v1
+As much as possible, this library is designed to behave similarly as the
+standard library's `encoding/json`.
 
-* [unmarshal](https://github.com/pelletier/go-toml/discussions/488)
+### Performance
+
+While go-toml favors usability, it is written with performance in mind. Most
+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 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.DisallowUnknownFields
+
+### Contextualized errors
+
+When most decoding errors occur, go-toml returns [`DecodeError`][decode-err],
+which contains a human readable contextualized version of the error. For
+example:
+
+```
+1| [server]
+2| path = 100
+ |        ~~~ cannot decode TOML integer into struct field toml_test.Server.Path of type string
+3| port = 50
+```
+
+[decode-err]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#DecodeError
+
+### Local date and time support
+
+TOML supports native [local date/times][ldt]. It allows to represent a given
+date, time, or date-time without relation to a timezone or offset. To support
+this use-case, go-toml provides [`LocalDate`][tld], [`LocalTime`][tlt], and
+[`LocalDateTime`][tldt]. Those types can be transformed to and from `time.Time`,
+making them convenient yet unambiguous structures for their respective TOML
+representation.
+
+[ldt]: https://toml.io/en/v1.0.0#local-date-time
+[tld]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#LocalDate
+[tlt]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#LocalTime
+[tldt]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#LocalDateTime
+
+### Commented config
+
+Since TOML is often used for configuration files, go-toml can emit documents
+annotated with [comments and commented-out values][comments-example]. For
+example, it can generate the following file:
+
+```toml
+# Host IP to connect to.
+host = '127.0.0.1'
+# Port of the remote server.
+port = 4242
+
+# Encryption parameters (optional)
+# [TLS]
+# cipher = 'AEAD-AES128-GCM-SHA256'
+# version = 'TLS 1.3'
+```
+
+[comments-example]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#example-Marshal-Commented
+
+## Getting started
+
+Given the following struct, let's see how to read it and write it as TOML:
+
+```go
+type MyConfig struct {
+	Version int
+	Name    string
+	Tags    []string
+}
+```
+
+### Unmarshaling
+
+[`Unmarshal`][unmarshal] reads a TOML document and fills a Go structure with its
+content. 
+
+Note that the struct variable names are _capitalized_, while the variables in the toml document are _lowercase_.
+
+For example:
+
+```go
+doc := `
+version = 2
+name = "go-toml"
+tags = ["go", "toml"]
+`
+
+var cfg MyConfig
+err := toml.Unmarshal([]byte(doc), &cfg)
+if err != nil {
+	panic(err)
+}
+fmt.Println("version:", cfg.Version)
+fmt.Println("name:", cfg.Name)
+fmt.Println("tags:", cfg.Tags)
+
+// Output:
+// version: 2
+// name: go-toml
+// tags: [go toml]
+```
+
+[unmarshal]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#Unmarshal
+
+
+Here is an example using tables with some simple nesting:
+
+```go
+doc := `
+age = 45
+fruits = ["apple", "pear"]
+
+# these are very important!
+[my-variables]
+first = 1
+second = 0.2
+third = "abc"
+
+# this is not so important.
+[my-variables.b]
+bfirst = 123
+`
+
+var Document struct {
+	Age int
+	Fruits []string
+
+	Myvariables struct {
+		First  int
+		Second float64
+		Third  string
+
+		B struct {
+			Bfirst int
+		}
+	} `toml:"my-variables"`
+}
+
+err := toml.Unmarshal([]byte(doc), &Document)
+if err != nil {
+	panic(err)
+}
+
+fmt.Println("age:", Document.Age)
+fmt.Println("fruits:", Document.Fruits)
+fmt.Println("my-variables.first:", Document.Myvariables.First)
+fmt.Println("my-variables.second:", Document.Myvariables.Second)
+fmt.Println("my-variables.third:", Document.Myvariables.Third)
+fmt.Println("my-variables.B.Bfirst:", Document.Myvariables.B.Bfirst)
+
+// Output:
+// age: 45
+// fruits: [apple pear]
+// my-variables.first: 1
+// my-variables.second: 0.2
+// my-variables.third: abc
+// my-variables.B.Bfirst: 123
+```
+
+
+### Marshaling
+
+[`Marshal`][marshal] is the opposite of Unmarshal: it represents a Go structure
+as a TOML document:
+
+```go
+cfg := MyConfig{
+	Version: 2,
+	Name:    "go-toml",
+	Tags:    []string{"go", "toml"},
+}
+
+b, err := toml.Marshal(cfg)
+if err != nil {
+	panic(err)
+}
+fmt.Println(string(b))
+
+// Output:
+// Version = 2
+// Name = 'go-toml'
+// Tags = ['go', 'toml']
+```
+
+[marshal]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#Marshal
+
+## Unstable API
+
+This API does not yet follow the backward compatibility guarantees of this
+library. They provide early access to features that may have rough edges or an
+API subject to change.
+
+### Parser
+
+Parser is the unstable API that allows iterative parsing of a TOML document at
+the AST level. See https://pkg.go.dev/github.com/pelletier/go-toml/v2/unstable.
+
+## Benchmarks
+
+Execution time speedup compared to other Go TOML libraries:
+
+<table>
+    <thead>
+        <tr><th>Benchmark</th><th>go-toml v1</th><th>BurntSushi/toml</th></tr>
+    </thead>
+    <tbody>
+        <tr><td>Marshal/HugoFrontMatter-2</td><td>2.1x</td><td>2.0x</td></tr>
+        <tr><td>Marshal/ReferenceFile/map-2</td><td>2.0x</td><td>2.0x</td></tr>
+        <tr><td>Marshal/ReferenceFile/struct-2</td><td>2.3x</td><td>2.5x</td></tr>
+        <tr><td>Unmarshal/HugoFrontMatter-2</td><td>3.3x</td><td>2.8x</td></tr>
+        <tr><td>Unmarshal/ReferenceFile/map-2</td><td>2.9x</td><td>3.0x</td></tr>
+        <tr><td>Unmarshal/ReferenceFile/struct-2</td><td>4.8x</td><td>5.0x</td></tr>
+     </tbody>
+</table>
+<details><summary>See more</summary>
+<p>The table above has the results of the most common use-cases. The table below
+contains the results of all benchmarks, including unrealistic ones. It is
+provided for completeness.</p>
+
+<table>
+    <thead>
+        <tr><th>Benchmark</th><th>go-toml v1</th><th>BurntSushi/toml</th></tr>
+    </thead>
+    <tbody>
+        <tr><td>Marshal/SimpleDocument/map-2</td><td>2.0x</td><td>2.9x</td></tr>
+        <tr><td>Marshal/SimpleDocument/struct-2</td><td>2.5x</td><td>3.6x</td></tr>
+        <tr><td>Unmarshal/SimpleDocument/map-2</td><td>4.2x</td><td>3.4x</td></tr>
+        <tr><td>Unmarshal/SimpleDocument/struct-2</td><td>5.9x</td><td>4.4x</td></tr>
+        <tr><td>UnmarshalDataset/example-2</td><td>3.2x</td><td>2.9x</td></tr>
+        <tr><td>UnmarshalDataset/code-2</td><td>2.4x</td><td>2.8x</td></tr>
+        <tr><td>UnmarshalDataset/twitter-2</td><td>2.7x</td><td>2.5x</td></tr>
+        <tr><td>UnmarshalDataset/citm_catalog-2</td><td>2.3x</td><td>2.3x</td></tr>
+        <tr><td>UnmarshalDataset/canada-2</td><td>1.9x</td><td>1.5x</td></tr>
+        <tr><td>UnmarshalDataset/config-2</td><td>5.4x</td><td>3.0x</td></tr>
+        <tr><td>geomean</td><td>2.9x</td><td>2.8x</td></tr>
+     </tbody>
+</table>
+<p>This table can be generated with <code>./ci.sh benchmark -a -html</code>.</p>
+</details>
+
+## Modules
+
+go-toml uses Go's standard modules system.
+
+Installation instructions:
+
+- Go ≥ 1.16: Nothing to do. Use the import in your code. The `go` command deals
+  with it automatically.
+- Go ≥ 1.13: `GO111MODULE=on go get github.com/pelletier/go-toml/v2`.
+
+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 available 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
+how to get the original behavior when possible.
+
+### Decoding / Unmarshal
+
+#### Automatic field name guessing
+
+When unmarshaling to a struct, if a key in the TOML document does not exactly
+match the name of a struct field or any of the `toml`-tagged field, v1 tries
+multiple variations of the key ([code][v1-keys]).
+
+V2 instead does a case-insensitive matching, like `encoding/json`.
+
+This could impact you if you are relying on casing to differentiate two fields,
+and one of them is a not using the `toml` struct tag. The recommended solution
+is to be specific about tag names for those fields using the `toml` struct tag.
+
+[v1-keys]: https://github.com/pelletier/go-toml/blob/a2e52561804c6cd9392ebf0048ca64fe4af67a43/marshal.go#L775-L781
+
+#### Ignore preexisting value in interface
+
+When decoding into a non-nil `interface{}`, go-toml v1 uses the type of the
+element in the interface to decode the object. For example:
+
+```go
+type inner struct {
+	B interface{}
+}
+type doc struct {
+	A interface{}
+}
+
+d := doc{
+	A: inner{
+		B: "Before",
+	},
+}
+
+data := `
+[A]
+B = "After"
+`
+
+toml.Unmarshal([]byte(data), &d)
+fmt.Printf("toml v1: %#v\n", d)
+
+// toml v1: main.doc{A:main.inner{B:"After"}}
+```
+
+In this case, field `A` is of type `interface{}`, containing a `inner` struct.
+V1 sees that type and uses it when decoding the object.
+
+When decoding an object into an `interface{}`, V2 instead disregards whatever
+value the `interface{}` may contain and replaces it with a
+`map[string]interface{}`. With the same data structure as above, here is what
+the result looks like:
+
+```go
+toml.Unmarshal([]byte(data), &d)
+fmt.Printf("toml v2: %#v\n", d)
+
+// toml v2: main.doc{A:map[string]interface {}{"B":"After"}}
+```
+
+This is to match `encoding/json`'s behavior. There is no way to make the v2
+decoder behave like v1.
+
+#### Values out of array bounds ignored
+
+When decoding into an array, v1 returns an error when the number of elements
+contained in the doc is superior to the capacity of the array. For example:
+
+```go
+type doc struct {
+	A [2]string
+}
+d := doc{}
+err := toml.Unmarshal([]byte(`A = ["one", "two", "many"]`), &d)
+fmt.Println(err)
+
+// (1, 1): unmarshal: TOML array length (3) exceeds destination array length (2)
+```
+
+In the same situation, v2 ignores the last value:
+
+```go
+err := toml.Unmarshal([]byte(`A = ["one", "two", "many"]`), &d)
+fmt.Println("err:", err, "d:", d)
+// err: <nil> d: {[one two]}
+```
+
+This is to match `encoding/json`'s behavior. There is no way to make the v2
+decoder behave like v1.
+
+#### Support for `toml.Unmarshaler` has been dropped
+
+This method was not widely used, poorly defined, and added a lot of complexity.
+A similar effect can be achieved by implementing the `encoding.TextUnmarshaler`
+interface and use strings.
+
+#### Support for `default` struct tag has been dropped
+
+This feature adds complexity and a poorly defined API for an effect that can be
+accomplished outside of the library.
+
+It does not seem like other format parsers in Go support that feature (the
+project referenced in the original ticket #202 has not been updated since 2017).
+Given that go-toml v2 should not touch values not in the document, the same
+effect can be achieved by pre-filling the struct with defaults (libraries like
+[go-defaults][go-defaults] can help). Also, string representation is not well
+defined for all types: it creates issues like #278.
+
+The recommended replacement is pre-filling the struct before unmarshaling.
+
+[go-defaults]: https://github.com/mcuadros/go-defaults
+
+#### `toml.Tree` replacement
+
+This structure was the initial attempt at providing a document model for
+go-toml. It allows manipulating the structure of any document, encoding and
+decoding from their TOML representation. While a more robust feature was
+initially planned in go-toml v2, this has been ultimately [removed from
+scope][nodoc] of this library, with no plan to add it back at the moment. The
+closest equivalent at the moment would be to unmarshal into an `interface{}` and
+use type assertions and/or reflection to manipulate the arbitrary
+structure. However this would fall short of providing all of the TOML features
+such as adding comments and be specific about whitespace.
+
+
+#### `toml.Position` are not retrievable anymore
+
+The API for retrieving the position (line, column) of a specific TOML element do
+not exist anymore. This was done to minimize the amount of concepts introduced
+by the library (query path), and avoid the performance hit related to storing
+positions in the absence of a document model, for a feature that seemed to have
+little use. Errors however have gained more detailed position
+information. Position retrieval seems better fitted for a document model, which
+has been [removed from the scope][nodoc] of go-toml v2 at the moment.
+
+### Encoding / Marshal
+
+#### Default struct fields order
+
+V1 emits struct fields order alphabetically by default. V2 struct fields are
+emitted in order they are defined. For example:
+
+```go
+type S struct {
+	B string
+	A string
+}
+
+data := S{
+	B: "B",
+	A: "A",
+}
+
+b, _ := tomlv1.Marshal(data)
+fmt.Println("v1:\n" + string(b))
+
+b, _ = tomlv2.Marshal(data)
+fmt.Println("v2:\n" + string(b))
+
+// Output:
+// v1:
+// A = "A"
+// B = "B"
+
+// v2:
+// B = 'B'
+// A = 'A'
+```
+
+There is no way to make v2 encoder behave like v1. A workaround could be to
+manually sort the fields alphabetically in the struct definition, or generate
+struct types using `reflect.StructOf`.
+
+#### No indentation by default
+
+V1 automatically indents content of tables by default. V2 does not. However the
+same behavior can be obtained using [`Encoder.SetIndentTables`][sit]. For example:
+
+```go
+data := map[string]interface{}{
+	"table": map[string]string{
+		"key": "value",
+	},
+}
+
+b, _ := tomlv1.Marshal(data)
+fmt.Println("v1:\n" + string(b))
+
+b, _ = tomlv2.Marshal(data)
+fmt.Println("v2:\n" + string(b))
+
+buf := bytes.Buffer{}
+enc := tomlv2.NewEncoder(&buf)
+enc.SetIndentTables(true)
+enc.Encode(data)
+fmt.Println("v2 Encoder:\n" + string(buf.Bytes()))
+
+// Output:
+// v1:
+//
+// [table]
+//   key = "value"
+//
+// v2:
+// [table]
+// key = 'value'
+//
+//
+// v2 Encoder:
+// [table]
+//   key = 'value'
+```
+
+[sit]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#Encoder.SetIndentTables
+
+#### Keys and strings are single quoted
+
+V1 always uses double quotes (`"`) around strings and keys that cannot be
+represented bare (unquoted). V2 uses single quotes instead by default (`'`),
+unless a character cannot be represented, then falls back to double quotes. As a
+result of this change, `Encoder.QuoteMapKeys` has been removed, as it is not
+useful anymore.
+
+There is no way to make v2 encoder behave like v1.
+
+#### `TextMarshaler` emits as a string, not TOML
+
+Types that implement [`encoding.TextMarshaler`][tm] can emit arbitrary TOML in
+v1. The encoder would append the result to the output directly. In v2 the result
+is wrapped in a string. As a result, this interface cannot be implemented by the
+root object.
+
+There is no way to make v2 encoder behave like v1.
+
+[tm]: https://golang.org/pkg/encoding/#TextMarshaler
+
+#### `Encoder.CompactComments` has been removed
+
+Emitting compact comments is now the default behavior of go-toml. This option
+is not necessary anymore.
+
+#### Struct tags have been merged
+
+V1 used to provide multiple struct tags: `comment`, `commented`, `multiline`,
+`toml`, and `omitempty`. To behave more like the standard library, v2 has merged
+`toml`, `multiline`, `commented`, and `omitempty`. For example:
+
+```go
+type doc struct {
+	// v1
+	F string `toml:"field" multiline:"true" omitempty:"true" commented:"true"`
+	// v2
+	F string `toml:"field,multiline,omitempty,commented"`
+}
+```
+
+Has a result, the `Encoder.SetTag*` methods have been removed, as there is just
+one tag now.
+
+#### `Encoder.ArraysWithOneElementPerLine` has been renamed
+
+The new name is `Encoder.SetArraysMultiline`. The behavior should be the same.
+
+#### `Encoder.Indentation` has been renamed
+
+The new name is `Encoder.SetIndentSymbol`. The behavior should be the same.
+
+
+#### 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: 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
+
+Expect for parts explicitly marked otherwise, go-toml follows [Semantic
+Versioning](https://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
 

SECURITY.md

@@ -0,0 +1,16 @@
+# Security Policy
+
+## Supported Versions
+
+| Version    | Supported          |
+| ---------- | ------------------ |
+| Latest 2.x | :white_check_mark: |
+| All 1.x    | :x:                |
+| All 0.x    | :x:                |
+
+## Reporting a Vulnerability
+
+Email a vulnerability report to `security@pelletier.codes`. Make sure to include
+as many details as possible to reproduce the vulnerability. This is a
+side-project: I will try to get back to you as quickly as possible, time
+permitting in my personal life. Providing a working patch helps very much!

benchmark/bench_datasets_test.go

@@ -3,15 +3,16 @@ package benchmark_test
 import (
 	"compress/gzip"
 	"encoding/json"
-	"io/ioutil"
+	"io"
 	"os"
 	"path/filepath"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/pelletier/go-toml/v2"
+	"github.com/pelletier/go-toml/v2/internal/assert"
 )
 
-var bench_inputs = []struct {
+var benchInputs = []struct {
 	name    string
 	jsonLen int
 }{
@@ -29,66 +30,51 @@ var bench_inputs = []struct {
 }
 
 func TestUnmarshalDatasetCode(t *testing.T) {
-	for _, tc := range bench_inputs {
+	for _, tc := range benchInputs {
-		buf := fixture(t, tc.name)
 		t.Run(tc.name, func(t *testing.T) {
-			for _, r := range runners {
+			buf := fixture(t, tc.name)
-				if r.name == "bs" && tc.name == "canada" {
-					t.Skip("skipping: burntsushi can't handle mixed arrays")
-				}
 
-				t.Run(r.name, func(t *testing.T) {
+			var v interface{}
-					var v interface{}
+			assert.NoError(t, toml.Unmarshal(buf, &v))
-					check(t, r.unmarshal(buf, &v))
 
-					b, err := json.Marshal(v)
+			b, err := json.Marshal(v)
-					check(t, err)
+			assert.NoError(t, err)
-					require.Equal(t, len(b), tc.jsonLen)
+			assert.Equal(t, len(b), tc.jsonLen)
-				})
-			}
 		})
 	}
 }
 
 func BenchmarkUnmarshalDataset(b *testing.B) {
-	for _, tc := range bench_inputs {
+	for _, tc := range benchInputs {
-		buf := fixture(b, tc.name)
 		b.Run(tc.name, func(b *testing.B) {
-			bench(b, func(r runner, b *testing.B) {
+			buf := fixture(b, tc.name)
-				if r.name == "bs" && tc.name == "canada" {
+			b.SetBytes(int64(len(buf)))
-					b.Skip("skipping: burntsushi can't handle mixed arrays")
+			b.ReportAllocs()
-				}
+			b.ResetTimer()
-
+			for i := 0; i < b.N; i++ {
-				b.SetBytes(int64(len(buf)))
+				var v interface{}
-				b.ReportAllocs()
+				assert.NoError(b, toml.Unmarshal(buf, &v))
-				b.ResetTimer()
+			}
-				for i := 0; i < b.N; i++ {
-					var v interface{}
-					check(b, r.unmarshal(buf, &v))
-				}
-			})
 		})
 	}
 }
 
 // fixture returns the uncompressed contents of path.
 func fixture(tb testing.TB, path string) []byte {
-	f, err := os.Open(filepath.Join("testdata", path+".toml.gz"))
+	tb.Helper()
-	check(tb, err)
+
-	defer f.Close()
+	file := path + ".toml.gz"
+	f, err := os.Open(filepath.Join("testdata", file))
+	if os.IsNotExist(err) {
+		tb.Skip("benchmark fixture not found:", file)
+	}
+	assert.NoError(tb, err)
+	defer func() { _ = f.Close() }()
 
 	gz, err := gzip.NewReader(f)
-	check(tb, err)
+	assert.NoError(tb, err)
-
-	buf, err := ioutil.ReadAll(gz)
-	check(tb, err)
 
+	buf, err := io.ReadAll(gz)
+	assert.NoError(tb, err)
 	return buf
 }
-
-func check(tb testing.TB, err error) {
-	if err != nil {
-		tb.Helper()
-		tb.Fatal(err)
-	}
-}

benchmark/benchmark.toml

@@ -186,7 +186,7 @@ key3 = 1979-05-27T00:32:00.999999-07:00
 key1 = [ 1, 2, 3 ]
 key2 = [ "red", "yellow", "green" ]
 key3 = [ [ 1, 2 ], [3, 4, 5] ]
-#key4 = [ [ 1, 2 ], ["a", "b", "c"] ] # this is ok
+key4 = [ [ 1, 2 ], ["a", "b", "c"] ] # this is ok
 
 # Arrays can also be multiline. So in addition to ignoring whitespace, arrays
 # also ignore newlines between the brackets.  Terminating commas are ok before

benchmark/benchmark_test.go

@@ -1,50 +1,241 @@
 package benchmark_test
 
 import (
-	"io/ioutil"
+	"bytes"
+	"os"
 	"testing"
 	"time"
 
-	tomlbs "github.com/BurntSushi/toml"
-	tomlv1 "github.com/pelletier/go-toml-v1"
 	"github.com/pelletier/go-toml/v2"
-	"github.com/stretchr/testify/require"
+	"github.com/pelletier/go-toml/v2/internal/assert"
 )
 
-type runner struct {
+func TestUnmarshalSimple(t *testing.T) {
-	name      string
+	doc := []byte(`A = "hello"`)
-	unmarshal func([]byte, interface{}) error
+	d := struct {
-}
+		A string
+	}{}
 
-var runners = []runner{
+	err := toml.Unmarshal(doc, &d)
-	{"v2", toml.Unmarshal},
+	if err != nil {
-	{"v1", tomlv1.Unmarshal},
+		t.Error(err)
-	{"bs", tomlbs.Unmarshal},
-}
-
-func bench(b *testing.B, f func(r runner, b *testing.B)) {
-	for _, r := range runners {
-		b.Run(r.name, func(b *testing.B) {
-			f(r, b)
-		})
 	}
 }
 
-func BenchmarkUnmarshalSimple(b *testing.B) {
+func BenchmarkUnmarshal(b *testing.B) {
-	bench(b, func(r runner, b *testing.B) {
+	b.Run("SimpleDocument", func(b *testing.B) {
-		d := struct {
-			A string
-		}{}
 		doc := []byte(`A = "hello"`)
+
+		b.Run("struct", func(b *testing.B) {
+			b.SetBytes(int64(len(doc)))
+			b.ReportAllocs()
+			b.ResetTimer()
+
+			for i := 0; i < b.N; i++ {
+				d := struct {
+					A string
+				}{}
+
+				err := toml.Unmarshal(doc, &d)
+				if err != nil {
+					b.Error(err)
+				}
+			}
+		})
+
+		b.Run("map", func(b *testing.B) {
+			b.SetBytes(int64(len(doc)))
+			b.ReportAllocs()
+			b.ResetTimer()
+
+			for i := 0; i < b.N; i++ {
+				d := map[string]interface{}{}
+				err := toml.Unmarshal(doc, &d)
+				if err != nil {
+					b.Error(err)
+				}
+			}
+		})
+	})
+
+	b.Run("ReferenceFile", func(b *testing.B) {
+		bytes, err := os.ReadFile("benchmark.toml")
+		if err != nil {
+			b.Fatal(err)
+		}
+
+		b.Run("struct", func(b *testing.B) {
+			b.SetBytes(int64(len(bytes)))
+			b.ReportAllocs()
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				d := benchmarkDoc{}
+				err := toml.Unmarshal(bytes, &d)
+				if err != nil {
+					b.Error(err)
+				}
+			}
+		})
+
+		b.Run("map", func(b *testing.B) {
+			b.SetBytes(int64(len(bytes)))
+			b.ReportAllocs()
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				d := map[string]interface{}{}
+				err := toml.Unmarshal(bytes, &d)
+				if err != nil {
+					b.Error(err)
+				}
+			}
+		})
+	})
+
+	b.Run("HugoFrontMatter", func(b *testing.B) {
+		b.SetBytes(int64(len(hugoFrontMatterbytes)))
+		b.ReportAllocs()
+		b.ResetTimer()
 		for i := 0; i < b.N; i++ {
-			err := r.unmarshal(doc, &d)
+			d := map[string]interface{}{}
+			err := toml.Unmarshal(hugoFrontMatterbytes, &d)
 			if err != nil {
-				panic(err)
+				b.Error(err)
 			}
 		}
 	})
 }
 
+func marshal(v interface{}) ([]byte, error) {
+	var b bytes.Buffer
+	enc := toml.NewEncoder(&b)
+	err := enc.Encode(v)
+	return b.Bytes(), err
+}
+
+func BenchmarkMarshal(b *testing.B) {
+	b.Run("SimpleDocument", func(b *testing.B) {
+		doc := []byte(`A = "hello"`)
+
+		b.Run("struct", func(b *testing.B) {
+			d := struct {
+				A string
+			}{}
+
+			err := toml.Unmarshal(doc, &d)
+			if err != nil {
+				b.Error(err)
+			}
+
+			b.ReportAllocs()
+			b.ResetTimer()
+
+			var out []byte
+
+			for i := 0; i < b.N; i++ {
+				out, err = marshal(d)
+				if err != nil {
+					b.Error(err)
+				}
+			}
+
+			b.SetBytes(int64(len(out)))
+		})
+
+		b.Run("map", func(b *testing.B) {
+			d := map[string]interface{}{}
+			err := toml.Unmarshal(doc, &d)
+			if err != nil {
+				b.Error(err)
+			}
+
+			b.ReportAllocs()
+			b.ResetTimer()
+
+			var out []byte
+
+			for i := 0; i < b.N; i++ {
+				out, err = marshal(d)
+				if err != nil {
+					b.Error(err)
+				}
+			}
+
+			b.SetBytes(int64(len(out)))
+		})
+	})
+
+	b.Run("ReferenceFile", func(b *testing.B) {
+		bytes, err := os.ReadFile("benchmark.toml")
+		if err != nil {
+			b.Fatal(err)
+		}
+
+		b.Run("struct", func(b *testing.B) {
+			d := benchmarkDoc{}
+			err := toml.Unmarshal(bytes, &d)
+			if err != nil {
+				b.Error(err)
+			}
+			b.ReportAllocs()
+			b.ResetTimer()
+
+			var out []byte
+
+			for i := 0; i < b.N; i++ {
+				out, err = marshal(d)
+				if err != nil {
+					b.Error(err)
+				}
+			}
+
+			b.SetBytes(int64(len(out)))
+		})
+
+		b.Run("map", func(b *testing.B) {
+			d := map[string]interface{}{}
+			err := toml.Unmarshal(bytes, &d)
+			if err != nil {
+				b.Error(err)
+			}
+
+			b.ReportAllocs()
+			b.ResetTimer()
+
+			var out []byte
+			for i := 0; i < b.N; i++ {
+				out, err = marshal(d)
+				if err != nil {
+					b.Error(err)
+				}
+			}
+
+			b.SetBytes(int64(len(out)))
+		})
+	})
+
+	b.Run("HugoFrontMatter", func(b *testing.B) {
+		d := map[string]interface{}{}
+		err := toml.Unmarshal(hugoFrontMatterbytes, &d)
+		if err != nil {
+			b.Error(err)
+		}
+
+		b.ReportAllocs()
+		b.ResetTimer()
+
+		var out []byte
+
+		for i := 0; i < b.N; i++ {
+			out, err = marshal(d)
+			if err != nil {
+				b.Error(err)
+			}
+		}
+
+		b.SetBytes(int64(len(out)))
+	})
+}
+
 type benchmarkDoc struct {
 	Table struct {
 		Key      string
@@ -58,7 +249,7 @@ type benchmarkDoc struct {
 			}
 			Point struct {
 				X int64
-				U int64
+				Y int64
 			}
 		}
 	}
@@ -131,6 +322,7 @@ type benchmarkDoc struct {
 		Key2 []string
 		Key3 [][]int64
 		// TODO: Key4 not supported by go-toml's Unmarshal
+		Key4 []interface{}
 		Key5 []int64
 		Key6 []int64
 	}
@@ -142,38 +334,321 @@ type benchmarkDoc struct {
 	Fruit []struct {
 		Name     string
 		Physical struct {
-			Color   string
+			Color string
-			Shape   string
+			Shape string
-			Variety []struct {
+		}
-				Name string
+		Variety []struct {
-			}
+			Name string
 		}
 	}
 }
 
-func BenchmarkReferenceFile(b *testing.B) {
+func TestUnmarshalReferenceFile(t *testing.T) {
-	bench(b, func(r runner, b *testing.B) {
+	bytes, err := os.ReadFile("benchmark.toml")
-		bytes, err := ioutil.ReadFile("benchmark.toml")
+	assert.NoError(t, err)
-		if err != nil {
-			b.Fatal(err)
-		}
-		b.SetBytes(int64(len(bytes)))
-		b.ReportAllocs()
-		b.ResetTimer()
-		for i := 0; i < b.N; i++ {
-			d := benchmarkDoc{}
-			err := r.unmarshal(bytes, &d)
-			if err != nil {
-				panic(err)
-			}
-		}
-	})
-}
-
-func TestReferenceFile(t *testing.T) {
-	bytes, err := ioutil.ReadFile("benchmark.toml")
-	require.NoError(t, err)
 	d := benchmarkDoc{}
 	err = toml.Unmarshal(bytes, &d)
-	require.NoError(t, err)
+	assert.NoError(t, err)
+
+	expected := benchmarkDoc{
+		Table: struct {
+			Key      string
+			Subtable struct{ Key string }
+			Inline   struct {
+				Name struct {
+					First string
+					Last  string
+				}
+				Point struct {
+					X int64
+					Y int64
+				}
+			}
+		}{
+			Key: "value",
+			Subtable: struct{ Key string }{
+				Key: "another value",
+			},
+			// note: x.y.z.w is purposefully missing
+			Inline: struct {
+				Name struct {
+					First string
+					Last  string
+				}
+				Point struct {
+					X int64
+					Y int64
+				}
+			}{
+				Name: struct {
+					First string
+					Last  string
+				}{
+					First: "Tom",
+					Last:  "Preston-Werner",
+				},
+				Point: struct {
+					X int64
+					Y int64
+				}{
+					X: 1,
+					Y: 2,
+				},
+			},
+		},
+		String: struct {
+			Basic     struct{ Basic string }
+			Multiline struct {
+				Key1      string
+				Key2      string
+				Key3      string
+				Continued struct {
+					Key1 string
+					Key2 string
+					Key3 string
+				}
+			}
+			Literal struct {
+				Winpath   string
+				Winpath2  string
+				Quoted    string
+				Regex     string
+				Multiline struct {
+					Regex2 string
+					Lines  string
+				}
+			}
+		}{
+			Basic: struct{ Basic string }{
+				Basic: "I'm a string. \"You can quote me\". Name\tJos\u00E9\nLocation\tSF.",
+			},
+			Multiline: struct {
+				Key1      string
+				Key2      string
+				Key3      string
+				Continued struct {
+					Key1 string
+					Key2 string
+					Key3 string
+				}
+			}{
+				Key1: "One\nTwo",
+				Key2: "One\nTwo",
+				Key3: "One\nTwo",
+
+				Continued: struct {
+					Key1 string
+					Key2 string
+					Key3 string
+				}{
+					Key1: `The quick brown fox jumps over the lazy dog.`,
+					Key2: `The quick brown fox jumps over the lazy dog.`,
+					Key3: `The quick brown fox jumps over the lazy dog.`,
+				},
+			},
+			Literal: struct {
+				Winpath   string
+				Winpath2  string
+				Quoted    string
+				Regex     string
+				Multiline struct {
+					Regex2 string
+					Lines  string
+				}
+			}{
+				Winpath:  `C:\Users\nodejs\templates`,
+				Winpath2: `\\ServerX\admin$\system32\`,
+				Quoted:   `Tom "Dubs" Preston-Werner`,
+				Regex:    `<\i\c*\s*>`,
+
+				Multiline: struct {
+					Regex2 string
+					Lines  string
+				}{
+					Regex2: `I [dw]on't need \d{2} apples`,
+					Lines: `The first newline is
+trimmed in raw strings.
+   All other whitespace
+   is preserved.
+`,
+				},
+			},
+		},
+		Integer: struct {
+			Key1        int64
+			Key2        int64
+			Key3        int64
+			Key4        int64
+			Underscores struct {
+				Key1 int64
+				Key2 int64
+				Key3 int64
+			}
+		}{
+			Key1: 99,
+			Key2: 42,
+			Key3: 0,
+			Key4: -17,
+
+			Underscores: struct {
+				Key1 int64
+				Key2 int64
+				Key3 int64
+			}{
+				Key1: 1000,
+				Key2: 5349221,
+				Key3: 12345,
+			},
+		},
+		Float: struct {
+			Fractional struct {
+				Key1 float64
+				Key2 float64
+				Key3 float64
+			}
+			Exponent struct {
+				Key1 float64
+				Key2 float64
+				Key3 float64
+			}
+			Both        struct{ Key float64 }
+			Underscores struct {
+				Key1 float64
+				Key2 float64
+			}
+		}{
+			Fractional: struct {
+				Key1 float64
+				Key2 float64
+				Key3 float64
+			}{
+				Key1: 1.0,
+				Key2: 3.1415,
+				Key3: -0.01,
+			},
+			Exponent: struct {
+				Key1 float64
+				Key2 float64
+				Key3 float64
+			}{
+				Key1: 5e+22,
+				Key2: 1e6,
+				Key3: -2e-2,
+			},
+			Both: struct{ Key float64 }{
+				Key: 6.626e-34,
+			},
+			Underscores: struct {
+				Key1 float64
+				Key2 float64
+			}{
+				Key1: 9224617.445991228313,
+				Key2: 1e100,
+			},
+		},
+		Boolean: struct {
+			True  bool
+			False bool
+		}{
+			True:  true,
+			False: false,
+		},
+		Datetime: struct {
+			Key1 time.Time
+			Key2 time.Time
+			Key3 time.Time
+		}{
+			Key1: time.Date(1979, 5, 27, 7, 32, 0, 0, time.UTC),
+			Key2: time.Date(1979, 5, 27, 0, 32, 0, 0, time.FixedZone("", -7*3600)),
+			Key3: time.Date(1979, 5, 27, 0, 32, 0, 999999000, time.FixedZone("", -7*3600)),
+		},
+		Array: struct {
+			Key1 []int64
+			Key2 []string
+			Key3 [][]int64
+			Key4 []interface{}
+			Key5 []int64
+			Key6 []int64
+		}{
+			Key1: []int64{1, 2, 3},
+			Key2: []string{"red", "yellow", "green"},
+			Key3: [][]int64{{1, 2}, {3, 4, 5}},
+			Key4: []interface{}{
+				[]interface{}{int64(1), int64(2)},
+				[]interface{}{"a", "b", "c"},
+			},
+			Key5: []int64{1, 2, 3},
+			Key6: []int64{1, 2},
+		},
+		Products: []struct {
+			Name  string
+			Sku   int64
+			Color string
+		}{
+			{
+				Name: "Hammer",
+				Sku:  738594937,
+			},
+			{},
+			{
+				Name:  "Nail",
+				Sku:   284758393,
+				Color: "gray",
+			},
+		},
+		Fruit: []struct {
+			Name     string
+			Physical struct {
+				Color string
+				Shape string
+			}
+			Variety []struct{ Name string }
+		}{
+			{
+				Name: "apple",
+				Physical: struct {
+					Color string
+					Shape string
+				}{
+					Color: "red",
+					Shape: "round",
+				},
+				Variety: []struct{ Name string }{
+					{Name: "red delicious"},
+					{Name: "granny smith"},
+				},
+			},
+			{
+				Name: "banana",
+				Variety: []struct{ Name string }{
+					{Name: "plantain"},
+				},
+			},
+		},
+	}
+
+	assert.Equal(t, expected, d)
 }
+
+var hugoFrontMatterbytes = []byte(`
+categories = ["Development", "VIM"]
+date = "2012-04-06"
+description = "spf13-vim is a cross platform distribution of vim plugins and resources for Vim."
+slug = "spf13-vim-3-0-release-and-new-website"
+tags = [".vimrc", "plugins", "spf13-vim", "vim"]
+title = "spf13-vim 3.0 release and new website"
+include_toc = true
+show_comments = false
+
+[[cascade]]
+  background = "yosemite.jpg"
+  [cascade._target]
+    kind = "page"
+    lang = "en"
+    path = "/blog/**"
+
+[[cascade]]
+  background = "goldenbridge.jpg"
+  [cascade._target]
+    kind = "section"
+`)

benchmark/go.mod

@@ -1,14 +0,0 @@
-module github.com/pelletier/go-toml/v2/benchmark
-
-go 1.16
-
-replace github.com/pelletier/go-toml/v2 => ../
-
-replace github.com/pelletier/go-toml-v1 => github.com/pelletier/go-toml v1.8.1
-
-require (
-	github.com/BurntSushi/toml v0.3.1
-	github.com/pelletier/go-toml-v1 v0.0.0-00010101000000-000000000000
-	github.com/pelletier/go-toml/v2 v2.0.0-00010101000000-000000000000
-	github.com/stretchr/testify v1.7.0
-)

benchmark/go.sum

@@ -1,16 +0,0 @@
-github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-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/pelletier/go-toml v1.8.1 h1:1Nf83orprkJyknT6h7zbuEGUEjcyVlCxSUGTENmNCRM=
-github.com/pelletier/go-toml v1.8.1/go.mod h1:T2/BmBdy8dvIRq1a/8aqjN41wvWlN4lrapLU/GW4pbc=
-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.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-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=

ci.sh

@@ -0,0 +1,289 @@
+#!/usr/bin/env bash
+
+
+stderr() {
+    echo "$@" 1>&2
+}
+
+usage() {
+    b=$(basename "$0")
+    echo $b: ERROR: "$@" 1>&2
+
+    cat 1>&2 <<EOF
+
+DESCRIPTION
+
+    $(basename "$0") is the script to run continuous integration commands for
+    go-toml on unix.
+
+    Requires Go and Git to be available in the PATH. Expects to be ran from the
+    root of go-toml's Git repository.
+
+USAGE
+
+    $b COMMAND [OPTIONS...]
+
+COMMANDS
+
+benchmark [OPTIONS...] [BRANCH]
+
+    Run benchmarks.
+
+    ARGUMENTS
+
+        BRANCH Optional. Defines which Git branch to use when running
+               benchmarks.
+
+    OPTIONS
+
+        -d      Compare benchmarks of HEAD with BRANCH using benchstats. In
+                this form the BRANCH argument is required.
+
+        -a      Compare benchmarks of HEAD against go-toml v1 and
+                BurntSushi/toml.
+
+        -html   When used with -a, emits the output as HTML, ready to be
+                embedded in the README.
+
+coverage [OPTIONS...] [BRANCH]
+
+    Generates code coverage.
+
+    ARGUMENTS
+
+        BRANCH  Optional. Defines which Git branch to use when reporting
+                coverage. Defaults to HEAD.
+
+    OPTIONS
+
+        -d      Compare coverage of HEAD with the one of BRANCH. In this form,
+                the BRANCH argument is required. Exit code is non-zero when
+                coverage percentage decreased.
+EOF
+    exit 1
+}
+
+cover() {
+    branch="${1}"
+    dir="$(mktemp -d)"
+
+    stderr "Executing coverage for ${branch} at ${dir}"
+
+    if [ "${branch}" = "HEAD" ]; then
+	    cp -r . "${dir}/"
+    else
+	    git worktree add "$dir" "$branch"
+    fi
+
+    pushd "$dir"
+    go test -covermode=atomic  -coverpkg=./... -coverprofile=coverage.out.tmp ./...
+    grep -Ev '(fuzz|testsuite|tomltestgen|gotoml-test-decoder|gotoml-test-encoder)' coverage.out.tmp > coverage.out
+    go tool cover -func=coverage.out
+    echo "Coverage profile for ${branch}: ${dir}/coverage.out" >&2
+    popd
+
+    if [ "${branch}" != "HEAD" ]; then
+	    git worktree remove --force "$dir"
+    fi
+}
+
+coverage() {
+    case "$1" in
+	-d)
+	    shift
+	    target="${1?Need to provide a target branch argument}"
+
+	    output_dir="$(mktemp -d)"
+	    target_out="${output_dir}/target.txt"
+	    head_out="${output_dir}/head.txt"
+	    
+	    cover "${target}" > "${target_out}"
+	    cover "HEAD" > "${head_out}"
+
+	    cat "${target_out}"
+	    cat "${head_out}"
+
+	    echo ""
+
+	    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!";
+
+            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
+	    ;;
+    esac
+
+    cover "${1-HEAD}"
+}
+
+bench() {
+    branch="${1}"
+    out="${2}"
+    replace="${3}"
+    dir="$(mktemp -d)"
+
+    stderr "Executing benchmark for ${branch} at ${dir}"
+
+    if [ "${branch}" = "HEAD" ]; then
+    	cp -r . "${dir}/"
+    else
+	    git worktree add "$dir" "$branch"
+    fi
+
+    pushd "$dir"
+
+    if [ "${replace}" != "" ]; then
+        find ./benchmark/ -iname '*.go' -exec sed -i -E "s|github.com/pelletier/go-toml/v2\"|${replace}\"|g" {} \;
+        go get "${replace}"
+    fi
+
+    export GOMAXPROCS=2
+    go test '-bench=^Benchmark(Un)?[mM]arshal' -count=10 -run=Nothing ./... | tee "${out}"
+    popd
+
+    if [ "${branch}" != "HEAD" ]; then
+	    git worktree remove --force "$dir"
+    fi
+}
+
+fmktemp() {
+    if mktemp --version &> /dev/null; then
+	# GNU
+        mktemp --suffix=-$1
+    else
+	# BSD
+	mktemp -t $1
+    fi
+}
+
+benchstathtml() {
+python3 - $1 <<'EOF'
+import sys
+
+lines = []
+stop = False
+
+with open(sys.argv[1]) as f:
+    for line in f.readlines():
+        line = line.strip()
+        if line == "":
+            stop = True
+        if not stop:
+            lines.append(line.split(','))
+
+results = []
+for line in reversed(lines[2:]):
+    if len(line) < 8 or line[0] == "":
+        continue
+    v2 = float(line[1])
+    results.append([
+        line[0].replace("-32", ""),
+        "%.1fx" % (float(line[3])/v2),  # v1
+        "%.1fx" % (float(line[7])/v2),  # bs
+    ])
+
+if not results:
+    print("No benchmark results to display.", file=sys.stderr)
+    sys.exit(1)
+
+# move geomean to the end
+results.append(results[0])
+del results[0]
+
+
+def printtable(data):
+    print("""
+<table>
+    <thead>
+        <tr><th>Benchmark</th><th>go-toml v1</th><th>BurntSushi/toml</th></tr>
+    </thead>
+    <tbody>""")
+
+    for r in data:
+        print("        <tr><td>{}</td><td>{}</td><td>{}</td></tr>".format(*r))
+
+    print("""     </tbody>
+</table>""")
+
+
+def match(x):
+    return "ReferenceFile" in x[0] or "HugoFrontMatter" in x[0]
+
+above = [x for x in results if match(x)]
+below = [x for x in results if not match(x)]
+
+printtable(above)
+print("<details><summary>See more</summary>")
+print("""<p>The table above has the results of the most common use-cases. The table below
+contains the results of all benchmarks, including unrealistic ones. It is
+provided for completeness.</p>""")
+printtable(below)
+print('<p>This table can be generated with <code>./ci.sh benchmark -a -html</code>.</p>')
+print("</details>")
+
+EOF
+}
+
+benchmark() {
+    case "$1" in
+    -d)
+        shift
+     	target="${1?Need to provide a target branch argument}"
+
+        old=`fmktemp ${target}`
+        bench "${target}" "${old}"
+
+        new=`fmktemp HEAD`
+        bench HEAD "${new}"
+
+        benchstat "${old}" "${new}"
+        return 0
+        ;;
+    -a)
+        shift
+
+        v2stats=`fmktemp go-toml-v2`
+        bench HEAD "${v2stats}" "github.com/pelletier/go-toml/v2"
+        v1stats=`fmktemp go-toml-v1`
+        bench HEAD "${v1stats}" "github.com/pelletier/go-toml"
+        bsstats=`fmktemp bs-toml`
+        bench HEAD "${bsstats}" "github.com/BurntSushi/toml"
+
+        cp "${v2stats}" go-toml-v2.txt
+        cp "${v1stats}" go-toml-v1.txt
+        cp "${bsstats}" bs-toml.txt
+
+        if [ "$1" = "-html" ]; then
+            tmpcsv=`fmktemp csv`
+            benchstat -format csv go-toml-v2.txt go-toml-v1.txt bs-toml.txt > $tmpcsv
+            benchstathtml $tmpcsv
+        else
+            benchstat go-toml-v2.txt go-toml-v1.txt bs-toml.txt
+        fi
+
+        rm -f go-toml-v2.txt go-toml-v1.txt bs-toml.txt
+        return $?
+    esac
+
+    bench "${1-HEAD}" `mktemp`
+}
+
+case "$1" in
+    coverage) shift; coverage $@;;
+    benchmark) shift; benchmark $@;;
+    *) usage "bad argument $1";;
+esac

cmd/gotoml-test-decoder/main.go

@@ -0,0 +1,31 @@
+// Package gotoml-test-decoder is a minimal decoder program used to compare this library with other TOML implementations.
+package main
+
+import (
+	"flag"
+	"log"
+	"os"
+	"path"
+
+	"github.com/pelletier/go-toml/v2/internal/testsuite"
+)
+
+func main() {
+	log.SetFlags(0)
+	flag.Usage = usage
+	flag.Parse()
+	if flag.NArg() != 0 {
+		flag.Usage()
+	}
+
+	err := testsuite.DecodeStdin()
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func usage() {
+	log.Printf("Usage: %s < toml-file\n", path.Base(os.Args[0]))
+	flag.PrintDefaults()
+	os.Exit(1)
+}

cmd/gotoml-test-encoder/main.go

@@ -0,0 +1,31 @@
+// Package gotoml-test-encoder is a minimal encoder program used to compare this library with other TOML implementations.
+package main
+
+import (
+	"flag"
+	"log"
+	"os"
+	"path"
+
+	"github.com/pelletier/go-toml/v2/internal/testsuite"
+)
+
+func main() {
+	log.SetFlags(0)
+	flag.Usage = usage
+	flag.Parse()
+	if flag.NArg() != 0 {
+		flag.Usage()
+	}
+
+	err := testsuite.EncodeStdin()
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func usage() {
+	log.Printf("Usage: %s < json-file\n", path.Base(os.Args[0]))
+	flag.PrintDefaults()
+	os.Exit(1)
+}

cmd/jsontoml/main.go

@@ -0,0 +1,66 @@
+// 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"
+	"flag"
+	"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
+`
+
+var useJSONNumber bool
+
+func main() {
+	flag.BoolVar(&useJSONNumber, "use-json-number", false, "unmarshal numbers into `json.Number` type instead of as `float64`")
+
+	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)
+	e := toml.NewEncoder(w)
+
+	if useJSONNumber {
+		d.UseNumber()
+		e.SetMarshalJSONNumbers(true)
+	}
+
+	err := d.Decode(&v)
+	if err != nil {
+		return err
+	}
+
+	return e.Encode(v)
+}

cmd/jsontoml/main_test.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/pelletier/go-toml/v2/internal/assert"
+)
+
+func TestConvert(t *testing.T) {
+	examples := []struct {
+		name          string
+		input         string
+		expected      string
+		errors        bool
+		useJSONNumber bool
+	}{
+		{
+			name: "valid json",
+			input: `
+{
+  "mytoml": {
+    "a": 42
+  }
+}`,
+			expected: `[mytoml]
+a = 42.0
+`,
+		},
+		{
+			name:          "use json number",
+			useJSONNumber: true,
+			input: `
+{
+  "mytoml": {
+    "a": 42
+  }
+}`,
+			expected: `[mytoml]
+a = 42
+`,
+		},
+		{
+			name:   "invalid json",
+			input:  `{ foo`,
+			errors: true,
+		},
+	}
+
+	for _, e := range examples {
+		b := new(bytes.Buffer)
+		useJSONNumber = e.useJSONNumber
+		err := convert(strings.NewReader(e.input), b)
+		if e.errors {
+			assert.Error(t, err)
+		} else {
+			assert.NoError(t, err)
+			assert.Equal(t, e.expected, b.String())
+		}
+	}
+}

cmd/tomljson/main.go

@@ -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)
+}

cmd/tomljson/main_test.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"strings"
+	"testing"
+
+	"github.com/pelletier/go-toml/v2/internal/assert"
+)
+
+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 {
+			assert.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, errors.New("reader failed on purpose")
+}

cmd/tomll/main.go

@@ -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)
+}

cmd/tomll/main_test.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/pelletier/go-toml/v2/internal/assert"
+)
+
+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 {
+			assert.Error(t, err)
+		} else {
+			assert.NoError(t, err)
+			assert.Equal(t, e.expected, b.String())
+		}
+	}
+}

cmd/tomltestgen/main.go

@@ -0,0 +1,183 @@
+// tomltestgen retrieves a given version of the language-agnostic TOML test suite in
+// https://github.com/BurntSushi/toml-test and generates go-toml unit tests.
+//
+// Within the go-toml package, run `go generate`.  Otherwise, use:
+//
+//	go run github.com/pelletier/go-toml/cmd/tomltestgen -o toml_testgen_test.go
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"log"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"text/template"
+	"time"
+	"unicode"
+)
+
+type invalid struct {
+	Name  string
+	Input string
+}
+
+type valid struct {
+	Name    string
+	Input   string
+	JSONRef string
+}
+
+type testsCollection struct {
+	Ref       string
+	Timestamp string
+	Invalid   []invalid
+	Valid     []valid
+	Count     int
+}
+
+const srcTemplate = "// Code generated by tomltestgen for toml-test ref {{.Ref}} on {{.Timestamp}}. DO NOT EDIT.\n" +
+	"package toml_test\n" +
+	" import (\n" +
+	"	\"testing\"\n" +
+	")\n" +
+	"{{range .Invalid}}\n" +
+	"func TestTOMLTest_Invalid_{{.Name}}(t *testing.T) {\n" +
+	"	input := {{.Input|gostr}}\n" +
+	"	testgenInvalid(t, input)\n" +
+	"}\n" +
+	"{{end}}\n" +
+	"\n" +
+	"{{range .Valid}}\n" +
+	"func TestTOMLTest_Valid_{{.Name}}(t *testing.T) {\n" +
+	"   input := {{.Input|gostr}}\n" +
+	"   jsonRef := {{.JSONRef|gostr}}\n" +
+	"   testgenValid(t, input, jsonRef)\n" +
+	"}\n" +
+	"{{end}}\n"
+
+func kebabToCamel(kebab string) string {
+	var buf strings.Builder
+	nextUpper := true
+	for _, c := range kebab {
+		if nextUpper {
+			buf.WriteRune(unicode.ToUpper(c))
+			nextUpper = false
+		} else {
+			switch c {
+			case '-':
+				nextUpper = true
+			case '/':
+				nextUpper = true
+				buf.WriteByte('_')
+			default:
+				buf.WriteRune(c)
+			}
+		}
+	}
+	return buf.String()
+}
+
+func templateGoStr(input string) string {
+	return strconv.Quote(input)
+}
+
+var (
+	ref = flag.String("r", "master", "git reference")
+	out = flag.String("o", "", "output file")
+)
+
+func usage() {
+	_, _ = fmt.Fprintf(os.Stderr, "usage: tomltestgen [flags]\n")
+	flag.PrintDefaults()
+}
+
+func main() {
+	flag.Usage = usage
+	flag.Parse()
+
+	collection := testsCollection{
+		Ref:       *ref,
+		Timestamp: time.Now().Format(time.RFC3339),
+	}
+
+	dirContent, _ := filepath.Glob("tests/invalid/**/*.toml")
+	for _, f := range dirContent {
+		filename := strings.TrimPrefix(f, "tests/valid/")
+		name := kebabToCamel(strings.TrimSuffix(filename, ".toml"))
+		name = strings.ReplaceAll(name, ".", "_")
+
+		log.Printf("> [%s] %s\n", "invalid", name)
+
+		tomlContent, err := os.ReadFile(f) // #nosec G304
+		if err != nil {
+			fmt.Printf("failed to read test file: %s\n", err)
+			os.Exit(1)
+		}
+
+		collection.Invalid = append(collection.Invalid, invalid{
+			Name:  name,
+			Input: string(tomlContent),
+		})
+		collection.Count++
+	}
+
+	dirContent, _ = filepath.Glob("tests/valid/**/*.toml")
+	for _, f := range dirContent {
+		filename := strings.TrimPrefix(f, "tests/valid/")
+		name := kebabToCamel(strings.TrimSuffix(filename, ".toml"))
+		name = strings.ReplaceAll(name, ".", "_")
+
+		log.Printf("> [%s] %s\n", "valid", name)
+
+		tomlContent, err := os.ReadFile(f) // #nosec G304
+		if err != nil {
+			fmt.Printf("failed reading test file: %s\n", err)
+			os.Exit(1)
+		}
+
+		filename = strings.TrimSuffix(f, ".toml")
+		jsonContent, err := os.ReadFile(filename + ".json") // #nosec G304
+		if err != nil {
+			fmt.Printf("failed reading validation json: %s\n", err)
+			os.Exit(1)
+		}
+
+		collection.Valid = append(collection.Valid, valid{
+			Name:    name,
+			Input:   string(tomlContent),
+			JSONRef: string(jsonContent),
+		})
+		collection.Count++
+	}
+
+	log.Printf("Collected %d tests from toml-test\n", collection.Count)
+
+	funcMap := template.FuncMap{
+		"gostr": templateGoStr,
+	}
+	t := template.Must(template.New("src").Funcs(funcMap).Parse(srcTemplate))
+	buf := new(bytes.Buffer)
+	err := t.Execute(buf, collection)
+	if err != nil {
+		panic(err)
+	}
+	outputBytes, err := format.Source(buf.Bytes())
+	if err != nil {
+		panic(err)
+	}
+
+	if *out == "" {
+		fmt.Println(string(outputBytes))
+		return
+	}
+
+	err = os.WriteFile(*out, outputBytes, 0o600)
+	if err != nil {
+		panic(err)
+	}
+}

decode.go

@@ -1,12 +1,12 @@
 package toml
 
 import (
-	"errors"
 	"fmt"
 	"math"
 	"strconv"
-	"strings"
 	"time"
+
+	"github.com/pelletier/go-toml/v2/unstable"
 )
 
 func parseInteger(b []byte) (int64, error) {
@@ -19,7 +19,7 @@ func parseInteger(b []byte) (int64, error) {
 		case 'o':
 			return parseIntOct(b)
 		default:
-			return 0, newDecodeError(b[1:2], "invalid base: '%c'", b[1])
+			panic(fmt.Errorf("invalid base '%c', should have been checked by scanIntOrFloat", b[1]))
 		}
 	}
 
@@ -34,41 +34,40 @@ func parseLocalDate(b []byte) (LocalDate, error) {
 	var date LocalDate
 
 	if len(b) != 10 || b[4] != '-' || b[7] != '-' {
-		return date, newDecodeError(b, "dates are expected to have the format YYYY-MM-DD")
+		return date, unstable.NewParserError(b, "dates are expected to have the format YYYY-MM-DD")
 	}
 
 	var err error
 
 	date.Year, err = parseDecimalDigits(b[0:4])
 	if err != nil {
-		return date, err
+		return LocalDate{}, err
 	}
 
-	v, err := parseDecimalDigits(b[5:7])
+	date.Month, err = parseDecimalDigits(b[5:7])
 	if err != nil {
-		return date, err
+		return LocalDate{}, err
 	}
 
-	date.Month = time.Month(v)
-
 	date.Day, err = parseDecimalDigits(b[8:10])
 	if err != nil {
-		return date, err
+		return LocalDate{}, err
+	}
+
+	if !isValidDate(date.Year, date.Month, date.Day) {
+		return LocalDate{}, unstable.NewParserError(b, "impossible date")
 	}
 
 	return date, nil
 }
 
-var errNotDigit = errors.New("not a digit")
-
 func parseDecimalDigits(b []byte) (int, error) {
 	v := 0
 
-	for _, c := range b {
+	for i, c := range b {
-		if !isDigit(c) {
+		if c < '0' || c > '9' {
-			return 0, fmt.Errorf("%s: %w", b, errNotDigit)
+			return 0, unstable.NewParserError(b[i:i+1], "expected digit (0-9)")
 		}
-
 		v *= 10
 		v += int(c - '0')
 	}
@@ -76,13 +75,12 @@ func parseDecimalDigits(b []byte) (int, error) {
 	return v, nil
 }
 
-var errParseDateTimeMissingInfo = errors.New("date-time missing timezone information")
-
 func parseDateTime(b []byte) (time.Time, error) {
 	// offset-date-time = full-date time-delim full-time
 	// full-time      = partial-time time-offset
 	// time-offset    = "Z" / time-numoffset
 	// time-numoffset = ( "+" / "-" ) time-hour ":" time-minute
+
 	dt, b, err := parseLocalDateTime(b)
 	if err != nil {
 		return time.Time{}, err
@@ -91,95 +89,115 @@ func parseDateTime(b []byte) (time.Time, error) {
 	var zone *time.Location
 
 	if len(b) == 0 {
-		return time.Time{}, errParseDateTimeMissingInfo
+		// parser should have checked that when assigning the date time node
+		panic("date time should have a timezone")
 	}
 
-	if b[0] == 'Z' {
+	if b[0] == 'Z' || b[0] == 'z' {
 		b = b[1:]
 		zone = time.UTC
 	} else {
 		const dateTimeByteLen = 6
 		if len(b) != dateTimeByteLen {
-			return time.Time{}, newDecodeError(b, "invalid date-time timezone")
+			return time.Time{}, unstable.NewParserError(b, "invalid date-time timezone")
 		}
-		direction := 1
+		var direction int
 		switch b[0] {
-		case '+':
 		case '-':
 			direction = -1
+		case '+':
+			direction = +1
 		default:
-			return time.Time{}, newDecodeError(b[0:1], "invalid timezone offset character")
+			return time.Time{}, unstable.NewParserError(b[:1], "invalid timezone offset character")
+		}
+
+		if b[3] != ':' {
+			return time.Time{}, unstable.NewParserError(b[3:4], "expected a : separator")
+		}
+
+		hours, err := parseDecimalDigits(b[1:3])
+		if err != nil {
+			return time.Time{}, err
+		}
+		if hours > 23 {
+			return time.Time{}, unstable.NewParserError(b[:1], "invalid timezone offset hours")
+		}
+
+		minutes, err := parseDecimalDigits(b[4:6])
+		if err != nil {
+			return time.Time{}, err
+		}
+		if minutes > 59 {
+			return time.Time{}, unstable.NewParserError(b[:1], "invalid timezone offset minutes")
 		}
 
-		hours := digitsToInt(b[1:3])
-		minutes := digitsToInt(b[4:6])
 		seconds := direction * (hours*3600 + minutes*60)
-		zone = time.FixedZone("", seconds)
+		if seconds == 0 {
+			zone = time.UTC
+		} else {
+			zone = time.FixedZone("", seconds)
+		}
+		b = b[dateTimeByteLen:]
 	}
 
 	if len(b) > 0 {
-		return time.Time{}, newDecodeError(b, "extra bytes at the end of the timezone")
+		return time.Time{}, unstable.NewParserError(b, "extra bytes at the end of the timezone")
 	}
 
 	t := time.Date(
-		dt.Date.Year,
+		dt.Year,
-		dt.Date.Month,
+		time.Month(dt.Month),
-		dt.Date.Day,
+		dt.Day,
-		dt.Time.Hour,
+		dt.Hour,
-		dt.Time.Minute,
+		dt.Minute,
-		dt.Time.Second,
+		dt.Second,
-		dt.Time.Nanosecond,
+		dt.Nanosecond,
 		zone)
 
 	return t, nil
 }
 
-var (
-	errParseLocalDateTimeWrongLength = errors.New(
-		"local datetimes are expected to have the format YYYY-MM-DDTHH:MM:SS[.NNNNNN]",
-	)
-	errParseLocalDateTimeWrongSeparator = errors.New("datetime separator is expected to be T or a space")
-)
-
 func parseLocalDateTime(b []byte) (LocalDateTime, []byte, error) {
 	var dt LocalDateTime
 
-	const localDateTimeByteLen = 11
+	const localDateTimeByteMinLen = 11
-	if len(b) < localDateTimeByteLen {
+	if len(b) < localDateTimeByteMinLen {
-		return dt, nil, errParseLocalDateTimeWrongLength
+		return dt, nil, unstable.NewParserError(b, "local datetimes are expected to have the format YYYY-MM-DDTHH:MM:SS[.NNNNNNNNN]")
 	}
 
 	date, err := parseLocalDate(b[:10])
 	if err != nil {
 		return dt, nil, err
 	}
-	dt.Date = date
+	dt.LocalDate = date
 
 	sep := b[10]
-	if sep != 'T' && sep != ' ' {
+	if sep != 'T' && sep != ' ' && sep != 't' {
-		return dt, nil, errParseLocalDateTimeWrongSeparator
+		return dt, nil, unstable.NewParserError(b[10:11], "datetime separator is expected to be T or a space")
 	}
 
 	t, rest, err := parseLocalTime(b[11:])
 	if err != nil {
 		return dt, nil, err
 	}
-	dt.Time = t
+	dt.LocalTime = t
 
 	return dt, rest, nil
 }
 
-var errParseLocalTimeWrongLength = errors.New("times are expected to have the format HH:MM:SS[.NNNNNN]")
-
 // parseLocalTime is a bit different because it also returns the remaining
 // []byte that is didn't need. This is to allow parseDateTime to parse those
 // remaining bytes as a timezone.
 func parseLocalTime(b []byte) (LocalTime, []byte, error) {
-	var t LocalTime
+	var (
+		nspow = [10]int{0, 1e8, 1e7, 1e6, 1e5, 1e4, 1e3, 1e2, 1e1, 1e0}
+		t     LocalTime
+	)
 
+	// check if b matches to have expected format HH:MM:SS[.NNNNNN]
 	const localTimeByteLen = 8
 	if len(b) < localTimeByteLen {
-		return t, nil, errParseLocalTimeWrongLength
+		return t, nil, unstable.NewParserError(b, "times are expected to have the format HH:MM:SS[.NNNNNN]")
 	}
 
 	var err error
@@ -189,17 +207,22 @@ func parseLocalTime(b []byte) (LocalTime, []byte, error) {
 		return t, nil, err
 	}
 
+	if t.Hour > 23 {
+		return t, nil, unstable.NewParserError(b[0:2], "hour cannot be greater 23")
+	}
 	if b[2] != ':' {
-		return t, nil, newDecodeError(b[2:3], "expecting colon between hours and minutes")
+		return t, nil, unstable.NewParserError(b[2:3], "expecting colon between hours and minutes")
 	}
 
 	t.Minute, err = parseDecimalDigits(b[3:5])
 	if err != nil {
 		return t, nil, err
 	}
-
+	if t.Minute > 59 {
+		return t, nil, unstable.NewParserError(b[3:5], "minutes cannot be greater 59")
+	}
 	if b[5] != ':' {
-		return t, nil, newDecodeError(b[5:6], "expecting colon between minutes and seconds")
+		return t, nil, unstable.NewParserError(b[5:6], "expecting colon between minutes and seconds")
 	}
 
 	t.Second, err = parseDecimalDigits(b[6:8])
@@ -207,175 +230,320 @@ func parseLocalTime(b []byte) (LocalTime, []byte, error) {
 		return t, nil, err
 	}
 
-	if len(b) >= 15 && b[8] == '.' {
+	if t.Second > 59 {
-		t.Nanosecond, err = parseDecimalDigits(b[9:15])
+		return t, nil, unstable.NewParserError(b[6:8], "seconds cannot be greater than 59")
-		if err != nil {
-			return t, nil, err
-		}
-
-		return t, b[15:], nil
 	}
 
-	return t, b[8:], nil
+	b = b[8:]
+
+	if len(b) >= 1 && b[0] == '.' {
+		frac := 0
+		precision := 0
+		digits := 0
+
+		for i, c := range b[1:] {
+			if !isDigit(c) {
+				if i == 0 {
+					return t, nil, unstable.NewParserError(b[0:1], "need at least one digit after fraction point")
+				}
+				break
+			}
+			digits++
+
+			const maxFracPrecision = 9
+			if i >= maxFracPrecision {
+				// go-toml allows decoding fractional seconds
+				// beyond the supported precision of 9
+				// digits. It truncates the fractional component
+				// to the supported precision and ignores the
+				// remaining digits.
+				//
+				// https://github.com/pelletier/go-toml/discussions/707
+				continue
+			}
+
+			frac *= 10
+			frac += int(c - '0')
+			precision++
+		}
+
+		if precision == 0 {
+			return t, nil, unstable.NewParserError(b[:1], "nanoseconds need at least one digit")
+		}
+
+		t.Nanosecond = frac * nspow[precision]
+		t.Precision = precision
+
+		return t, b[1+digits:], nil
+	}
+	return t, b, nil
 }
 
-var (
-	errParseFloatStartDot = errors.New("float cannot start with a dot")
-	errParseFloatEndDot   = errors.New("float cannot end with a dot")
-)
-
-//nolint:cyclop
 func parseFloat(b []byte) (float64, error) {
-	//nolint:godox
-	// TODO: inefficient
 	if len(b) == 4 && (b[0] == '+' || b[0] == '-') && b[1] == 'n' && b[2] == 'a' && b[3] == 'n' {
 		return math.NaN(), nil
 	}
 
-	tok := string(b)
+	cleaned, err := checkAndRemoveUnderscoresFloats(b)
-
-	err := numberContainsInvalidUnderscore(tok)
 	if err != nil {
 		return 0, err
 	}
 
-	cleanedVal := cleanupNumberToken(tok)
+	if cleaned[0] == '.' {
-	if cleanedVal[0] == '.' {
+		return 0, unstable.NewParserError(b, "float cannot start with a dot")
-		return 0, errParseFloatStartDot
 	}
 
-	if cleanedVal[len(cleanedVal)-1] == '.' {
+	if cleaned[len(cleaned)-1] == '.' {
-		return 0, errParseFloatEndDot
+		return 0, unstable.NewParserError(b, "float cannot end with a dot")
 	}
 
-	f, err := strconv.ParseFloat(cleanedVal, 64)
+	dotAlreadySeen := false
+	for i, c := range cleaned {
+		if c == '.' {
+			if dotAlreadySeen {
+				return 0, unstable.NewParserError(b[i:i+1], "float can have at most one decimal point")
+			}
+			if !isDigit(cleaned[i-1]) {
+				return 0, unstable.NewParserError(b[i-1:i+1], "float decimal point must be preceded by a digit")
+			}
+			if !isDigit(cleaned[i+1]) {
+				return 0, unstable.NewParserError(b[i:i+2], "float decimal point must be followed by a digit")
+			}
+			dotAlreadySeen = true
+		}
+	}
+
+	start := 0
+	if cleaned[0] == '+' || cleaned[0] == '-' {
+		start = 1
+	}
+	if cleaned[start] == '0' && len(cleaned) > start+1 && isDigit(cleaned[start+1]) {
+		return 0, unstable.NewParserError(b, "float integer part cannot have leading zeroes")
+	}
+
+	f, err := strconv.ParseFloat(string(cleaned), 64)
 	if err != nil {
-		return 0, fmt.Errorf("coudn't ParseFloat %w", err)
+		return 0, unstable.NewParserError(b, "unable to parse float: %w", err)
 	}
 
 	return f, nil
 }
 
 func parseIntHex(b []byte) (int64, error) {
-	tok := string(b)
+	cleaned, err := checkAndRemoveUnderscoresIntegers(b[2:])
-	cleanedVal := cleanupNumberToken(tok)
-
-	err := hexNumberContainsInvalidUnderscore(cleanedVal)
 	if err != nil {
 		return 0, err
 	}
 
-	i, err := strconv.ParseInt(cleanedVal[2:], 16, 64)
+	i, err := strconv.ParseInt(string(cleaned), 16, 64)
 	if err != nil {
-		return 0, fmt.Errorf("coudn't ParseIntHex %w", err)
+		return 0, unstable.NewParserError(b, "couldn't parse hexadecimal number: %w", err)
 	}
 
 	return i, nil
 }
 
 func parseIntOct(b []byte) (int64, error) {
-	tok := string(b)
+	cleaned, err := checkAndRemoveUnderscoresIntegers(b[2:])
-	cleanedVal := cleanupNumberToken(tok)
-
-	err := numberContainsInvalidUnderscore(cleanedVal)
 	if err != nil {
 		return 0, err
 	}
 
-	i, err := strconv.ParseInt(cleanedVal[2:], 8, 64)
+	i, err := strconv.ParseInt(string(cleaned), 8, 64)
 	if err != nil {
-		return 0, fmt.Errorf("coudn't ParseIntOct %w", err)
+		return 0, unstable.NewParserError(b, "couldn't parse octal number: %w", err)
 	}
 
 	return i, nil
 }
 
 func parseIntBin(b []byte) (int64, error) {
-	tok := string(b)
+	cleaned, err := checkAndRemoveUnderscoresIntegers(b[2:])
-	cleanedVal := cleanupNumberToken(tok)
-
-	err := numberContainsInvalidUnderscore(cleanedVal)
 	if err != nil {
 		return 0, err
 	}
 
-	i, err := strconv.ParseInt(cleanedVal[2:], 2, 64)
+	i, err := strconv.ParseInt(string(cleaned), 2, 64)
 	if err != nil {
-		return 0, fmt.Errorf("coudn't ParseIntBin %w", err)
+		return 0, unstable.NewParserError(b, "couldn't parse binary number: %w", err)
 	}
 
 	return i, nil
 }
 
+func isSign(b byte) bool {
+	return b == '+' || b == '-'
+}
+
 func parseIntDec(b []byte) (int64, error) {
-	tok := string(b)
+	cleaned, err := checkAndRemoveUnderscoresIntegers(b)
-	cleanedVal := cleanupNumberToken(tok)
-
-	err := numberContainsInvalidUnderscore(cleanedVal)
 	if err != nil {
 		return 0, err
 	}
 
-	i, err := strconv.ParseInt(cleanedVal, 10, 64)
+	startIdx := 0
+
+	if isSign(cleaned[0]) {
+		startIdx++
+	}
+
+	if len(cleaned) > startIdx+1 && cleaned[startIdx] == '0' {
+		return 0, unstable.NewParserError(b, "leading zero not allowed on decimal number")
+	}
+
+	i, err := strconv.ParseInt(string(cleaned), 10, 64)
 	if err != nil {
-		return 0, fmt.Errorf("coudn't parseIntDec %w", err)
+		return 0, unstable.NewParserError(b, "couldn't parse decimal number: %w", err)
 	}
 
 	return i, nil
 }
 
-func numberContainsInvalidUnderscore(value string) error {
+func checkAndRemoveUnderscoresIntegers(b []byte) ([]byte, error) {
-	// For large numbers, you may use underscores between digits to enhance
+	start := 0
-	// readability. Each underscore must be surrounded by at least one digit on
+	if b[start] == '+' || b[start] == '-' {
-	// each side.
+		start++
-	hasBefore := false
-
-	for idx, r := range value {
-		if r == '_' {
-			if !hasBefore || idx+1 >= len(value) {
-				// can't end with an underscore
-				return errInvalidUnderscore
-			}
-		}
-		hasBefore = isDigitRune(r)
 	}
 
-	return nil
+	if len(b) == start {
-}
+		return b, nil
-
-func hexNumberContainsInvalidUnderscore(value string) error {
-	hasBefore := false
-
-	for idx, r := range value {
-		if r == '_' {
-			if !hasBefore || idx+1 >= len(value) {
-				// can't end with an underscore
-				return errInvalidUnderscoreHex
-			}
-		}
-		hasBefore = isHexDigit(r)
 	}
 
-	return nil
+	if b[start] == '_' {
+		return nil, unstable.NewParserError(b[start:start+1], "number cannot start with underscore")
+	}
+
+	if b[len(b)-1] == '_' {
+		return nil, unstable.NewParserError(b[len(b)-1:], "number cannot end with underscore")
+	}
+
+	// fast path
+	i := 0
+	for ; i < len(b); i++ {
+		if b[i] == '_' {
+			break
+		}
+	}
+	if i == len(b) {
+		return b, nil
+	}
+
+	before := false
+	cleaned := make([]byte, i, len(b))
+	copy(cleaned, b)
+
+	for i++; i < len(b); i++ {
+		c := b[i]
+		if c == '_' {
+			if !before {
+				return nil, unstable.NewParserError(b[i-1:i+1], "number must have at least one digit between underscores")
+			}
+			before = false
+		} else {
+			before = true
+			cleaned = append(cleaned, c)
+		}
+	}
+
+	return cleaned, nil
 }
 
-func cleanupNumberToken(value string) string {
+func checkAndRemoveUnderscoresFloats(b []byte) ([]byte, error) {
-	cleanedVal := strings.ReplaceAll(value, "_", "")
+	if b[0] == '_' {
+		return nil, unstable.NewParserError(b[0:1], "number cannot start with underscore")
+	}
 
-	return cleanedVal
+	if b[len(b)-1] == '_' {
+		return nil, unstable.NewParserError(b[len(b)-1:], "number cannot end with underscore")
+	}
+
+	// fast path
+	i := 0
+	for ; i < len(b); i++ {
+		if b[i] == '_' {
+			break
+		}
+	}
+	if i == len(b) {
+		return b, nil
+	}
+
+	before := false
+	cleaned := make([]byte, 0, len(b))
+
+	for i := 0; i < len(b); i++ {
+		c := b[i]
+
+		switch c {
+		case '_':
+			if !before {
+				return nil, unstable.NewParserError(b[i-1:i+1], "number must have at least one digit between underscores")
+			}
+			if i < len(b)-1 && (b[i+1] == 'e' || b[i+1] == 'E') {
+				return nil, unstable.NewParserError(b[i+1:i+2], "cannot have underscore before exponent")
+			}
+			before = false
+		case '+', '-':
+			// signed exponents
+			cleaned = append(cleaned, c)
+			before = false
+		case 'e', 'E':
+			if i < len(b)-1 && b[i+1] == '_' {
+				return nil, unstable.NewParserError(b[i+1:i+2], "cannot have underscore after exponent")
+			}
+			cleaned = append(cleaned, c)
+		case '.':
+			if i < len(b)-1 && b[i+1] == '_' {
+				return nil, unstable.NewParserError(b[i+1:i+2], "cannot have underscore after decimal point")
+			}
+			if i > 0 && b[i-1] == '_' {
+				return nil, unstable.NewParserError(b[i-1:i], "cannot have underscore before decimal point")
+			}
+			cleaned = append(cleaned, c)
+		default:
+			before = true
+			cleaned = append(cleaned, c)
+		}
+	}
+
+	return cleaned, nil
 }
 
-func isHexDigit(r rune) bool {
+// isValidDate checks if a provided date is a date that exists.
-	return isDigitRune(r) ||
+func isValidDate(year int, month int, day int) bool {
-		(r >= 'a' && r <= 'f') ||
+	return month > 0 && month < 13 && day > 0 && day <= daysIn(month, year)
-		(r >= 'A' && r <= 'F')
 }
 
-func isDigitRune(r rune) bool {
+// daysBefore[m] counts the number of days in a non-leap year
+// before month m begins. There is an entry for m=12, counting
+// the number of days before January of next year (365).
+var daysBefore = [...]int32{
+	0,
+	31,
+	31 + 28,
+	31 + 28 + 31,
+	31 + 28 + 31 + 30,
+	31 + 28 + 31 + 30 + 31,
+	31 + 28 + 31 + 30 + 31 + 30,
+	31 + 28 + 31 + 30 + 31 + 30 + 31,
+	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31,
+	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
+	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
+	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30,
+	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31,
+}
+
+func daysIn(m int, year int) int {
+	if m == 2 && isLeap(year) {
+		return 29
+	}
+	return int(daysBefore[m] - daysBefore[m-1])
+}
+
+func isLeap(year int) bool {
+	return year%4 == 0 && (year%100 != 0 || year%400 == 0)
+}
+
+func isDigit(r byte) bool {
 	return r >= '0' && r <= '9'
 }
-
-var (
-	errInvalidUnderscore    = errors.New("invalid use of _ in number")
-	errInvalidUnderscoreHex = errors.New("invalid use of _ in hex number")
-)

doc.go

@@ -0,0 +1,2 @@
+// Package toml is a library to read and write TOML documents.
+package toml

errors.go

@@ -2,10 +2,11 @@ package toml
 
 import (
 	"fmt"
+	"reflect"
 	"strconv"
 	"strings"
 
-	"github.com/pelletier/go-toml/v2/internal/unsafe"
+	"github.com/pelletier/go-toml/v2/unstable"
 )
 
 // DecodeError represents an error encountered during the parsing or decoding
@@ -18,31 +19,58 @@ type DecodeError struct {
 	message string
 	line    int
 	column  int
+	key     Key
 
 	human string
 }
 
-// internal version of DecodeError that is used as the base to create a
+// StrictMissingError occurs in a TOML document that does not have a
-// DecodeError with full context.
+// corresponding field in the target value. It contains all the missing fields
-type decodeError struct {
+// in Errors.
-	highlight []byte
+//
-	message   string
+// Emitted by Decoder when DisallowUnknownFields() was called.
+type StrictMissingError struct {
+	// One error per field that could not be found.
+	Errors []DecodeError
 }
 
-func (de *decodeError) Error() string {
+// Error returns the canonical string for this error.
-	return de.message
+func (s *StrictMissingError) Error() string {
+	return "strict mode: fields in the document are missing in the target struct"
 }
 
-func newDecodeError(highlight []byte, format string, args ...interface{}) error {
+// String returns a human readable description of all errors.
-	return &decodeError{
+func (s *StrictMissingError) String() string {
-		highlight: highlight,
+	var buf strings.Builder
-		message:   fmt.Sprintf(format, args...),
+
+	for i, e := range s.Errors {
+		if i > 0 {
+			buf.WriteString("\n---\n")
+		}
+
+		buf.WriteString(e.String())
 	}
+
+	return buf.String()
 }
 
+// Unwrap returns wrapped decode errors
+//
+// Implements errors.Join() interface.
+func (s *StrictMissingError) Unwrap() []error {
+	errs := make([]error, len(s.Errors))
+	for i := range s.Errors {
+		errs[i] = &s.Errors[i]
+	}
+	return errs
+}
+
+// Key represents a TOML key as a sequence of key parts.
+type Key []string
+
 // Error returns the error message contained in the DecodeError.
 func (e *DecodeError) Error() string {
-	return e.message
+	return "toml: " + e.message
 }
 
 // String returns the human-readable contextualized error. This string is multi-line.
@@ -56,30 +84,34 @@ func (e *DecodeError) Position() (row int, column int) {
 	return e.line, e.column
 }
 
-// decodeErrorFromHighlight creates a DecodeError referencing to a highlighted
+// Key that was being processed when the error occurred. The key is present only
+// if this DecodeError is part of a StrictMissingError.
+func (e *DecodeError) Key() Key {
+	return e.key
+}
+
+// wrapDecodeError creates a DecodeError referencing a highlighted
 // range of bytes from document.
 //
 // highlight needs to be a sub-slice of document, or this function panics.
 //
 // 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) error {
+func wrapDecodeError(document []byte, de *unstable.ParserError) *DecodeError {
-	if de == nil {
+	offset := subsliceOffset(document, de.Highlight)
-		return nil
-	}
 
-	offset := unsafe.SubsliceOffset(document, de.highlight)
+	errMessage := de.Error()
-
-	errMessage := de.message
 	errLine, errColumn := positionAtEnd(document[:offset])
-	before, after := linesOfContext(document, de.highlight, offset, 3)
+	before, after := linesOfContext(document, de.Highlight, offset, 3)
 
 	var buf strings.Builder
 
 	maxLine := errLine + len(after) - 1
 	lineColumnWidth := len(strconv.Itoa(maxLine))
 
+	// Write the lines of context strictly before the error.
 	for i := len(before) - 1; i > 0; i-- {
 		line := errLine - i
 		buf.WriteString(formatLineNumber(line, lineColumnWidth))
@@ -93,6 +125,8 @@ func wrapDecodeError(document []byte, de *decodeError) error {
 		buf.WriteRune('\n')
 	}
 
+	// Write the document line that contains the error.
+
 	buf.WriteString(formatLineNumber(errLine, lineColumnWidth))
 	buf.WriteString("| ")
 
@@ -100,13 +134,17 @@ func wrapDecodeError(document []byte, de *decodeError) error {
 		buf.Write(before[0])
 	}
 
-	buf.Write(de.highlight)
+	buf.Write(de.Highlight)
 
 	if len(after) > 0 {
 		buf.Write(after[0])
 	}
 
 	buf.WriteRune('\n')
+
+	// Write the line with the error message itself (so it does not have a line
+	// number).
+
 	buf.WriteString(strings.Repeat(" ", lineColumnWidth))
 	buf.WriteString("| ")
 
@@ -114,13 +152,15 @@ func wrapDecodeError(document []byte, de *decodeError) error {
 		buf.WriteString(strings.Repeat(" ", len(before[0])))
 	}
 
-	buf.WriteString(strings.Repeat("~", len(de.highlight)))
+	buf.WriteString(strings.Repeat("~", len(de.Highlight)))
 
 	if len(errMessage) > 0 {
 		buf.WriteString(" ")
 		buf.WriteString(errMessage)
 	}
 
+	// Write the lines of context strictly after the error.
+
 	for i := 1; i < len(after); i++ {
 		buf.WriteRune('\n')
 		line := errLine + i
@@ -137,6 +177,7 @@ func wrapDecodeError(document []byte, de *decodeError) error {
 		message: errMessage,
 		line:    errLine,
 		column:  errColumn,
+		key:     de.Key,
 		human:   buf.String(),
 	}
 }
@@ -193,7 +234,7 @@ forward:
 			rest = rest[o+1:]
 			o = 0
 
-		case o == len(rest)-1 && o > 0:
+		case o == len(rest)-1:
 			// add last line only if it's non-empty
 			afterLines = append(afterLines, rest)
 
@@ -219,5 +260,24 @@ func positionAtEnd(b []byte) (row int, column int) {
 		}
 	}
 
-	return
+	return row, column
+}
+
+// subsliceOffset returns the byte offset of subslice within data.
+// subslice must share the same backing array as data.
+func subsliceOffset(data []byte, subslice []byte) int {
+	if len(subslice) == 0 {
+		return 0
+	}
+
+	// Use reflect to get the data pointers of both slices.
+	// This is safe because we're only reading the pointer values for comparison.
+	dataPtr := reflect.ValueOf(data).Pointer()
+	subPtr := reflect.ValueOf(subslice).Pointer()
+
+	offset := int(subPtr - dataPtr)
+	if offset < 0 || offset > len(data) {
+		panic("subslice is not within data")
+	}
+	return offset
 }

errors_test.go

@@ -3,16 +3,16 @@ package toml
 import (
 	"bytes"
 	"errors"
+	"fmt"
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/pelletier/go-toml/v2/internal/assert"
+	"github.com/pelletier/go-toml/v2/unstable"
 )
 
 //nolint:funlen
 func TestDecodeError(t *testing.T) {
-	t.Parallel()
-
 	examples := []struct {
 		desc     string
 		doc      [3]string
@@ -148,24 +148,30 @@ line 5`,
 6|
 7| line 4`,
 		},
+		{
+			desc: "handle remainder of the error line when there is only one line",
+			doc:  [3]string{`P=`, `[`, `#`},
+			msg:  "array is incomplete",
+			expected: `1| P=[#
+ |   ~ array is incomplete`,
+		},
 	}
 
 	for _, e := range examples {
 		e := e
 		t.Run(e.desc, func(t *testing.T) {
-			t.Parallel()
 			b := bytes.Buffer{}
-			b.Write([]byte(e.doc[0]))
+			b.WriteString(e.doc[0])
 			start := b.Len()
-			b.Write([]byte(e.doc[1]))
+			b.WriteString(e.doc[1])
 			end := b.Len()
-			b.Write([]byte(e.doc[2]))
+			b.WriteString(e.doc[2])
 			doc := b.Bytes()
 			hl := doc[start:end]
 
-			err := wrapDecodeError(doc, &decodeError{
+			err := wrapDecodeError(doc, &unstable.ParserError{
-				highlight: hl,
+				Highlight: hl,
-				message:   e.msg,
+				Message:   e.msg,
 			})
 
 			var derr *DecodeError
@@ -179,3 +185,160 @@ line 5`,
 		})
 	}
 }
+
+func TestDecodeError_Accessors(t *testing.T) {
+	e := DecodeError{
+		message: "foo",
+		line:    1,
+		column:  2,
+		key:     []string{"one", "two"},
+		human:   "bar",
+	}
+	assert.Equal(t, "toml: foo", e.Error())
+	r, c := e.Position()
+	assert.Equal(t, 1, r)
+	assert.Equal(t, 2, c)
+	assert.Equal(t, Key{"one", "two"}, e.Key())
+	assert.Equal(t, "bar", e.String())
+}
+
+func TestDecodeError_DuplicateContent(t *testing.T) {
+	// This test verifies that when the same content appears multiple times
+	// in the document, the error correctly points to the actual location
+	// of the error, not the first occurrence of the content.
+	//
+	// The document has "1__2" on line 1 and "3__4" on line 2.
+	// Both have "__" which is invalid, but we want to ensure errors
+	// on line 2 report line 2, not line 1.
+
+	doc := `a = 1
+b = 3__4`
+
+	var v map[string]int
+	err := Unmarshal([]byte(doc), &v)
+
+	var derr *DecodeError
+	if !errors.As(err, &derr) {
+		t.Fatal("error not in expected format")
+	}
+
+	row, col := derr.Position()
+	// The error should be on line 2 where "3__4" is
+	if row != 2 {
+		t.Errorf("expected error on row 2, got row %d", row)
+	}
+	// Column should point to the "__" part (after "3")
+	if col < 5 {
+		t.Errorf("expected error at column >= 5, got column %d", col)
+	}
+}
+
+func TestDecodeError_Position(t *testing.T) {
+	// Test that error positions are correctly reported for various error locations
+	examples := []struct {
+		name        string
+		doc         string
+		expectedRow int
+		minCol      int
+	}{
+		{
+			name:        "error on first line",
+			doc:         `a = 1__2`,
+			expectedRow: 1,
+			minCol:      5,
+		},
+		{
+			name:        "error on second line",
+			doc:         "a = 1\nb = 2__3",
+			expectedRow: 2,
+			minCol:      5,
+		},
+		{
+			name:        "error on third line",
+			doc:         "a = 1\nb = 2\nc = 3__4",
+			expectedRow: 3,
+			minCol:      5,
+		},
+		{
+			name:        "missing equals on last line without trailing newline",
+			doc:         "a = 1\nb = 2\nc",
+			expectedRow: 3,
+			minCol:      1,
+		},
+	}
+
+	for _, e := range examples {
+		t.Run(e.name, func(t *testing.T) {
+			var v map[string]int
+			err := Unmarshal([]byte(e.doc), &v)
+
+			var derr *DecodeError
+			if !errors.As(err, &derr) {
+				t.Fatal("error not in expected format")
+			}
+
+			row, col := derr.Position()
+			assert.Equal(t, e.expectedRow, row)
+			if col < e.minCol {
+				t.Errorf("expected column >= %d, got %d", e.minCol, col)
+			}
+		})
+	}
+}
+
+func TestDecodeError_InvalidKeyStartAfterComment(t *testing.T) {
+	doc := "# comment\n= \"value\""
+
+	var out map[string]string
+	err := Unmarshal([]byte(doc), &out)
+	assert.Error(t, err)
+
+	var derr *DecodeError
+	if !errors.As(err, &derr) {
+		t.Fatal("error not in expected format")
+	}
+
+	row, col := derr.Position()
+	assert.Equal(t, 2, row)
+	assert.Equal(t, 1, col)
+	assert.Equal(t, "toml: invalid character at start of key: =", derr.Error())
+	assert.Equal(t, `1| # comment
+2| = "value"
+ | ~ invalid character at start of key: =`, derr.String())
+}
+
+func TestStrictErrorUnwrap(t *testing.T) {
+	fo := bytes.NewBufferString(`
+Missing = 1
+OtherMissing = 1
+`)
+	var out struct{}
+	err := NewDecoder(fo).DisallowUnknownFields().Decode(&out)
+	assert.Error(t, err)
+
+	strictErr := &StrictMissingError{}
+	assert.True(t, errors.As(err, &strictErr))
+
+	assert.Equal(t, 2, len(strictErr.Unwrap()))
+}
+
+func ExampleDecodeError() {
+	doc := `name = 123__456`
+
+	s := map[string]interface{}{}
+	err := Unmarshal([]byte(doc), &s)
+
+	fmt.Println(err)
+
+	var derr *DecodeError
+	if errors.As(err, &derr) {
+		fmt.Println(derr.String())
+		row, col := derr.Position()
+		fmt.Println("error occurred at row", row, "column", col)
+	}
+	// Output:
+	// toml: number must have at least one digit between underscores
+	// 1| name = 123__456
+	//  |           ~~ number must have at least one digit between underscores
+	// error occurred at row 1 column 11
+}

example_text_marshaling_test.go

@@ -0,0 +1,37 @@
+package toml_test
+
+import (
+	"fmt"
+	"log"
+	"strconv"
+
+	"github.com/pelletier/go-toml/v2"
+)
+
+type customInt int
+
+func (i *customInt) UnmarshalText(b []byte) error {
+	x, err := strconv.ParseInt(string(b), 10, 32)
+	if err != nil {
+		return err
+	}
+	*i = customInt(x * 100)
+	return nil
+}
+
+type doc struct {
+	Value customInt
+}
+
+func ExampleUnmarshal_textUnmarshal() {
+	var x doc
+
+	data := []byte(`value  = "42"`)
+	err := toml.Unmarshal(data, &x)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(x)
+	// Output:
+	// {4200}
+}

fast_test.go

@@ -0,0 +1,107 @@
+package toml_test
+
+import (
+	"testing"
+
+	"github.com/pelletier/go-toml/v2"
+	"github.com/pelletier/go-toml/v2/internal/assert"
+)
+
+func TestFastSimpleInt(t *testing.T) {
+	m := map[string]int64{}
+	err := toml.Unmarshal([]byte(`a = 42`), &m)
+	assert.NoError(t, err)
+	assert.Equal(t, map[string]int64{"a": 42}, m)
+}
+
+func TestFastSimpleFloat(t *testing.T) {
+	m := map[string]float64{}
+	err := toml.Unmarshal([]byte("a = 42\nb = 1.1\nc = 12341234123412341234123412341234"), &m)
+	assert.NoError(t, err)
+	assert.Equal(t, map[string]float64{"a": 42, "b": 1.1, "c": 1.2341234123412342e+31}, m)
+}
+
+func TestFastSimpleString(t *testing.T) {
+	m := map[string]string{}
+	err := toml.Unmarshal([]byte(`a = "hello"`), &m)
+	assert.NoError(t, err)
+	assert.Equal(t, map[string]string{"a": "hello"}, m)
+}
+
+func TestFastSimpleInterface(t *testing.T) {
+	m := map[string]interface{}{}
+	err := toml.Unmarshal([]byte(`
+	a = "hello"
+	b = 42`), &m)
+	assert.NoError(t, err)
+	assert.Equal(t, map[string]interface{}{
+		"a": "hello",
+		"b": int64(42),
+	}, m)
+}
+
+func TestFastMultipartKeyInterface(t *testing.T) {
+	m := map[string]interface{}{}
+	err := toml.Unmarshal([]byte(`
+	a.interim = "test"
+	a.b.c = "hello"
+	b = 42`), &m)
+	assert.NoError(t, err)
+	assert.Equal(t, map[string]interface{}{
+		"a": map[string]interface{}{
+			"interim": "test",
+			"b": map[string]interface{}{
+				"c": "hello",
+			},
+		},
+		"b": int64(42),
+	}, m)
+}
+
+func TestFastExistingMap(t *testing.T) {
+	m := map[string]interface{}{
+		"ints": map[string]int{},
+	}
+	err := toml.Unmarshal([]byte(`
+	ints.one = 1
+	ints.two = 2
+	strings.yo = "hello"`), &m)
+	assert.NoError(t, err)
+	assert.Equal(t, map[string]interface{}{
+		"ints": map[string]interface{}{
+			"one": int64(1),
+			"two": int64(2),
+		},
+		"strings": map[string]interface{}{
+			"yo": "hello",
+		},
+	}, m)
+}
+
+func TestFastArrayTable(t *testing.T) {
+	b := []byte(`
+	[root]
+	[[root.nested]]
+	name = 'Bob'
+	[[root.nested]]
+	name = 'Alice'
+	`)
+
+	m := map[string]interface{}{}
+
+	err := toml.Unmarshal(b, &m)
+	assert.NoError(t, err)
+
+	assert.Equal(t, map[string]interface{}{
+		"root": map[string]interface{}{
+			"nested": []interface{}{
+				map[string]interface{}{
+					"name": "Bob",
+				},
+				map[string]interface{}{
+					"name": "Alice",
+				},
+			},
+		},
+	}, m)
+}

fuzz_test.go

@@ -0,0 +1,53 @@
+package toml_test
+
+import (
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/pelletier/go-toml/v2"
+	"github.com/pelletier/go-toml/v2/internal/assert"
+)
+
+func FuzzUnmarshal(f *testing.F) {
+	file, err := os.ReadFile("benchmark/benchmark.toml")
+	if err != nil {
+		f.Error(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)
+		}
+		assert.Equal(t, v, v2)
+	})
+}

go.mod

@@ -1,5 +1,3 @@
 module github.com/pelletier/go-toml/v2
 
-go 1.15
+go 1.21.0
-
-require github.com/stretchr/testify v1.7.0

go.sum

@@ -1,11 +0,0 @@
-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/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.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-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=

internal/assert/assertions.go

@@ -0,0 +1,141 @@
+// Package assert provides assertion functions for unit testing.
+package assert
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// True asserts that an expression is true.
+func True(tb testing.TB, ok bool, msgAndArgs ...any) {
+	tb.Helper()
+	if ok {
+		return
+	}
+	tb.Fatal(formatMsgAndArgs("Expected expression to be true", msgAndArgs...))
+}
+
+// False asserts that an expression is false.
+func False(tb testing.TB, ok bool, msgAndArgs ...any) {
+	tb.Helper()
+	if !ok {
+		return
+	}
+	tb.Fatal(formatMsgAndArgs("Expected expression to be false", msgAndArgs...))
+}
+
+// Equal asserts that "expected" and "actual" are equal.
+func Equal[T any](tb testing.TB, expected, actual T, msgAndArgs ...any) {
+	tb.Helper()
+	if objectsAreEqual(expected, actual) {
+		return
+	}
+	msg := formatMsgAndArgs("Expected values to be equal:", msgAndArgs...)
+	tb.Fatalf("%s\n%s", msg, diff(expected, actual))
+}
+
+// Error asserts that an error is not nil.
+func Error(tb testing.TB, err error, msgAndArgs ...any) {
+	tb.Helper()
+	if err != nil {
+		return
+	}
+	tb.Fatal(formatMsgAndArgs("Expected an error", msgAndArgs...))
+}
+
+// NoError asserts that an error is nil.
+func NoError(tb testing.TB, err error, msgAndArgs ...any) {
+	tb.Helper()
+	if err == nil {
+		return
+	}
+	msg := formatMsgAndArgs("Unexpected error:", msgAndArgs...)
+	tb.Fatalf("%s\n%+v", msg, err)
+}
+
+// Panics asserts that the given function panics.
+func Panics(tb testing.TB, fn func(), msgAndArgs ...any) {
+	tb.Helper()
+	defer func() {
+		if recover() == nil {
+			msg := formatMsgAndArgs("Expected function to panic", msgAndArgs...)
+			tb.Fatal(msg)
+		}
+	}()
+	fn()
+}
+
+// Zero asserts that a value is its zero value.
+func Zero[T any](tb testing.TB, value T, msgAndArgs ...any) {
+	tb.Helper()
+	var zero T
+	if objectsAreEqual(value, zero) {
+		return
+	}
+	val := reflect.ValueOf(value)
+	if (val.Kind() == reflect.Slice || val.Kind() == reflect.Map || val.Kind() == reflect.Array) && val.Len() == 0 {
+		return
+	}
+	msg := formatMsgAndArgs("Expected zero value but got:", msgAndArgs...)
+	tb.Fatalf("%s\n%v", msg, value)
+}
+
+func NotZero[T any](tb testing.TB, value T, msgAndArgs ...any) {
+	tb.Helper()
+	var zero T
+	if !objectsAreEqual(value, zero) {
+		val := reflect.ValueOf(value)
+		switch val.Kind() {
+		case reflect.Slice, reflect.Map, reflect.Array:
+			if val.Len() > 0 {
+				return
+			}
+		default:
+			return
+		}
+	}
+	msg := formatMsgAndArgs("Unexpected zero value:", msgAndArgs...)
+	tb.Fatalf("%s\n%v", msg, value)
+}
+
+func formatMsgAndArgs(msg string, args ...any) string {
+	if len(args) == 0 {
+		return msg
+	}
+	format, ok := args[0].(string)
+	if !ok {
+		panic("message argument must be a fmt string")
+	}
+	return fmt.Sprintf(format, args[1:]...)
+}
+
+func diff(expected, actual any) string {
+	lines := []string{
+		"expected:",
+		fmt.Sprintf("%v", expected),
+		"actual:",
+		fmt.Sprintf("%v", actual),
+	}
+	return strings.Join(lines, "\n")
+}
+
+func objectsAreEqual(expected, actual any) bool {
+	if expected == nil || actual == nil {
+		return expected == actual
+	}
+	if exp, eok := expected.([]byte); eok {
+		if act, aok := actual.([]byte); aok {
+			return bytes.Equal(exp, act)
+		}
+	}
+	if exp, eok := expected.(string); eok {
+		if act, aok := actual.(string); aok {
+			return exp == act
+		}
+	}
+
+	return reflect.DeepEqual(expected, actual)
+}

internal/assert/assertions_test.go

@@ -0,0 +1,217 @@
+package assert
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+type Data struct {
+	Label string
+	Value int64
+}
+
+func TestBadMessage(t *testing.T) {
+	invalidMessage := func() { True(t, false, 1234) }
+	assertOk(t, "Non-fmt message value", func(tb testing.TB) {
+		tb.Helper()
+		Panics(tb, invalidMessage)
+	})
+	assertFail(t, "Non-fmt message value", func(tb testing.TB) {
+		tb.Helper()
+		True(tb, false, "example %s", "message")
+	})
+}
+
+func TestTrue(t *testing.T) {
+	assertOk(t, "Succeed", func(tb testing.TB) {
+		tb.Helper()
+		True(tb, 1 > 0)
+	})
+	assertFail(t, "Fail", func(tb testing.TB) {
+		tb.Helper()
+		True(tb, 1 < 0)
+	})
+}
+
+func TestFalse(t *testing.T) {
+	assertOk(t, "Succeed", func(tb testing.TB) {
+		tb.Helper()
+		False(tb, 1 < 0)
+	})
+	assertFail(t, "Fail", func(tb testing.TB) {
+		tb.Helper()
+		False(tb, 1 > 0)
+	})
+}
+
+func TestEqual(t *testing.T) {
+	assertOk(t, "Nil", func(tb testing.TB) {
+		tb.Helper()
+		Equal(tb, interface{}(nil), interface{}(nil))
+	})
+	assertOk(t, "Identical structs", func(tb testing.TB) {
+		tb.Helper()
+		Equal(tb, Data{"expected", 1234}, Data{"expected", 1234})
+	})
+	assertFail(t, "Different structs", func(tb testing.TB) {
+		tb.Helper()
+		Equal(tb, Data{"expected", 1234}, Data{"actual", 1234})
+	})
+	assertOk(t, "Identical numbers", func(tb testing.TB) {
+		tb.Helper()
+		Equal(tb, 1234, 1234)
+	})
+	assertFail(t, "Identical numbers", func(tb testing.TB) {
+		tb.Helper()
+		Equal(tb, 1234, 1324)
+	})
+	assertOk(t, "Zero-length byte arrays", func(tb testing.TB) {
+		tb.Helper()
+		Equal(tb, []byte(nil), []byte(""))
+	})
+	assertOk(t, "Identical byte arrays", func(tb testing.TB) {
+		tb.Helper()
+		Equal(tb, []byte{1, 2, 3, 4}, []byte{1, 2, 3, 4})
+	})
+	assertFail(t, "Different byte arrays", func(tb testing.TB) {
+		tb.Helper()
+		Equal(tb, []byte{1, 2, 3, 4}, []byte{1, 3, 2, 4})
+	})
+	assertOk(t, "Identical strings", func(tb testing.TB) {
+		tb.Helper()
+		Equal(tb, "example", "example")
+	})
+	assertFail(t, "Identical strings", func(tb testing.TB) {
+		tb.Helper()
+		Equal(tb, "example", "elpmaxe")
+	})
+}
+
+func TestError(t *testing.T) {
+	assertOk(t, "Error", func(tb testing.TB) {
+		tb.Helper()
+		Error(tb, errors.New("example"))
+	})
+	assertFail(t, "Nil", func(tb testing.TB) {
+		tb.Helper()
+		Error(tb, nil)
+	})
+}
+
+func TestNoError(t *testing.T) {
+	assertFail(t, "Error", func(tb testing.TB) {
+		tb.Helper()
+		NoError(tb, errors.New("example"))
+	})
+	assertOk(t, "Nil", func(tb testing.TB) {
+		tb.Helper()
+		NoError(tb, nil)
+	})
+}
+
+func TestPanics(t *testing.T) {
+	willPanic := func() { panic("example") }
+	wontPanic := func() {}
+	assertOk(t, "Will panic", func(tb testing.TB) {
+		tb.Helper()
+		Panics(tb, willPanic)
+	})
+	assertFail(t, "Won't panic", func(tb testing.TB) {
+		tb.Helper()
+		Panics(tb, wontPanic)
+	})
+}
+
+func TestZero(t *testing.T) {
+	assertOk(t, "Empty struct", func(tb testing.TB) {
+		tb.Helper()
+		Zero(tb, Data{})
+	})
+	assertFail(t, "Non-empty struct", func(tb testing.TB) {
+		tb.Helper()
+		Zero(tb, Data{Label: "example"})
+	})
+	assertOk(t, "Nil slice", func(tb testing.TB) {
+		tb.Helper()
+		var slice []int
+		Zero(tb, slice)
+	})
+	assertFail(t, "Non-empty slice", func(tb testing.TB) {
+		tb.Helper()
+		slice := []int{1, 2, 3, 4}
+		Zero(tb, slice)
+	})
+	assertOk(t, "Zero-length slice", func(tb testing.TB) {
+		tb.Helper()
+		slice := []int{}
+		Zero(tb, slice)
+	})
+}
+
+func TestNotZero(t *testing.T) {
+	assertFail(t, "Empty struct", func(tb testing.TB) {
+		tb.Helper()
+		zero := Data{}
+		NotZero(tb, zero)
+	})
+	assertOk(t, "Non-empty struct", func(tb testing.TB) {
+		tb.Helper()
+		notZero := Data{Label: "example"}
+		NotZero(tb, notZero)
+	})
+	assertFail(t, "Nil slice", func(tb testing.TB) {
+		tb.Helper()
+		var slice []int
+		NotZero(tb, slice)
+	})
+	assertFail(t, "Zero-length slice", func(tb testing.TB) {
+		tb.Helper()
+		slice := []int{}
+		NotZero(tb, slice)
+	})
+	assertOk(t, "Non-empty slice", func(tb testing.TB) {
+		tb.Helper()
+		slice := []int{1, 2, 3, 4}
+		NotZero(tb, slice)
+	})
+}
+
+type testCase struct {
+	*testing.T
+	failed string
+}
+
+func (t *testCase) Fatal(args ...interface{}) {
+	t.failed = fmt.Sprint(args...)
+}
+
+func (t *testCase) Fatalf(message string, args ...interface{}) {
+	t.failed = fmt.Sprintf(message, args...)
+}
+
+func assertFail(t *testing.T, name string, fn func(testing.TB)) {
+	t.Helper()
+	t.Run(name, func(t *testing.T) {
+		t.Helper()
+		test := &testCase{T: t}
+		fn(test)
+		if test.failed == "" {
+			t.Fatal("Test expected to fail but did not")
+		} else {
+			t.Log(test.failed)
+		}
+	})
+}
+
+func assertOk(t *testing.T, name string, fn func(testing.TB)) {
+	t.Helper()
+	t.Run(name, func(t *testing.T) {
+		t.Helper()
+		test := &testCase{T: t}
+		fn(test)
+		if test.failed != "" {
+			t.Fatal("Test expected to succeed but did not:\n", test.failed)
+		}
+	})
+}

internal/ast/ast.go

@@ -1,138 +0,0 @@
-package ast
-
-import (
-	"fmt"
-)
-
-// Iterator starts uninitialized, you need to call Next() first.
-//
-// For example:
-//
-// it := n.Children()
-// for it.Next() {
-// 		it.Node()
-// }
-type Iterator struct {
-	started bool
-	node    Node
-}
-
-// Next moves the iterator forward and returns true if points to a node, false
-// otherwise.
-func (c *Iterator) Next() bool {
-	if !c.started {
-		c.started = true
-	} else if c.node.Valid() {
-		c.node = c.node.Next()
-	}
-	return c.node.Valid()
-}
-
-// Node returns a copy of the node pointed at by the iterator.
-func (c *Iterator) Node() Node {
-	return c.node
-}
-
-// Root contains a full AST.
-//
-// It is immutable once constructed with Builder.
-type Root struct {
-	nodes []Node
-}
-
-// Iterator over the top level nodes.
-func (r *Root) Iterator() Iterator {
-	it := Iterator{}
-	if len(r.nodes) > 0 {
-		it.node = r.nodes[0]
-	}
-	return it
-}
-
-func (r *Root) at(idx int) Node {
-	// TODO: unsafe to point to the node directly
-	return r.nodes[idx]
-}
-
-// Arrays have one child per element in the array.
-// InlineTables have one child per key-value pair in the table.
-// KeyValues have at least two children. The first one is the value. The
-// rest make a potentially dotted key.
-// Table and Array table have one child per element of the key they
-// represent (same as KeyValue, but without the last node being the value).
-// children []Node
-type Node struct {
-	Kind Kind
-	Data []byte // Raw bytes from the input
-
-	// next idx (in the root array). 0 if last of the collection.
-	next int
-	// child idx (in the root array). 0 if no child.
-	child int
-	// pointer to the root array
-	root *Root
-}
-
-// Next returns a copy of the next node, or an invalid Node if there is no
-// next node.
-func (n Node) Next() Node {
-	if n.next <= 0 {
-		return noNode
-	}
-	return n.root.at(n.next)
-}
-
-// Child returns a copy of the first child node of this node. Other children
-// can be accessed calling Next on the first child.
-// Returns an invalid Node if there is none.
-func (n Node) Child() Node {
-	if n.child <= 0 {
-		return noNode
-	}
-	return n.root.at(n.child)
-}
-
-// Valid returns true if the node's kind is set (not to Invalid).
-func (n Node) Valid() bool {
-	return n.Kind != Invalid
-}
-
-var noNode = Node{}
-
-// Key returns the child nodes making the Key on a supported node. Panics
-// otherwise.
-// They are guaranteed to be all be of the Kind Key. A simple key would return
-// just one element.
-func (n *Node) Key() Iterator {
-	switch n.Kind {
-	case KeyValue:
-		value := n.Child()
-		if !value.Valid() {
-			panic(fmt.Errorf("KeyValue should have at least two children"))
-		}
-		return Iterator{node: value.Next()}
-	case Table, ArrayTable:
-		return Iterator{node: n.Child()}
-	default:
-		panic(fmt.Errorf("Key() is not supported on a %s", n.Kind))
-	}
-}
-
-// Value returns a pointer to the value node of a KeyValue.
-// Guaranteed to be non-nil.
-// Panics if not called on a KeyValue node, or if the Children are malformed.
-func (n Node) Value() Node {
-	assertKind(KeyValue, n)
-	return n.Child()
-}
-
-// Children returns an iterator over a node's children.
-func (n Node) Children() Iterator {
-	return Iterator{node: n.Child()}
-}
-
-func assertKind(k Kind, n Node) {
-	if n.Kind != k {
-		panic(fmt.Errorf("method was expecting a %s, not a %s", k, n.Kind))
-	}
-}

internal/ast/builder.go

@@ -1,60 +0,0 @@
-package ast
-
-type Reference struct {
-	idx int
-	set bool
-}
-
-func (r Reference) Valid() bool {
-	return r.set
-}
-
-type Builder struct {
-	tree    Root
-	lastIdx int
-}
-
-func (b *Builder) Tree() *Root {
-	return &b.tree
-}
-
-func (b *Builder) NodeAt(ref Reference) Node {
-	return b.tree.at(ref.idx)
-}
-
-func (b *Builder) Reset() {
-	b.tree.nodes = b.tree.nodes[:0]
-	b.lastIdx = 0
-}
-
-func (b *Builder) Push(n Node) Reference {
-	n.root = &b.tree
-	b.lastIdx = len(b.tree.nodes)
-	b.tree.nodes = append(b.tree.nodes, n)
-	return Reference{
-		idx: b.lastIdx,
-		set: true,
-	}
-}
-
-func (b *Builder) PushAndChain(n Node) Reference {
-	n.root = &b.tree
-	newIdx := len(b.tree.nodes)
-	b.tree.nodes = append(b.tree.nodes, n)
-	if b.lastIdx >= 0 {
-		b.tree.nodes[b.lastIdx].next = newIdx
-	}
-	b.lastIdx = newIdx
-	return Reference{
-		idx: b.lastIdx,
-		set: true,
-	}
-}
-
-func (b *Builder) AttachChild(parent Reference, child Reference) {
-	b.tree.nodes[parent.idx].child = child.idx
-}
-
-func (b *Builder) Chain(from Reference, to Reference) {
-	b.tree.nodes[from.idx].next = to.idx
-}

internal/ast/kind.go

@@ -1,69 +0,0 @@
-package ast
-
-import "fmt"
-
-type Kind int
-
-const (
-	// meta
-	Invalid Kind = iota
-	Comment
-	Key
-
-	// top level structures
-	Table
-	ArrayTable
-	KeyValue
-
-	// containers values
-	Array
-	InlineTable
-
-	// values
-	String
-	Bool
-	Float
-	Integer
-	LocalDate
-	LocalDateTime
-	DateTime
-	Time
-)
-
-func (k Kind) String() string {
-	switch k {
-	case Invalid:
-		return "Invalid"
-	case Comment:
-		return "Comment"
-	case Key:
-		return "Key"
-	case Table:
-		return "Table"
-	case ArrayTable:
-		return "ArrayTable"
-	case KeyValue:
-		return "KeyValue"
-	case Array:
-		return "Array"
-	case InlineTable:
-		return "InlineTable"
-	case String:
-		return "String"
-	case Bool:
-		return "Bool"
-	case Float:
-		return "Float"
-	case Integer:
-		return "Integer"
-	case LocalDate:
-		return "LocalDate"
-	case LocalDateTime:
-		return "LocalDateTime"
-	case DateTime:
-		return "DateTime"
-	case Time:
-		return "Time"
-	}
-	panic(fmt.Errorf("Kind.String() not implemented for '%d'", k))
-}

internal/characters/ascii.go

@@ -0,0 +1,42 @@
+package characters
+
+var invalidASCIITable = [256]bool{
+	0x00: true,
+	0x01: true,
+	0x02: true,
+	0x03: true,
+	0x04: true,
+	0x05: true,
+	0x06: true,
+	0x07: true,
+	0x08: true,
+	// 0x09 TAB
+	// 0x0A LF
+	0x0B: true,
+	0x0C: true,
+	// 0x0D CR
+	0x0E: true,
+	0x0F: true,
+	0x10: true,
+	0x11: true,
+	0x12: true,
+	0x13: true,
+	0x14: true,
+	0x15: true,
+	0x16: true,
+	0x17: true,
+	0x18: true,
+	0x19: true,
+	0x1A: true,
+	0x1B: true,
+	0x1C: true,
+	0x1D: true,
+	0x1E: true,
+	0x1F: true,
+	// 0x20 - 0x7E Printable ASCII characters
+	0x7F: true,
+}
+
+func InvalidASCII(b byte) bool {
+	return invalidASCIITable[b]
+}

internal/characters/utf8.go

@@ -0,0 +1,175 @@
+// Package characters provides functions for working with string encodings.
+package characters
+
+import (
+	"unicode/utf8"
+)
+
+// Utf8TomlValidAlreadyEscaped verifies that a given string is only made of
+// valid UTF-8 characters allowed by the TOML spec:
+//
+// Any Unicode character may be used except those that must be escaped:
+// quotation mark, backslash, and the control characters other than tab (U+0000
+// to U+0008, U+000A to U+001F, U+007F).
+//
+// It is a copy of the Go 1.17 utf8.Valid implementation, tweaked to exit early
+// when a character is not allowed.
+//
+// The returned slice is empty if the string is valid, or contains the bytes
+// of the invalid character.
+//
+// quotation mark => already checked
+// backslash => already checked
+// 0-0x8 => invalid
+// 0x9 => tab, ok
+// 0xA - 0x1F => invalid
+// 0x7F => invalid
+func Utf8TomlValidAlreadyEscaped(p []byte) []byte {
+	// Fast path. Check for and skip 8 bytes of ASCII characters per iteration.
+	for len(p) >= 8 {
+		// Combining two 32 bit loads allows the same code to be used
+		// for 32 and 64 bit platforms.
+		// The compiler can generate a 32bit load for first32 and second32
+		// on many platforms. See test/codegen/memcombine.go.
+		first32 := uint32(p[0]) | uint32(p[1])<<8 | uint32(p[2])<<16 | uint32(p[3])<<24
+		second32 := uint32(p[4]) | uint32(p[5])<<8 | uint32(p[6])<<16 | uint32(p[7])<<24
+		if (first32|second32)&0x80808080 != 0 {
+			// Found a non ASCII byte (>= RuneSelf).
+			break
+		}
+
+		for i, b := range p[:8] {
+			if InvalidASCII(b) {
+				return p[i : i+1]
+			}
+		}
+
+		p = p[8:]
+	}
+	n := len(p)
+	for i := 0; i < n; {
+		pi := p[i]
+		if pi < utf8.RuneSelf {
+			if InvalidASCII(pi) {
+				return p[i : i+1]
+			}
+			i++
+			continue
+		}
+		x := first[pi]
+		if x == xx {
+			// Illegal starter byte.
+			return p[i : i+1]
+		}
+		size := int(x & 7)
+		if i+size > n {
+			// Short or invalid.
+			return p[i:n]
+		}
+		accept := acceptRanges[x>>4]
+		if c := p[i+1]; c < accept.lo || accept.hi < c {
+			return p[i : i+2]
+		} else if size == 2 { //revive:disable:empty-block
+		} else if c := p[i+2]; c < locb || hicb < c {
+			return p[i : i+3]
+		} else if size == 3 { //revive:disable:empty-block
+		} else if c := p[i+3]; c < locb || hicb < c {
+			return p[i : i+4]
+		}
+		i += size
+	}
+	return nil
+}
+
+// Utf8ValidNext returns the size of the next rune if valid, 0 otherwise.
+func Utf8ValidNext(p []byte) int {
+	c := p[0]
+
+	if c < utf8.RuneSelf {
+		if InvalidASCII(c) {
+			return 0
+		}
+		return 1
+	}
+
+	x := first[c]
+	if x == xx {
+		// Illegal starter byte.
+		return 0
+	}
+	size := int(x & 7)
+	if size > len(p) {
+		// Short or invalid.
+		return 0
+	}
+	accept := acceptRanges[x>>4]
+	if c := p[1]; c < accept.lo || accept.hi < c {
+		return 0
+	} else if size == 2 { //nolint:revive
+	} else if c := p[2]; c < locb || hicb < c {
+		return 0
+	} else if size == 3 { //nolint:revive
+	} else if c := p[3]; c < locb || hicb < c {
+		return 0
+	}
+
+	return size
+}
+
+// acceptRange gives the range of valid values for the second byte in a UTF-8
+// sequence.
+type acceptRange struct {
+	lo uint8 // lowest value for second byte.
+	hi uint8 // highest value for second byte.
+}
+
+// acceptRanges has size 16 to avoid bounds checks in the code that uses it.
+var acceptRanges = [16]acceptRange{
+	0: {locb, hicb},
+	1: {0xA0, hicb},
+	2: {locb, 0x9F},
+	3: {0x90, hicb},
+	4: {locb, 0x8F},
+}
+
+// first is information about the first byte in a UTF-8 sequence.
+var first = [256]uint8{
+	//   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
+	as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x00-0x0F
+	as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x10-0x1F
+	as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x20-0x2F
+	as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x30-0x3F
+	as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x40-0x4F
+	as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x50-0x5F
+	as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x60-0x6F
+	as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x70-0x7F
+	//   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
+	xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0x80-0x8F
+	xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0x90-0x9F
+	xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xA0-0xAF
+	xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xB0-0xBF
+	xx, xx, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xC0-0xCF
+	s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xD0-0xDF
+	s2, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s4, s3, s3, // 0xE0-0xEF
+	s5, s6, s6, s6, s7, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xF0-0xFF
+}
+
+const (
+	// The default lowest and highest continuation byte.
+	locb = 0b10000000
+	hicb = 0b10111111
+
+	// These names of these constants are chosen to give nice alignment in the
+	// table below. The first nibble is an index into acceptRanges or F for
+	// special one-byte cases. The second nibble is the Rune length or the
+	// Status for the special one-byte case.
+	xx = 0xF1 // invalid: size 1
+	as = 0xF0 // ASCII: size 1
+	s1 = 0x02 // accept 0, size 2
+	s2 = 0x13 // accept 1, size 3
+	s3 = 0x03 // accept 0, size 3
+	s4 = 0x23 // accept 2, size 3
+	s5 = 0x34 // accept 3, size 4
+	s6 = 0x04 // accept 0, size 4
+	s7 = 0x44 // accept 4, size 4
+)

internal/cli/cli.go

@@ -0,0 +1,87 @@
+// Package cli provides common functions for command-line programs.
+package cli
+
+import (
+	"bytes"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"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 conversion in place on each provided file.
+	Inplace bool
+}
+
+func (p *Program) Execute() {
+	flag.Usage = func() { fmt.Fprint(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, stderr io.Writer) int {
+	err := p.run(files, input, output)
+	if err != nil {
+		var derr *toml.DecodeError
+		if errors.As(err, &derr) {
+			_, _ = fmt.Fprintln(stderr, derr.String())
+			row, col := derr.Position()
+			_, _ = fmt.Fprintln(stderr, "error occurred at row", row, "column", col)
+		} else {
+			_, _ = fmt.Fprintln(stderr, 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 func() { _ = 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 := os.ReadFile(path) // #nosec G304
+	if err != nil {
+		return err
+	}
+
+	out := new(bytes.Buffer)
+
+	err = p.Fn(bytes.NewReader(in), out)
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(path, out.Bytes(), 0o600)
+}

internal/cli/cli_test.go

@@ -0,0 +1,166 @@
+package cli
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"os"
+	"path"
+	"strings"
+	"testing"
+
+	"github.com/pelletier/go-toml/v2"
+	"github.com/pelletier/go-toml/v2/internal/assert"
+)
+
+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(io.Reader, io.Writer) error {
+		return nil
+	})
+
+	assert.Equal(t, 0, exit)
+	assert.Zero(t, stdout.String())
+	assert.Zero(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(io.Reader, io.Writer) error {
+		return errors.New("something bad")
+	})
+
+	assert.Equal(t, -1, exit)
+	assert.Zero(t, stdout.String())
+	assert.NotZero(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(io.Reader, io.Writer) error {
+		var v interface{}
+		return toml.Unmarshal([]byte(`qwe = 001`), &v)
+	})
+
+	assert.Equal(t, -1, exit)
+	assert.Zero(t, stdout.String())
+	assert.True(t, strings.Contains(stderr.String(), "error occurred at"))
+}
+
+func TestProcessMainFileExists(t *testing.T) {
+	tmpfile, err := os.CreateTemp(t.TempDir(), "example")
+	assert.NoError(t, err)
+	_, err = tmpfile.WriteString(`some data`)
+	assert.NoError(t, err)
+	assert.NoError(t, tmpfile.Close())
+
+	stdout := new(bytes.Buffer)
+	stderr := new(bytes.Buffer)
+
+	exit := processMain([]string{tmpfile.Name()}, nil, stdout, stderr, func(io.Reader, io.Writer) error {
+		return nil
+	})
+
+	assert.Equal(t, 0, exit)
+	assert.Zero(t, stdout.String())
+	assert.Zero(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(io.Reader, io.Writer) error {
+		return nil
+	})
+
+	assert.Equal(t, -1, exit)
+	assert.Zero(t, stdout.String())
+	assert.NotZero(t, stderr.String())
+}
+
+func TestProcessMainFilesInPlace(t *testing.T) {
+	dir := t.TempDir()
+
+	path1 := path.Join(dir, "file1")
+	path2 := path.Join(dir, "file2")
+
+	err := os.WriteFile(path1, []byte("content 1"), 0o600)
+	assert.NoError(t, err)
+	err = os.WriteFile(path2, []byte("content 2"), 0o600)
+	assert.NoError(t, err)
+
+	p := Program{
+		Fn:      dummyFileFn,
+		Inplace: true,
+	}
+
+	exit := p.main([]string{path1, path2}, os.Stdin, os.Stdout, os.Stderr)
+
+	assert.Equal(t, 0, exit)
+
+	v1, err := os.ReadFile(path1)
+	assert.NoError(t, err)
+	assert.Equal(t, "1", string(v1))
+
+	v2, err := os.ReadFile(path2)
+	assert.NoError(t, err)
+	assert.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)
+
+	assert.Equal(t, -1, exit)
+}
+
+func TestProcessMainFilesInPlaceFailFn(t *testing.T) {
+	dir := t.TempDir()
+
+	path1 := path.Join(dir, "file1")
+
+	err := os.WriteFile(path1, []byte("content 1"), 0o600)
+	assert.NoError(t, err)
+
+	p := Program{
+		Fn:      func(io.Reader, io.Writer) error { return errors.New("oh no") },
+		Inplace: true,
+	}
+
+	exit := p.main([]string{path1}, os.Stdin, os.Stdout, os.Stderr)
+
+	assert.Equal(t, -1, exit)
+
+	v1, err := os.ReadFile(path1)
+	assert.NoError(t, err)
+	assert.Equal(t, "content 1", string(v1))
+}
+
+func dummyFileFn(r io.Reader, w io.Writer) error {
+	b, err := io.ReadAll(r)
+	if err != nil {
+		return err
+	}
+	v := strings.SplitN(string(b), " ", 2)[1]
+	_, err = w.Write([]byte(v))
+	return err
+}

internal/imported_tests/marshal_imported_test.go

@@ -1,14 +1,15 @@
-package imported_tests
+package imported_tests //revive:disable:var-naming
 
 // Those tests have been imported from v1, but adjust to match the new
 // defaults of v2.
 
 import (
+	"fmt"
 	"testing"
 	"time"
 
 	"github.com/pelletier/go-toml/v2"
-	"github.com/stretchr/testify/require"
+	"github.com/pelletier/go-toml/v2/internal/assert"
 )
 
 func TestDocMarshal(t *testing.T) {
@@ -20,12 +21,12 @@ func TestDocMarshal(t *testing.T) {
 		Subdocs     testDocSubs       `toml:"subdoc"`
 		Basics      testDocBasics     `toml:"basic"`
 		SubDocList  []testSubDoc      `toml:"subdoclist"`
-		err         int               `toml:"shouldntBeHere"`
+		err         int               `toml:"shouldntBeHere"` //nolint:unused
 		unexported  int               `toml:"shouldntBeHere"`
 		Unexported2 int               `toml:"-"`
 	}
 
-	var docData = testDoc{
+	docData := testDoc{
 		Title:       "TOML Marshal Testing",
 		unexported:  0,
 		Unexported2: 0,
@@ -66,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]
@@ -88,7 +90,6 @@ name = 'Second'
 [subdoc.first]
 name = 'First'
 
-
 [basic]
 uint = 5001
 bool = true
@@ -100,34 +101,34 @@ date = 1979-05-27T07:32:00Z
 
 [[subdoclist]]
 name = 'List.First'
+
 [[subdoclist]]
 name = 'List.Second'
-
 `
 
 	result, err := toml.Marshal(docData)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, marshalTestToml, string(result))
+	assert.Equal(t, marshalTestToml, string(result))
 }
 
 func TestBasicMarshalQuotedKey(t *testing.T) {
 	result, err := toml.Marshal(quotedKeyMarshalTestData)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
 	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))
+	assert.Equal(t, expected, string(result))
-
 }
 
 func TestEmptyMarshal(t *testing.T) {
@@ -151,16 +152,47 @@ func TestEmptyMarshal(t *testing.T) {
 		Map:        map[string]string{},
 	}
 	result, err := toml.Marshal(doc)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
 	expected := `title = 'Placeholder'
 bool = false
 int = 0
 string = ''
 stringlist = []
-[map]
 
+[map]
 `
 
-	require.Equal(t, string(expected), string(result))
+	assert.Equal(t, expected, string(result))
+}
+
+type textMarshaler struct {
+	FirstName string
+	LastName  string
+}
+
+func (m textMarshaler) MarshalText() ([]byte, error) {
+	fullName := fmt.Sprintf("%s %s", m.FirstName, m.LastName)
+	return []byte(fullName), nil
+}
+
+func TestTextMarshaler(t *testing.T) {
+	type wrap struct {
+		TM textMarshaler
+	}
+
+	m := textMarshaler{FirstName: "Sally", LastName: "Fields"}
+
+	t.Run("at root", func(t *testing.T) {
+		_, err := toml.Marshal(m)
+		// in v2 we do not allow TextMarshaler at root
+		assert.Error(t, err)
+	})
+
+	t.Run("leaf", func(t *testing.T) {
+		res, err := toml.Marshal(wrap{m})
+		assert.NoError(t, err)
+
+		assert.Equal(t, "TM = 'Sally Fields'\n", string(res))
+	})
 }

internal/testsuite/add.go

@@ -0,0 +1,75 @@
+package testsuite
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"time"
+
+	"github.com/pelletier/go-toml/v2"
+)
+
+// addTag adds JSON tags to a data structure as expected by toml-test.
+func addTag(tomlData interface{}) interface{} {
+	// Switch on the data type.
+	switch orig := tomlData.(type) {
+	default:
+		// return map[string]interface{}{}
+		panic(fmt.Sprintf("Unknown type: %T", tomlData))
+
+	// A table: we don't need to add any tags, just recurse for every table
+	// entry.
+	case map[string]interface{}:
+		typed := make(map[string]interface{}, len(orig))
+		for k, v := range orig {
+			typed[k] = addTag(v)
+		}
+		return typed
+
+	// An array: we don't need to add any tags, just recurse for every table
+	// entry.
+	case []map[string]interface{}:
+		typed := make([]map[string]interface{}, len(orig))
+		for i, v := range orig {
+			typed[i] = addTag(v).(map[string]interface{})
+		}
+		return typed
+	case []interface{}:
+		typed := make([]interface{}, len(orig))
+		for i, v := range orig {
+			typed[i] = addTag(v)
+		}
+		return typed
+
+	// Datetime: tag as datetime.
+	case toml.LocalTime:
+		return tag("time-local", orig.String())
+	case toml.LocalDate:
+		return tag("date-local", orig.String())
+	case toml.LocalDateTime:
+		return tag("datetime-local", orig.String())
+	case time.Time:
+		return tag("datetime", orig.Format("2006-01-02T15:04:05.999999999Z07:00"))
+
+	// Tag primitive values: bool, string, int, and float64.
+	case bool:
+		return tag("bool", strconv.FormatBool(orig))
+	case string:
+		return tag("string", orig)
+	case int64:
+		return tag("integer", strconv.FormatInt(orig, 10))
+	case float64:
+		// Special case for nan since NaN == NaN is false.
+		if math.IsNaN(orig) {
+			return tag("float", "nan")
+		}
+		return tag("float", fmt.Sprintf("%v", orig))
+	}
+}
+
+func tag(typeName string, data interface{}) map[string]interface{} {
+	return map[string]interface{}{
+		"type":  typeName,
+		"value": data,
+	}
+}

internal/testsuite/json.go

@@ -0,0 +1,244 @@
+package testsuite
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+func CmpJSON(t *testing.T, key string, want, have interface{}) {
+	t.Helper()
+	switch w := want.(type) {
+	case map[string]interface{}:
+		cmpJSONMaps(t, key, w, have)
+	case []interface{}:
+		cmpJSONArrays(t, key, w, have)
+	default:
+		t.Errorf(
+			"Key '%s' in expected output should be a map or a list of maps, but it's a %T",
+			key, want)
+	}
+}
+
+func cmpJSONMaps(t *testing.T, key string, want map[string]interface{}, have interface{}) {
+	t.Helper()
+	haveMap, ok := have.(map[string]interface{})
+	if !ok {
+		mismatch(t, key, "table", want, haveMap)
+		return
+	}
+
+	// Check to make sure both or neither are values.
+	if isValue(want) && !isValue(haveMap) {
+		t.Fatalf("Key '%s' is supposed to be a value, but the parser reports it as a table", key)
+	}
+	if !isValue(want) && isValue(haveMap) {
+		t.Fatalf("Key '%s' is supposed to be a table, but the parser reports it as a value", key)
+	}
+	if isValue(want) && isValue(haveMap) {
+		cmpJSONValues(t, key, want, haveMap)
+		return
+	}
+
+	// Check that the keys of each map are equivalent.
+	for k := range want {
+		if _, ok := haveMap[k]; !ok {
+			bunk := kjoin(key, k)
+			t.Fatalf("Could not find key '%s' in parser output.", bunk)
+		}
+	}
+	for k := range haveMap {
+		if _, ok := want[k]; !ok {
+			bunk := kjoin(key, k)
+			t.Fatalf("Could not find key '%s' in expected output.", bunk)
+		}
+	}
+
+	// Okay, now make sure that each value is equivalent.
+	for k := range want {
+		CmpJSON(t, kjoin(key, k), want[k], haveMap[k])
+	}
+}
+
+func cmpJSONArrays(t *testing.T, key string, want, have interface{}) {
+	t.Helper()
+	wantSlice, ok := want.([]interface{})
+	if !ok {
+		panic(fmt.Sprintf("'value' should be a JSON array when 'type=array', but it is a %T", want))
+	}
+
+	haveSlice, ok := have.([]interface{})
+	if !ok {
+		t.Fatalf("Malformed output from your encoder: 'value' is not a JSON array: %T", have)
+	}
+
+	if len(wantSlice) != len(haveSlice) {
+		t.Fatalf("Array lengths differ for key '%s':\n"+
+			"  Expected:     %d\n"+
+			"  Your encoder: %d",
+			key, len(wantSlice), len(haveSlice))
+	}
+	for i := 0; i < len(wantSlice); i++ {
+		CmpJSON(t, key, wantSlice[i], haveSlice[i])
+	}
+}
+
+func cmpJSONValues(t *testing.T, key string, want, have map[string]interface{}) {
+	t.Helper()
+	wantType, ok := want["type"].(string)
+	if !ok {
+		panic(fmt.Sprintf("'type' should be a string, but it is a %T", want["type"]))
+	}
+
+	haveType, ok := have["type"].(string)
+	if !ok {
+		t.Fatalf("Malformed output from your encoder: 'type' is not a string: %T", have["type"])
+	}
+
+	if wantType != haveType {
+		valMismatch(t, key, wantType, haveType, want, have)
+	}
+
+	// If this is an array, then we've got to do some work to check equality.
+	if wantType == "array" {
+		cmpJSONArrays(t, key, want, have)
+		return
+	}
+
+	// Atomic values are always strings
+	wantVal, ok := want["value"].(string)
+	if !ok {
+		panic(fmt.Sprintf("'value' %v should be a string, but it is a %[1]T", want["value"]))
+	}
+
+	haveVal, ok := have["value"].(string)
+	if !ok {
+		panic(fmt.Sprintf("Malformed output from your encoder: %T is not a string", have["value"]))
+	}
+
+	// Excepting floats and datetimes, other values can be compared as strings.
+	switch wantType {
+	case "float":
+		cmpFloats(t, key, wantVal, haveVal)
+	case "datetime", "datetime-local", "date-local", "time-local":
+		cmpAsDatetimes(t, key, wantType, wantVal, haveVal)
+	default:
+		cmpAsStrings(t, key, wantVal, haveVal)
+	}
+}
+
+func cmpAsStrings(t *testing.T, key string, want, have string) {
+	t.Helper()
+	if want != have {
+		t.Fatalf("Values for key '%s' don't match:\n"+
+			"  Expected:     %s\n"+
+			"  Your encoder: %s",
+			key, want, have)
+	}
+}
+
+func cmpFloats(t *testing.T, key string, want, have string) {
+	t.Helper()
+	// Special case for NaN, since NaN != NaN.
+	if strings.HasSuffix(want, "nan") || strings.HasSuffix(have, "nan") {
+		if want != have {
+			t.Fatalf("Values for key '%s' don't match:\n"+
+				"  Expected:     %v\n"+
+				"  Your encoder: %v",
+				key, want, have)
+		}
+		return
+	}
+
+	wantF, err := strconv.ParseFloat(want, 64)
+	if err != nil {
+		panic(fmt.Sprintf("Could not read '%s' as a float value for key '%s'", want, key))
+	}
+
+	haveF, err := strconv.ParseFloat(have, 64)
+	if err != nil {
+		panic(fmt.Sprintf("Malformed output from your encoder: key '%s' is not a float: '%s'", key, have))
+	}
+
+	if wantF != haveF {
+		t.Fatalf("Values for key '%s' don't match:\n"+
+			"  Expected:     %v\n"+
+			"  Your encoder: %v",
+			key, wantF, haveF)
+	}
+}
+
+var datetimeRepl = strings.NewReplacer(
+	" ", "T",
+	"t", "T",
+	"z", "Z")
+
+var layouts = map[string]string{
+	"datetime":       time.RFC3339Nano,
+	"datetime-local": "2006-01-02T15:04:05.999999999",
+	"date-local":     "2006-01-02",
+	"time-local":     "15:04:05",
+}
+
+func cmpAsDatetimes(t *testing.T, key string, kind, want, have string) {
+	t.Helper()
+	layout, ok := layouts[kind]
+	if !ok {
+		panic("should never happen")
+	}
+
+	wantT, err := time.Parse(layout, datetimeRepl.Replace(want))
+	if err != nil {
+		panic(fmt.Sprintf("Could not read '%s' as a datetime value for key '%s'", want, key))
+	}
+
+	haveT, err := time.Parse(layout, datetimeRepl.Replace(want))
+	if err != nil {
+		t.Fatalf("Malformed output from your encoder: key '%s' is not a datetime: '%s'", key, have)
+		return
+	}
+	if !wantT.Equal(haveT) {
+		t.Fatalf("Values for key '%s' don't match:\n"+
+			"  Expected:     %v\n"+
+			"  Your encoder: %v",
+			key, wantT, haveT)
+	}
+}
+
+func kjoin(old, key string) string {
+	if len(old) == 0 {
+		return key
+	}
+	return old + "." + key
+}
+
+func isValue(m map[string]interface{}) bool {
+	if len(m) != 2 {
+		return false
+	}
+	if _, ok := m["type"]; !ok {
+		return false
+	}
+	if _, ok := m["value"]; !ok {
+		return false
+	}
+	return true
+}
+
+func mismatch(t *testing.T, key string, wantType string, want, have interface{}) {
+	t.Helper()
+	t.Fatalf("Key '%s' is not an %s but %[4]T:\n"+
+		"  Expected:     %#[3]v\n"+
+		"  Your encoder: %#[4]v",
+		key, wantType, want, have)
+}
+
+func valMismatch(t *testing.T, key string, wantType, haveType string, want, have interface{}) {
+	t.Helper()
+	t.Fatalf("Key '%s' is not an %s but %s:\n"+
+		"  Expected:     %#[3]v\n"+
+		"  Your encoder: %#[4]v",
+		key, wantType, haveType, want, have)
+}

internal/testsuite/rm.go

@@ -0,0 +1,116 @@
+package testsuite
+
+import (
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/pelletier/go-toml/v2"
+)
+
+// Remove JSON tags to a data structure as returned by toml-test.
+func rmTag(typedJSON interface{}) (interface{}, error) {
+	// Check if key is in the table m.
+	in := func(key string, m map[string]interface{}) bool {
+		_, ok := m[key]
+		return ok
+	}
+
+	// Switch on the data type.
+	switch v := typedJSON.(type) {
+	// Object: this can either be a TOML table or a primitive with tags.
+	case map[string]interface{}:
+		// This value represents a primitive: remove the tags and return just
+		// the primitive value.
+		if len(v) == 2 && in("type", v) && in("value", v) {
+			ut, err := untag(v)
+			if err != nil {
+				return ut, fmt.Errorf("tag.Remove: %w", err)
+			}
+			return ut, nil
+		}
+
+		// Table: remove tags on all children.
+		m := make(map[string]interface{}, len(v))
+		for k, v2 := range v {
+			var err error
+			m[k], err = rmTag(v2)
+			if err != nil {
+				return nil, err
+			}
+		}
+		return m, nil
+
+	// Array: remove tags from all items.
+	case []interface{}:
+		a := make([]interface{}, len(v))
+		for i := range v {
+			var err error
+			a[i], err = rmTag(v[i])
+			if err != nil {
+				return nil, err
+			}
+		}
+		return a, nil
+	}
+
+	// The top level must be an object or array.
+	return nil, fmt.Errorf("unrecognized JSON format '%T'", typedJSON)
+}
+
+// Return a primitive: read the "type" and convert the "value" to that.
+func untag(typed map[string]interface{}) (interface{}, error) {
+	t := typed["type"].(string)
+	v := typed["value"].(string)
+	switch t {
+	case "string":
+		return v, nil
+	case "integer":
+		n, err := strconv.ParseInt(v, 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("untag: %w", err)
+		}
+		return n, nil
+	case "float":
+		f, err := strconv.ParseFloat(v, 64)
+		if err != nil {
+			return nil, fmt.Errorf("untag: %w", err)
+		}
+		return f, nil
+
+		// toml.LocalDate{Year:2020, Month:12, Day:12}
+	case "datetime":
+		return time.Parse("2006-01-02T15:04:05.999999999Z07:00", v)
+	case "datetime-local":
+		var t toml.LocalDateTime
+		err := t.UnmarshalText([]byte(v))
+		if err != nil {
+			return nil, fmt.Errorf("untag: %w", err)
+		}
+		return t, nil
+	case "date-local":
+		var t toml.LocalDate
+		err := t.UnmarshalText([]byte(v))
+		if err != nil {
+			return nil, fmt.Errorf("untag: %w", err)
+		}
+		return t, nil
+	case "time-local":
+		var t toml.LocalTime
+		err := t.UnmarshalText([]byte(v))
+		if err != nil {
+			return nil, fmt.Errorf("untag: %w", err)
+		}
+		return t, nil
+	case "bool":
+		switch v {
+		case "true":
+			return true, nil
+		case "false":
+			return false, nil
+		}
+		return nil, fmt.Errorf("untag: could not parse %q as a boolean", v)
+	}
+
+	return nil, fmt.Errorf("untag: unrecognized tag type %q", t)
+}

internal/testsuite/testsuite.go

@@ -0,0 +1,68 @@
+// Package testsuite provides helper functions for interoperating with the
+// language-agnostic TOML test suite at github.com/BurntSushi/toml-test.
+package testsuite
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/pelletier/go-toml/v2"
+)
+
+// Marshal is a helper function for calling toml.Marshal
+//
+// Only needed to avoid package import loops.
+func Marshal(v interface{}) ([]byte, error) {
+	return toml.Marshal(v)
+}
+
+// Unmarshal is a helper function for calling toml.Unmarshal.
+//
+// Only needed to avoid package import loops.
+func Unmarshal(data []byte, v interface{}) error {
+	return toml.Unmarshal(data, v)
+}
+
+// ValueToTaggedJSON takes a data structure and returns the tagged JSON
+// representation.
+func ValueToTaggedJSON(doc interface{}) ([]byte, error) {
+	return json.MarshalIndent(addTag(doc), "", "  ")
+}
+
+// DecodeStdin is a helper function for the toml-test binary interface.  TOML input
+// is read from STDIN and a resulting tagged JSON representation is written to
+// STDOUT.
+func DecodeStdin() error {
+	var decoded map[string]interface{}
+
+	if err := toml.NewDecoder(os.Stdin).Decode(&decoded); err != nil {
+		return fmt.Errorf("error decoding TOML: %w", err)
+	}
+
+	j := json.NewEncoder(os.Stdout)
+	j.SetIndent("", "  ")
+	if err := j.Encode(addTag(decoded)); err != nil {
+		return fmt.Errorf("error encoding JSON: %w", err)
+	}
+
+	return nil
+}
+
+// EncodeStdin is a helper function for the toml-test binary interface.  Tagged
+// JSON is read from STDIN and a resulting TOML representation is written to
+// STDOUT.
+func EncodeStdin() error {
+	var j interface{}
+	err := json.NewDecoder(os.Stdin).Decode(&j)
+	if err != nil {
+		return err
+	}
+
+	rm, err := rmTag(j)
+	if err != nil {
+		return fmt.Errorf("removing tags: %w", err)
+	}
+
+	return toml.NewEncoder(os.Stdout).Encode(rm)
+}

internal/tracker/key.go

@@ -0,0 +1,48 @@
+package tracker
+
+import "github.com/pelletier/go-toml/v2/unstable"
+
+// KeyTracker is a tracker that keeps track of the current Key as the AST is
+// walked.
+type KeyTracker struct {
+	k []string
+}
+
+// UpdateTable sets the state of the tracker with the AST table node.
+func (t *KeyTracker) UpdateTable(node *unstable.Node) {
+	t.reset()
+	t.Push(node)
+}
+
+// UpdateArrayTable sets the state of the tracker with the AST array table node.
+func (t *KeyTracker) UpdateArrayTable(node *unstable.Node) {
+	t.reset()
+	t.Push(node)
+}
+
+// Push the given key on the stack.
+func (t *KeyTracker) Push(node *unstable.Node) {
+	it := node.Key()
+	for it.Next() {
+		t.k = append(t.k, string(it.Node().Data))
+	}
+}
+
+// Pop key from stack.
+func (t *KeyTracker) Pop(node *unstable.Node) {
+	it := node.Key()
+	for it.Next() {
+		t.k = t.k[:len(t.k)-1]
+	}
+}
+
+// Key returns the current key.
+func (t *KeyTracker) Key() []string {
+	k := make([]string, len(t.k))
+	copy(k, t.k)
+	return k
+}
+
+func (t *KeyTracker) reset() {
+	t.k = t.k[:0]
+}

internal/tracker/seen.go

@@ -0,0 +1,359 @@
+package tracker
+
+import (
+	"bytes"
+	"fmt"
+	"sync"
+
+	"github.com/pelletier/go-toml/v2/unstable"
+)
+
+type keyKind uint8
+
+const (
+	invalidKind keyKind = iota
+	valueKind
+	tableKind
+	arrayTableKind
+)
+
+func (k keyKind) String() string {
+	switch k {
+	case invalidKind:
+		return "invalid"
+	case valueKind:
+		return "value"
+	case tableKind:
+		return "table"
+	case arrayTableKind:
+		return "array table"
+	}
+	panic("missing keyKind string mapping")
+}
+
+// SeenTracker tracks which keys have been seen with which TOML type to flag
+// duplicates and mismatches according to the spec.
+//
+// Each node in the visited tree is represented by an entry. Each entry has an
+// identifier, which is provided by a counter. Entries are stored in the array
+// entries. As new nodes are discovered (referenced for the first time in the
+// TOML document), entries are created and appended to the array. An entry
+// points to its parent using its id.
+//
+// To find whether a given key (sequence of []byte) has already been visited,
+// the entries are linearly searched, looking for one with the right name and
+// parent id.
+//
+// Given that all keys appear in the document after their parent, it is
+// guaranteed that all descendants of a node are stored after the node, this
+// speeds up the search process.
+//
+// When encountering [[array tables]], the descendants of that node are removed
+// to allow that branch of the tree to be "rediscovered". To maintain the
+// invariant above, the deletion process needs to keep the order of entries.
+// This results in more copies in that case.
+type SeenTracker struct {
+	entries    []entry
+	currentIdx int
+}
+
+var pool = sync.Pool{
+	New: func() interface{} {
+		return &SeenTracker{}
+	},
+}
+
+func (s *SeenTracker) reset() {
+	// Always contains a root element at index 0.
+	s.currentIdx = 0
+	if len(s.entries) == 0 {
+		s.entries = make([]entry, 1, 2)
+	} else {
+		s.entries = s.entries[:1]
+	}
+	s.entries[0].child = -1
+	s.entries[0].next = -1
+}
+
+type entry struct {
+	// Use -1 to indicate no child or no sibling.
+	child int
+	next  int
+
+	name     []byte
+	kind     keyKind
+	explicit bool
+	kv       bool
+}
+
+// Find the index of the child of parentIdx with key k. Returns -1 if
+// it does not exist.
+func (s *SeenTracker) find(parentIdx int, k []byte) int {
+	for i := s.entries[parentIdx].child; i >= 0; i = s.entries[i].next {
+		if bytes.Equal(s.entries[i].name, k) {
+			return i
+		}
+	}
+	return -1
+}
+
+// Remove all descendants of node at position idx.
+func (s *SeenTracker) clear(idx int) {
+	if idx >= len(s.entries) {
+		return
+	}
+
+	for i := s.entries[idx].child; i >= 0; {
+		next := s.entries[i].next
+		n := s.entries[0].next
+		s.entries[0].next = i
+		s.entries[i].next = n
+		s.entries[i].name = nil
+		s.clear(i)
+		i = next
+	}
+
+	s.entries[idx].child = -1
+}
+
+func (s *SeenTracker) create(parentIdx int, name []byte, kind keyKind, explicit bool, kv bool) int {
+	e := entry{
+		child: -1,
+		next:  s.entries[parentIdx].child,
+
+		name:     name,
+		kind:     kind,
+		explicit: explicit,
+		kv:       kv,
+	}
+	var idx int
+	if s.entries[0].next >= 0 {
+		idx = s.entries[0].next
+		s.entries[0].next = s.entries[idx].next
+		s.entries[idx] = e
+	} else {
+		idx = len(s.entries)
+		s.entries = append(s.entries, e)
+	}
+
+	s.entries[parentIdx].child = idx
+
+	return idx
+}
+
+func (s *SeenTracker) setExplicitFlag(parentIdx int) {
+	for i := s.entries[parentIdx].child; i >= 0; i = s.entries[i].next {
+		if s.entries[i].kv {
+			s.entries[i].explicit = true
+			s.entries[i].kv = false
+		}
+		s.setExplicitFlag(i)
+	}
+}
+
+// CheckExpression takes a top-level node and checks that it does not contain
+// keys that have been seen in previous calls, and validates that types are
+// consistent. It returns true if it is the first time this node's key is seen.
+// Useful to clear array tables on first use.
+func (s *SeenTracker) CheckExpression(node *unstable.Node) (bool, error) {
+	if s.entries == nil {
+		s.reset()
+	}
+	switch node.Kind {
+	case unstable.KeyValue:
+		return s.checkKeyValue(node)
+	case unstable.Table:
+		return s.checkTable(node)
+	case unstable.ArrayTable:
+		return s.checkArrayTable(node)
+	default:
+		panic(fmt.Errorf("this should not be a top level node type: %s", node.Kind))
+	}
+}
+
+func (s *SeenTracker) checkTable(node *unstable.Node) (bool, error) {
+	if s.currentIdx >= 0 {
+		s.setExplicitFlag(s.currentIdx)
+	}
+
+	it := node.Key()
+
+	parentIdx := 0
+
+	// This code is duplicated in checkArrayTable. This is because factoring
+	// it in a function requires to copy the iterator, or allocate it to the
+	// heap, which is not cheap.
+	for it.Next() {
+		if it.IsLast() {
+			break
+		}
+
+		k := it.Node().Data
+
+		idx := s.find(parentIdx, k)
+
+		if idx < 0 {
+			idx = s.create(parentIdx, k, tableKind, false, false)
+		} else {
+			entry := s.entries[idx]
+			if entry.kind == valueKind {
+				return false, fmt.Errorf("toml: expected %s to be a table, not a %s", string(k), entry.kind)
+			}
+		}
+		parentIdx = idx
+	}
+
+	k := it.Node().Data
+	idx := s.find(parentIdx, k)
+
+	first := false
+	if idx >= 0 {
+		kind := s.entries[idx].kind
+		if kind != tableKind {
+			return false, fmt.Errorf("toml: key %s should be a table, not a %s", string(k), kind)
+		}
+		if s.entries[idx].explicit {
+			return false, fmt.Errorf("toml: table %s already exists", string(k))
+		}
+		s.entries[idx].explicit = true
+	} else {
+		idx = s.create(parentIdx, k, tableKind, true, false)
+		first = true
+	}
+
+	s.currentIdx = idx
+
+	return first, nil
+}
+
+func (s *SeenTracker) checkArrayTable(node *unstable.Node) (bool, error) {
+	if s.currentIdx >= 0 {
+		s.setExplicitFlag(s.currentIdx)
+	}
+
+	it := node.Key()
+
+	parentIdx := 0
+
+	for it.Next() {
+		if it.IsLast() {
+			break
+		}
+
+		k := it.Node().Data
+
+		idx := s.find(parentIdx, k)
+
+		if idx < 0 {
+			idx = s.create(parentIdx, k, tableKind, false, false)
+		} else {
+			entry := s.entries[idx]
+			if entry.kind == valueKind {
+				return false, fmt.Errorf("toml: expected %s to be a table, not a %s", string(k), entry.kind)
+			}
+		}
+
+		parentIdx = idx
+	}
+
+	k := it.Node().Data
+	idx := s.find(parentIdx, k)
+
+	firstTime := idx < 0
+	if firstTime {
+		idx = s.create(parentIdx, k, arrayTableKind, true, false)
+	} else {
+		kind := s.entries[idx].kind
+		if kind != arrayTableKind {
+			return false, fmt.Errorf("toml: key %s already exists as a %s,  but should be an array table", kind, string(k))
+		}
+		s.clear(idx)
+	}
+
+	s.currentIdx = idx
+
+	return firstTime, nil
+}
+
+func (s *SeenTracker) checkKeyValue(node *unstable.Node) (bool, error) {
+	parentIdx := s.currentIdx
+	it := node.Key()
+
+	for it.Next() {
+		k := it.Node().Data
+
+		idx := s.find(parentIdx, k)
+
+		if idx < 0 {
+			idx = s.create(parentIdx, k, tableKind, false, true)
+		} else {
+			entry := s.entries[idx]
+			switch {
+			case it.IsLast():
+				return false, fmt.Errorf("toml: key %s is already defined", string(k))
+			case entry.kind != tableKind:
+				return false, fmt.Errorf("toml: expected %s to be a table, not a %s", string(k), entry.kind)
+			case entry.explicit:
+				return false, fmt.Errorf("toml: cannot redefine table %s that has already been explicitly defined", string(k))
+			}
+		}
+
+		parentIdx = idx
+	}
+
+	s.entries[parentIdx].kind = valueKind
+
+	value := node.Value()
+
+	switch value.Kind {
+	case unstable.InlineTable:
+		return s.checkInlineTable(value)
+	case unstable.Array:
+		return s.checkArray(value)
+	default:
+		return false, nil
+	}
+}
+
+func (s *SeenTracker) checkArray(node *unstable.Node) (first bool, err error) {
+	it := node.Children()
+	for it.Next() {
+		n := it.Node()
+		switch n.Kind { //nolint:exhaustive
+		case unstable.InlineTable:
+			first, err = s.checkInlineTable(n)
+			if err != nil {
+				return false, err
+			}
+		case unstable.Array:
+			first, err = s.checkArray(n)
+			if err != nil {
+				return false, err
+			}
+		}
+	}
+	return first, nil
+}
+
+func (s *SeenTracker) checkInlineTable(node *unstable.Node) (first bool, err error) {
+	s = pool.Get().(*SeenTracker)
+	s.reset()
+
+	it := node.Children()
+	for it.Next() {
+		n := it.Node()
+		first, err = s.checkKeyValue(n)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	// As inline tables are self-contained, the tracker does not
+	// need to retain the details of what they contain. The
+	// keyValue element that creates the inline table is kept to
+	// mark the presence of the inline table and prevent
+	// redefinition of its keys: check* functions cannot walk into
+	// a value.
+	pool.Put(s)
+	return first, nil
+}

internal/tracker/seen_test.go

@@ -0,0 +1,21 @@
+package tracker
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/pelletier/go-toml/v2/internal/assert"
+)
+
+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
+	entrySize := int(reflect.TypeOf(entry{}).Size())
+	assert.True(t,
+		entrySize <= maxExpectedEntrySize,
+		"Expected entry to be less than or equal to %d, got: %d",
+		maxExpectedEntrySize, entrySize,
+	)
+}

internal/tracker/tracker.go

@@ -1,200 +1,2 @@
+// Package tracker provides functions for keeping track of AST nodes.
 package tracker
-
-import (
-	"fmt"
-
-	"github.com/pelletier/go-toml/v2/internal/ast"
-)
-
-type keyKind uint8
-
-const (
-	invalidKind keyKind = iota
-	valueKind
-	tableKind
-	arrayTableKind
-)
-
-func (k keyKind) String() string {
-	switch k {
-	case invalidKind:
-		return "invalid"
-	case valueKind:
-		return "value"
-	case tableKind:
-		return "table"
-	case arrayTableKind:
-		return "array table"
-	}
-	panic("missing keyKind string mapping")
-}
-
-// Tracks which keys have been seen with which TOML type to flag duplicates
-// and mismatches according to the spec.
-type Seen struct {
-	root    *info
-	current *info
-}
-
-type info struct {
-	parent   *info
-	kind     keyKind
-	children map[string]*info
-	explicit bool
-}
-
-func (i *info) Clear() {
-	i.children = nil
-}
-
-func (i *info) Has(k string) (*info, bool) {
-	c, ok := i.children[k]
-	return c, ok
-}
-
-func (i *info) SetKind(kind keyKind) {
-	i.kind = kind
-}
-
-func (i *info) CreateTable(k string, explicit bool) *info {
-	return i.createChild(k, tableKind, explicit)
-}
-
-func (i *info) CreateArrayTable(k string, explicit bool) *info {
-	return i.createChild(k, arrayTableKind, explicit)
-}
-
-func (i *info) createChild(k string, kind keyKind, explicit bool) *info {
-	if i.children == nil {
-		i.children = make(map[string]*info, 1)
-	}
-
-	x := &info{
-		parent:   i,
-		kind:     kind,
-		explicit: explicit,
-	}
-	i.children[k] = x
-	return x
-}
-
-// CheckExpression takes a top-level node and checks that it does not contain keys
-// that have been seen in previous calls, and validates that types are consistent.
-func (s *Seen) CheckExpression(node ast.Node) error {
-	if s.root == nil {
-		s.root = &info{
-			kind: tableKind,
-		}
-		s.current = s.root
-	}
-	switch node.Kind {
-	case ast.KeyValue:
-		return s.checkKeyValue(s.current, node)
-	case ast.Table:
-		return s.checkTable(node)
-	case ast.ArrayTable:
-		return s.checkArrayTable(node)
-	default:
-		panic(fmt.Errorf("this should not be a top level node type: %s", node.Kind))
-	}
-
-}
-func (s *Seen) checkTable(node ast.Node) error {
-	s.current = s.root
-
-	it := node.Key()
-	// handle the first parts of the key, excluding the last one
-	for it.Next() {
-		if !it.Node().Next().Valid() {
-			break
-		}
-
-		k := string(it.Node().Data)
-		child, found := s.current.Has(k)
-		if !found {
-			child = s.current.CreateTable(k, false)
-		}
-		s.current = child
-	}
-
-	// handle the last part of the key
-	k := string(it.Node().Data)
-
-	i, found := s.current.Has(k)
-	if found {
-		if i.kind != tableKind {
-			return fmt.Errorf("key %s should be a table", k)
-		}
-		if i.explicit {
-			return fmt.Errorf("table %s already exists", k)
-		}
-		i.explicit = true
-		s.current = i
-	} else {
-		s.current = s.current.CreateTable(k, true)
-	}
-
-	return nil
-}
-
-func (s *Seen) checkArrayTable(node ast.Node) error {
-	s.current = s.root
-
-	it := node.Key()
-
-	// handle the first parts of the key, excluding the last one
-	for it.Next() {
-		if !it.Node().Next().Valid() {
-			break
-		}
-
-		k := string(it.Node().Data)
-		child, found := s.current.Has(k)
-		if !found {
-			child = s.current.CreateTable(k, false)
-		}
-		s.current = child
-	}
-
-	// handle the last part of the key
-	k := string(it.Node().Data)
-
-	info, found := s.current.Has(k)
-	if found {
-		if info.kind != arrayTableKind {
-			return fmt.Errorf("key %s already exists but is not an array table", k)
-		}
-		info.Clear()
-	} else {
-		info = s.current.CreateArrayTable(k, true)
-	}
-
-	s.current = info
-	return nil
-}
-
-func (s *Seen) checkKeyValue(context *info, node ast.Node) error {
-	it := node.Key()
-
-	// handle the first parts of the key, excluding the last one
-	for it.Next() {
-		k := string(it.Node().Data)
-		child, found := context.Has(k)
-		if found {
-			if child.kind != tableKind {
-				return fmt.Errorf("expected %s to be a table, not a %s", k, child.kind)
-			}
-		} else {
-			child = context.CreateTable(k, false)
-		}
-		context = child
-	}
-
-	if node.Value().Kind == ast.InlineTable {
-		context.SetKind(tableKind)
-	} else {
-		context.SetKind(valueKind)
-	}
-
-	return nil
-}

internal/unsafe/unsafe.go

@@ -1,35 +0,0 @@
-package unsafe
-
-import (
-	"fmt"
-	"reflect"
-	"unsafe"
-)
-
-const maxInt = uintptr(int(^uint(0) >> 1))
-
-func SubsliceOffset(data []byte, subslice []byte) int {
-	datap := (*reflect.SliceHeader)(unsafe.Pointer(&data))
-	hlp := (*reflect.SliceHeader)(unsafe.Pointer(&subslice))
-
-	if hlp.Data < datap.Data {
-		panic(fmt.Errorf("subslice address (%d) is before data address (%d)", hlp.Data, datap.Data))
-	}
-	offset := hlp.Data - datap.Data
-
-	if offset > maxInt {
-		panic(fmt.Errorf("slice offset larger than int (%d)", offset))
-	}
-
-	intoffset := int(offset)
-
-	if intoffset > datap.Len {
-		panic(fmt.Errorf("slice offset (%d) is farther than data length (%d)", intoffset, datap.Len))
-	}
-
-	if intoffset+hlp.Len > datap.Len {
-		panic(fmt.Errorf("slice ends (%d+%d) is farther than data length (%d)", intoffset, hlp.Len, datap.Len))
-	}
-
-	return intoffset
-}

internal/unsafe/unsafe_test.go

@@ -1,79 +0,0 @@
-package unsafe_test
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/pelletier/go-toml/v2/internal/unsafe"
-)
-
-func TestUnsafeSubsliceOffsetValid(t *testing.T) {
-	examples := []struct {
-		desc   string
-		test   func() ([]byte, []byte)
-		offset int
-	}{
-		{
-			desc: "simple",
-			test: func() ([]byte, []byte) {
-				data := []byte("hello")
-				return data, data[1:]
-			},
-			offset: 1,
-		},
-	}
-
-	for _, e := range examples {
-		t.Run(e.desc, func(t *testing.T) {
-			d, s := e.test()
-			offset := unsafe.SubsliceOffset(d, s)
-			assert.Equal(t, e.offset, offset)
-		})
-	}
-}
-
-func TestUnsafeSubsliceOffsetInvalid(t *testing.T) {
-	examples := []struct {
-		desc string
-		test func() ([]byte, []byte)
-	}{
-		{
-			desc: "unrelated arrays",
-			test: func() ([]byte, []byte) {
-				return []byte("one"), []byte("two")
-			},
-		},
-		{
-			desc: "slice starts before data",
-			test: func() ([]byte, []byte) {
-				full := []byte("hello world")
-				return full[5:], full[1:]
-			},
-		},
-		{
-			desc: "slice starts after data",
-			test: func() ([]byte, []byte) {
-				full := []byte("hello world")
-				return full[:3], full[5:]
-			},
-		},
-		{
-			desc: "slice ends after data",
-			test: func() ([]byte, []byte) {
-				full := []byte("hello world")
-				return full[:5], full[3:8]
-			},
-		},
-	}
-
-	for _, e := range examples {
-		t.Run(e.desc, func(t *testing.T) {
-			d, s := e.test()
-			require.Panics(t, func() {
-				unsafe.SubsliceOffset(d, s)
-			})
-		})
-	}
-}

localtime.go

@@ -1,281 +1,122 @@
-// Implementation of TOML's local date/time.
-// Copied over from https://github.com/googleapis/google-cloud-go/blob/master/civil/civil.go
-// to avoid pulling all the Google dependencies.
-//
-// Copyright 2016 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package civil implements types for civil time, a time-zone-independent
-// representation of time that follows the rules of the proleptic
-// Gregorian calendar with exactly 24-hour days, 60-minute hours, and 60-second
-// minutes.
-//
-// Because they lack location information, these types do not represent unique
-// moments or intervals of time. Use time.Time for that purpose.
 package toml
 
 import (
 	"fmt"
+	"strings"
 	"time"
+
+	"github.com/pelletier/go-toml/v2/unstable"
 )
 
-// A LocalDate represents a date (year, month, day).
+// LocalDate represents a calendar day in no specific timezone.
-//
-// This type does not include location information, and therefore does not
-// describe a unique 24-hour timespan.
 type LocalDate struct {
-	Year  int        // Year (e.g., 2014).
+	Year  int
-	Month time.Month // Month of the year (January = 1, ...).
+	Month int
-	Day   int        // Day of the month, starting at 1.
+	Day   int
 }
 
-// LocalDateOf returns the LocalDate in which a time occurs in that time's location.
+// AsTime converts d into a specific time instance at midnight in zone.
-func LocalDateOf(t time.Time) LocalDate {
+func (d LocalDate) AsTime(zone *time.Location) time.Time {
-	var d LocalDate
+	return time.Date(d.Year, time.Month(d.Month), d.Day, 0, 0, 0, 0, zone)
-	d.Year, d.Month, d.Day = t.Date()
-	return d
 }
 
-// ParseLocalDate parses a string in RFC3339 full-date format and returns the date value it represents.
+// String returns RFC 3339 representation of d.
-func ParseLocalDate(s string) (LocalDate, error) {
-	t, err := time.Parse("2006-01-02", s)
-	if err != nil {
-		return LocalDate{}, err
-	}
-	return LocalDateOf(t), nil
-}
-
-// String returns the date in RFC3339 full-date format.
 func (d LocalDate) String() string {
 	return fmt.Sprintf("%04d-%02d-%02d", d.Year, d.Month, d.Day)
 }
 
-// IsValid reports whether the date is valid.
+// MarshalText returns RFC 3339 representation of d.
-func (d LocalDate) IsValid() bool {
-	return LocalDateOf(d.In(time.UTC)) == d
-}
-
-// In returns the time corresponding to time 00:00:00 of the date in the location.
-//
-// In is always consistent with time.LocalDate, even when time.LocalDate returns a time
-// on a different day. For example, if loc is America/Indiana/Vincennes, then both
-//     time.LocalDate(1955, time.May, 1, 0, 0, 0, 0, loc)
-// and
-//     civil.LocalDate{Year: 1955, Month: time.May, Day: 1}.In(loc)
-// return 23:00:00 on April 30, 1955.
-//
-// In panics if loc is nil.
-func (d LocalDate) In(loc *time.Location) time.Time {
-	return time.Date(d.Year, d.Month, d.Day, 0, 0, 0, 0, loc)
-}
-
-// AddDays returns the date that is n days in the future.
-// n can also be negative to go into the past.
-func (d LocalDate) AddDays(n int) LocalDate {
-	return LocalDateOf(d.In(time.UTC).AddDate(0, 0, n))
-}
-
-// DaysSince returns the signed number of days between the date and s, not including the end day.
-// This is the inverse operation to AddDays.
-func (d LocalDate) DaysSince(s LocalDate) (days int) {
-	// We convert to Unix time so we do not have to worry about leap seconds:
-	// Unix time increases by exactly 86400 seconds per day.
-	deltaUnix := d.In(time.UTC).Unix() - s.In(time.UTC).Unix()
-	return int(deltaUnix / 86400)
-}
-
-// Before reports whether d1 occurs before d2.
-func (d1 LocalDate) Before(d2 LocalDate) bool {
-	if d1.Year != d2.Year {
-		return d1.Year < d2.Year
-	}
-	if d1.Month != d2.Month {
-		return d1.Month < d2.Month
-	}
-	return d1.Day < d2.Day
-}
-
-// After reports whether d1 occurs after d2.
-func (d1 LocalDate) After(d2 LocalDate) bool {
-	return d2.Before(d1)
-}
-
-// MarshalText implements the encoding.TextMarshaler interface.
-// The output is the result of d.String().
 func (d LocalDate) MarshalText() ([]byte, error) {
 	return []byte(d.String()), nil
 }
 
-// UnmarshalText implements the encoding.TextUnmarshaler interface.
+// UnmarshalText parses b using RFC 3339 to fill d.
-// The date is expected to be a string in a format accepted by ParseLocalDate.
+func (d *LocalDate) UnmarshalText(b []byte) error {
-func (d *LocalDate) UnmarshalText(data []byte) error {
+	res, err := parseLocalDate(b)
-	var err error
+	if err != nil {
-	*d, err = ParseLocalDate(string(data))
+		return err
-	return err
+	}
+	*d = res
+	return nil
 }
 
-// A LocalTime represents a time with nanosecond precision.
+// LocalTime represents a time of day of no specific day in no specific
-//
+// timezone.
-// This type does not include location information, and therefore does not
-// describe a unique moment in time.
-//
-// This type exists to represent the TIME type in storage-based APIs like BigQuery.
-// Most operations on Times are unlikely to be meaningful. Prefer the LocalDateTime type.
 type LocalTime struct {
-	Hour       int // The hour of the day in 24-hour format; range [0-23]
+	Hour       int // Hour of the day: [0; 24[
-	Minute     int // The minute of the hour; range [0-59]
+	Minute     int // Minute of the hour: [0; 60[
-	Second     int // The second of the minute; range [0-59]
+	Second     int // Second of the minute: [0; 59]
-	Nanosecond int // The nanosecond of the second; range [0-999999999]
+	Nanosecond int // Nanoseconds within the second:  [0, 1000000000[
+	Precision  int // Number of digits to display for Nanosecond.
 }
 
-// LocalTimeOf returns the LocalTime representing the time of day in which a time occurs
+// String returns RFC 3339 representation of d.
-// in that time's location. It ignores the date.
+// If d.Nanosecond and d.Precision are zero, the time won't have a nanosecond
-func LocalTimeOf(t time.Time) LocalTime {
+// component. If d.Nanosecond > 0 but d.Precision = 0, then the minimum number
-	var tm LocalTime
+// of digits for nanoseconds is provided.
-	tm.Hour, tm.Minute, tm.Second = t.Clock()
+func (d LocalTime) String() string {
-	tm.Nanosecond = t.Nanosecond()
+	s := fmt.Sprintf("%02d:%02d:%02d", d.Hour, d.Minute, d.Second)
-	return tm
+
+	if d.Precision > 0 {
+		s += fmt.Sprintf(".%09d", d.Nanosecond)[:d.Precision+1]
+	} else if d.Nanosecond > 0 {
+		// Nanoseconds are specified, but precision is not provided. Use the
+		// minimum.
+		s += strings.Trim(fmt.Sprintf(".%09d", d.Nanosecond), "0")
+	}
+
+	return s
 }
 
-// ParseLocalTime parses a string and returns the time value it represents.
+// MarshalText returns RFC 3339 representation of d.
-// ParseLocalTime accepts an extended form of the RFC3339 partial-time format. After
+func (d LocalTime) MarshalText() ([]byte, error) {
-// the HH:MM:SS part of the string, an optional fractional part may appear,
+	return []byte(d.String()), nil
-// consisting of a decimal point followed by one to nine decimal digits.
+}
-// (RFC3339 admits only one digit after the decimal point).
+
-func ParseLocalTime(s string) (LocalTime, error) {
+// UnmarshalText parses b using RFC 3339 to fill d.
-	t, err := time.Parse("15:04:05.999999999", s)
+func (d *LocalTime) UnmarshalText(b []byte) error {
+	res, left, err := parseLocalTime(b)
+	if err == nil && len(left) != 0 {
+		err = unstable.NewParserError(left, "extra characters")
+	}
 	if err != nil {
-		return LocalTime{}, err
+		return err
 	}
-	return LocalTimeOf(t), nil
+	*d = res
+	return nil
 }
 
-// String returns the date in the format described in ParseLocalTime. If Nanoseconds
+// LocalDateTime represents a time of a specific day in no specific timezone.
-// is zero, no fractional part will be generated. Otherwise, the result will
-// end with a fractional part consisting of a decimal point and nine digits.
-func (t LocalTime) String() string {
-	s := fmt.Sprintf("%02d:%02d:%02d", t.Hour, t.Minute, t.Second)
-	if t.Nanosecond == 0 {
-		return s
-	}
-	return s + fmt.Sprintf(".%09d", t.Nanosecond)
-}
-
-// IsValid reports whether the time is valid.
-func (t LocalTime) IsValid() bool {
-	// Construct a non-zero time.
-	tm := time.Date(2, 2, 2, t.Hour, t.Minute, t.Second, t.Nanosecond, time.UTC)
-	return LocalTimeOf(tm) == t
-}
-
-// MarshalText implements the encoding.TextMarshaler interface.
-// The output is the result of t.String().
-func (t LocalTime) MarshalText() ([]byte, error) {
-	return []byte(t.String()), nil
-}
-
-// UnmarshalText implements the encoding.TextUnmarshaler interface.
-// The time is expected to be a string in a format accepted by ParseLocalTime.
-func (t *LocalTime) UnmarshalText(data []byte) error {
-	var err error
-	*t, err = ParseLocalTime(string(data))
-	return err
-}
-
-// A LocalDateTime represents a date and time.
-//
-// This type does not include location information, and therefore does not
-// describe a unique moment in time.
 type LocalDateTime struct {
-	Date LocalDate
+	LocalDate
-	Time LocalTime
+	LocalTime
 }
 
-// Note: We deliberately do not embed LocalDate into LocalDateTime, to avoid promoting AddDays and Sub.
+// AsTime converts d into a specific time instance in zone.
+func (d LocalDateTime) AsTime(zone *time.Location) time.Time {
+	return time.Date(d.Year, time.Month(d.Month), d.Day, d.Hour, d.Minute, d.Second, d.Nanosecond, zone)
+}
 
-// LocalDateTimeOf returns the LocalDateTime in which a time occurs in that time's location.
+// String returns RFC 3339 representation of d.
-func LocalDateTimeOf(t time.Time) LocalDateTime {
+func (d LocalDateTime) String() string {
-	return LocalDateTime{
+	return d.LocalDate.String() + "T" + d.LocalTime.String()
-		Date: LocalDateOf(t),
+}
-		Time: LocalTimeOf(t),
+
+// MarshalText returns RFC 3339 representation of d.
+func (d LocalDateTime) MarshalText() ([]byte, error) {
+	return []byte(d.String()), nil
+}
+
+// UnmarshalText parses b using RFC 3339 to fill d.
+func (d *LocalDateTime) UnmarshalText(data []byte) error {
+	res, left, err := parseLocalDateTime(data)
+	if err == nil && len(left) != 0 {
+		err = unstable.NewParserError(left, "extra characters")
 	}
-}
-
-// ParseLocalDateTime parses a string and returns the LocalDateTime it represents.
-// ParseLocalDateTime accepts a variant of the RFC3339 date-time format that omits
-// the time offset but includes an optional fractional time, as described in
-// ParseLocalTime. Informally, the accepted format is
-//     YYYY-MM-DDTHH:MM:SS[.FFFFFFFFF]
-// where the 'T' may be a lower-case 't'.
-func ParseLocalDateTime(s string) (LocalDateTime, error) {
-	t, err := time.Parse("2006-01-02T15:04:05.999999999", s)
 	if err != nil {
-		t, err = time.Parse("2006-01-02t15:04:05.999999999", s)
+		return err
-		if err != nil {
-			return LocalDateTime{}, err
-		}
 	}
-	return LocalDateTimeOf(t), nil
-}
 
-// String returns the date in the format described in ParseLocalDate.
+	*d = res
-func (dt LocalDateTime) String() string {
+	return nil
-	return dt.Date.String() + "T" + dt.Time.String()
-}
-
-// IsValid reports whether the datetime is valid.
-func (dt LocalDateTime) IsValid() bool {
-	return dt.Date.IsValid() && dt.Time.IsValid()
-}
-
-// In returns the time corresponding to the LocalDateTime in the given location.
-//
-// If the time is missing or ambigous at the location, In returns the same
-// result as time.LocalDate. For example, if loc is America/Indiana/Vincennes, then
-// both
-//     time.LocalDate(1955, time.May, 1, 0, 30, 0, 0, loc)
-// and
-//     civil.LocalDateTime{
-//         civil.LocalDate{Year: 1955, Month: time.May, Day: 1}},
-//         civil.LocalTime{Minute: 30}}.In(loc)
-// return 23:30:00 on April 30, 1955.
-//
-// In panics if loc is nil.
-func (dt LocalDateTime) In(loc *time.Location) time.Time {
-	return time.Date(dt.Date.Year, dt.Date.Month, dt.Date.Day, dt.Time.Hour, dt.Time.Minute, dt.Time.Second, dt.Time.Nanosecond, loc)
-}
-
-// Before reports whether dt1 occurs before dt2.
-func (dt1 LocalDateTime) Before(dt2 LocalDateTime) bool {
-	return dt1.In(time.UTC).Before(dt2.In(time.UTC))
-}
-
-// After reports whether dt1 occurs after dt2.
-func (dt1 LocalDateTime) After(dt2 LocalDateTime) bool {
-	return dt2.Before(dt1)
-}
-
-// MarshalText implements the encoding.TextMarshaler interface.
-// The output is the result of dt.String().
-func (dt LocalDateTime) MarshalText() ([]byte, error) {
-	return []byte(dt.String()), nil
-}
-
-// UnmarshalText implements the encoding.TextUnmarshaler interface.
-// The datetime is expected to be a string in a format accepted by ParseLocalDateTime
-func (dt *LocalDateTime) UnmarshalText(data []byte) error {
-	var err error
-	*dt, err = ParseLocalDateTime(string(data))
-	return err
 }

localtime_test.go

@@ -1,446 +1,118 @@
-// Copyright 2016 Google LLC
+package toml_test
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package toml
 
 import (
-	"encoding/json"
-	"reflect"
 	"testing"
 	"time"
+
+	"github.com/pelletier/go-toml/v2"
+	"github.com/pelletier/go-toml/v2/internal/assert"
 )
 
-func cmpEqual(x, y interface{}) bool {
+func TestLocalDate_AsTime(t *testing.T) {
-	return reflect.DeepEqual(x, y)
+	d := toml.LocalDate{2021, 6, 8}
+	cast := d.AsTime(time.UTC)
+	assert.Equal(t, time.Date(2021, time.June, 8, 0, 0, 0, 0, time.UTC), cast)
 }
 
-func TestDates(t *testing.T) {
+func TestLocalDate_String(t *testing.T) {
-	for _, test := range []struct {
+	d := toml.LocalDate{2021, 6, 8}
-		date     LocalDate
+	assert.Equal(t, "2021-06-08", d.String())
-		loc      *time.Location
-		wantStr  string
-		wantTime time.Time
-	}{
-		{
-			date:     LocalDate{2014, 7, 29},
-			loc:      time.Local,
-			wantStr:  "2014-07-29",
-			wantTime: time.Date(2014, time.July, 29, 0, 0, 0, 0, time.Local),
-		},
-		{
-			date:     LocalDateOf(time.Date(2014, 8, 20, 15, 8, 43, 1, time.Local)),
-			loc:      time.UTC,
-			wantStr:  "2014-08-20",
-			wantTime: time.Date(2014, 8, 20, 0, 0, 0, 0, time.UTC),
-		},
-		{
-			date:     LocalDateOf(time.Date(999, time.January, 26, 0, 0, 0, 0, time.Local)),
-			loc:      time.UTC,
-			wantStr:  "0999-01-26",
-			wantTime: time.Date(999, 1, 26, 0, 0, 0, 0, time.UTC),
-		},
-	} {
-		if got := test.date.String(); got != test.wantStr {
-			t.Errorf("%#v.String() = %q, want %q", test.date, got, test.wantStr)
-		}
-		if got := test.date.In(test.loc); !got.Equal(test.wantTime) {
-			t.Errorf("%#v.In(%v) = %v, want %v", test.date, test.loc, got, test.wantTime)
-		}
-	}
 }
 
-func TestDateIsValid(t *testing.T) {
+func TestLocalDate_MarshalText(t *testing.T) {
-	for _, test := range []struct {
+	d := toml.LocalDate{2021, 6, 8}
-		date LocalDate
+	b, err := d.MarshalText()
-		want bool
+	assert.NoError(t, err)
-	}{
+	assert.Equal(t, []byte("2021-06-08"), b)
-		{LocalDate{2014, 7, 29}, true},
-		{LocalDate{2000, 2, 29}, true},
-		{LocalDate{10000, 12, 31}, true},
-		{LocalDate{1, 1, 1}, true},
-		{LocalDate{0, 1, 1}, true},  // year zero is OK
-		{LocalDate{-1, 1, 1}, true}, // negative year is OK
-		{LocalDate{1, 0, 1}, false},
-		{LocalDate{1, 1, 0}, false},
-		{LocalDate{2016, 1, 32}, false},
-		{LocalDate{2016, 13, 1}, false},
-		{LocalDate{1, -1, 1}, false},
-		{LocalDate{1, 1, -1}, false},
-	} {
-		got := test.date.IsValid()
-		if got != test.want {
-			t.Errorf("%#v: got %t, want %t", test.date, got, test.want)
-		}
-	}
 }
 
-func TestParseDate(t *testing.T) {
+func TestLocalDate_UnmarshalMarshalText(t *testing.T) {
-	for _, test := range []struct {
+	d := toml.LocalDate{}
-		str  string
+	err := d.UnmarshalText([]byte("2021-06-08"))
-		want LocalDate // if empty, expect an error
+	assert.NoError(t, err)
-	}{
+	assert.Equal(t, toml.LocalDate{2021, 6, 8}, d)
-		{"2016-01-02", LocalDate{2016, 1, 2}},
+
-		{"2016-12-31", LocalDate{2016, 12, 31}},
+	err = d.UnmarshalText([]byte("what"))
-		{"0003-02-04", LocalDate{3, 2, 4}},
+	assert.Error(t, err)
-		{"999-01-26", LocalDate{}},
-		{"", LocalDate{}},
-		{"2016-01-02x", LocalDate{}},
-	} {
-		got, err := ParseLocalDate(test.str)
-		if got != test.want {
-			t.Errorf("ParseLocalDate(%q) = %+v, want %+v", test.str, got, test.want)
-		}
-		if err != nil && test.want != (LocalDate{}) {
-			t.Errorf("Unexpected error %v from ParseLocalDate(%q)", err, test.str)
-		}
-	}
 }
 
-func TestDateArithmetic(t *testing.T) {
+func TestLocalTime_String(t *testing.T) {
-	for _, test := range []struct {
+	d := toml.LocalTime{20, 12, 1, 2, 9}
-		desc  string
+	assert.Equal(t, "20:12:01.000000002", d.String())
-		start LocalDate
+	d = toml.LocalTime{20, 12, 1, 0, 0}
-		end   LocalDate
+	assert.Equal(t, "20:12:01", d.String())
-		days  int
+	d = toml.LocalTime{20, 12, 1, 0, 9}
-	}{
+	assert.Equal(t, "20:12:01.000000000", d.String())
-		{
+	d = toml.LocalTime{20, 12, 1, 100, 0}
-			desc:  "zero days noop",
+	assert.Equal(t, "20:12:01.0000001", d.String())
-			start: LocalDate{2014, 5, 9},
-			end:   LocalDate{2014, 5, 9},
-			days:  0,
-		},
-		{
-			desc:  "crossing a year boundary",
-			start: LocalDate{2014, 12, 31},
-			end:   LocalDate{2015, 1, 1},
-			days:  1,
-		},
-		{
-			desc:  "negative number of days",
-			start: LocalDate{2015, 1, 1},
-			end:   LocalDate{2014, 12, 31},
-			days:  -1,
-		},
-		{
-			desc:  "full leap year",
-			start: LocalDate{2004, 1, 1},
-			end:   LocalDate{2005, 1, 1},
-			days:  366,
-		},
-		{
-			desc:  "full non-leap year",
-			start: LocalDate{2001, 1, 1},
-			end:   LocalDate{2002, 1, 1},
-			days:  365,
-		},
-		{
-			desc:  "crossing a leap second",
-			start: LocalDate{1972, 6, 30},
-			end:   LocalDate{1972, 7, 1},
-			days:  1,
-		},
-		{
-			desc:  "dates before the unix epoch",
-			start: LocalDate{101, 1, 1},
-			end:   LocalDate{102, 1, 1},
-			days:  365,
-		},
-	} {
-		if got := test.start.AddDays(test.days); got != test.end {
-			t.Errorf("[%s] %#v.AddDays(%v) = %#v, want %#v", test.desc, test.start, test.days, got, test.end)
-		}
-		if got := test.end.DaysSince(test.start); got != test.days {
-			t.Errorf("[%s] %#v.Sub(%#v) = %v, want %v", test.desc, test.end, test.start, got, test.days)
-		}
-	}
 }
 
-func TestDateBefore(t *testing.T) {
+func TestLocalTime_MarshalText(t *testing.T) {
-	for _, test := range []struct {
+	d := toml.LocalTime{20, 12, 1, 2, 9}
-		d1, d2 LocalDate
+	b, err := d.MarshalText()
-		want   bool
+	assert.NoError(t, err)
-	}{
+	assert.Equal(t, []byte("20:12:01.000000002"), b)
-		{LocalDate{2016, 12, 31}, LocalDate{2017, 1, 1}, true},
-		{LocalDate{2016, 1, 1}, LocalDate{2016, 1, 1}, false},
-		{LocalDate{2016, 12, 30}, LocalDate{2016, 12, 31}, true},
-		{LocalDate{2016, 1, 30}, LocalDate{2016, 12, 31}, true},
-	} {
-		if got := test.d1.Before(test.d2); got != test.want {
-			t.Errorf("%v.Before(%v): got %t, want %t", test.d1, test.d2, got, test.want)
-		}
-	}
 }
 
-func TestDateAfter(t *testing.T) {
+func TestLocalTime_UnmarshalMarshalText(t *testing.T) {
-	for _, test := range []struct {
+	d := toml.LocalTime{}
-		d1, d2 LocalDate
+	err := d.UnmarshalText([]byte("20:12:01.000000002"))
-		want   bool
+	assert.NoError(t, err)
-	}{
+	assert.Equal(t, toml.LocalTime{20, 12, 1, 2, 9}, d)
-		{LocalDate{2016, 12, 31}, LocalDate{2017, 1, 1}, false},
+
-		{LocalDate{2016, 1, 1}, LocalDate{2016, 1, 1}, false},
+	err = d.UnmarshalText([]byte("what"))
-		{LocalDate{2016, 12, 30}, LocalDate{2016, 12, 31}, false},
+	assert.Error(t, err)
-	} {
+
-		if got := test.d1.After(test.d2); got != test.want {
+	err = d.UnmarshalText([]byte("20:12:01.000000002 bad"))
-			t.Errorf("%v.After(%v): got %t, want %t", test.d1, test.d2, got, test.want)
+	assert.Error(t, err)
-		}
-	}
 }
 
-func TestTimeToString(t *testing.T) {
+func TestLocalTime_RoundTrip(t *testing.T) {
-	for _, test := range []struct {
+	var d struct{ A toml.LocalTime }
-		str       string
+	err := toml.Unmarshal([]byte("a=20:12:01.500"), &d)
-		time      LocalTime
+	assert.NoError(t, err)
-		roundTrip bool // ParseLocalTime(str).String() == str?
+	assert.Equal(t, "20:12:01.500", d.A.String())
-	}{
-		{"13:26:33", LocalTime{13, 26, 33, 0}, true},
-		{"01:02:03.000023456", LocalTime{1, 2, 3, 23456}, true},
-		{"00:00:00.000000001", LocalTime{0, 0, 0, 1}, true},
-		{"13:26:03.1", LocalTime{13, 26, 3, 100000000}, false},
-		{"13:26:33.0000003", LocalTime{13, 26, 33, 300}, false},
-	} {
-		gotTime, err := ParseLocalTime(test.str)
-		if err != nil {
-			t.Errorf("ParseLocalTime(%q): got error: %v", test.str, err)
-			continue
-		}
-		if gotTime != test.time {
-			t.Errorf("ParseLocalTime(%q) = %+v, want %+v", test.str, gotTime, test.time)
-		}
-		if test.roundTrip {
-			gotStr := test.time.String()
-			if gotStr != test.str {
-				t.Errorf("%#v.String() = %q, want %q", test.time, gotStr, test.str)
-			}
-		}
-	}
 }
 
-func TestTimeOf(t *testing.T) {
+func TestLocalDateTime_AsTime(t *testing.T) {
-	for _, test := range []struct {
+	d := toml.LocalDateTime{
-		time time.Time
+		toml.LocalDate{2021, 6, 8},
-		want LocalTime
+		toml.LocalTime{20, 12, 1, 2, 9},
-	}{
-		{time.Date(2014, 8, 20, 15, 8, 43, 1, time.Local), LocalTime{15, 8, 43, 1}},
-		{time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC), LocalTime{0, 0, 0, 0}},
-	} {
-		if got := LocalTimeOf(test.time); got != test.want {
-			t.Errorf("LocalTimeOf(%v) = %+v, want %+v", test.time, got, test.want)
-		}
 	}
+	cast := d.AsTime(time.UTC)
+	assert.Equal(t, time.Date(2021, time.June, 8, 20, 12, 1, 2, time.UTC), cast)
 }
 
-func TestTimeIsValid(t *testing.T) {
+func TestLocalDateTime_String(t *testing.T) {
-	for _, test := range []struct {
+	d := toml.LocalDateTime{
-		time LocalTime
+		toml.LocalDate{2021, 6, 8},
-		want bool
+		toml.LocalTime{20, 12, 1, 2, 9},
-	}{
-		{LocalTime{0, 0, 0, 0}, true},
-		{LocalTime{23, 0, 0, 0}, true},
-		{LocalTime{23, 59, 59, 999999999}, true},
-		{LocalTime{24, 59, 59, 999999999}, false},
-		{LocalTime{23, 60, 59, 999999999}, false},
-		{LocalTime{23, 59, 60, 999999999}, false},
-		{LocalTime{23, 59, 59, 1000000000}, false},
-		{LocalTime{-1, 0, 0, 0}, false},
-		{LocalTime{0, -1, 0, 0}, false},
-		{LocalTime{0, 0, -1, 0}, false},
-		{LocalTime{0, 0, 0, -1}, false},
-	} {
-		got := test.time.IsValid()
-		if got != test.want {
-			t.Errorf("%#v: got %t, want %t", test.time, got, test.want)
-		}
 	}
+	assert.Equal(t, "2021-06-08T20:12:01.000000002", d.String())
 }
 
-func TestDateTimeToString(t *testing.T) {
+func TestLocalDateTime_MarshalText(t *testing.T) {
-	for _, test := range []struct {
+	d := toml.LocalDateTime{
-		str       string
+		toml.LocalDate{2021, 6, 8},
-		dateTime  LocalDateTime
+		toml.LocalTime{20, 12, 1, 2, 9},
-		roundTrip bool // ParseLocalDateTime(str).String() == str?
-	}{
-		{"2016-03-22T13:26:33", LocalDateTime{LocalDate{2016, 03, 22}, LocalTime{13, 26, 33, 0}}, true},
-		{"2016-03-22T13:26:33.000000600", LocalDateTime{LocalDate{2016, 03, 22}, LocalTime{13, 26, 33, 600}}, true},
-		{"2016-03-22t13:26:33", LocalDateTime{LocalDate{2016, 03, 22}, LocalTime{13, 26, 33, 0}}, false},
-	} {
-		gotDateTime, err := ParseLocalDateTime(test.str)
-		if err != nil {
-			t.Errorf("ParseLocalDateTime(%q): got error: %v", test.str, err)
-			continue
-		}
-		if gotDateTime != test.dateTime {
-			t.Errorf("ParseLocalDateTime(%q) = %+v, want %+v", test.str, gotDateTime, test.dateTime)
-		}
-		if test.roundTrip {
-			gotStr := test.dateTime.String()
-			if gotStr != test.str {
-				t.Errorf("%#v.String() = %q, want %q", test.dateTime, gotStr, test.str)
-			}
-		}
 	}
+	b, err := d.MarshalText()
+	assert.NoError(t, err)
+	assert.Equal(t, []byte("2021-06-08T20:12:01.000000002"), b)
 }
 
-func TestParseDateTimeErrors(t *testing.T) {
+func TestLocalDateTime_UnmarshalMarshalText(t *testing.T) {
-	for _, str := range []string{
+	d := toml.LocalDateTime{}
-		"",
+	err := d.UnmarshalText([]byte("2021-06-08 20:12:01.000000002"))
-		"2016-03-22",           // just a date
+	assert.NoError(t, err)
-		"13:26:33",             // just a time
+	assert.Equal(t, toml.LocalDateTime{
-		"2016-03-22 13:26:33",  // wrong separating character
+		toml.LocalDate{2021, 6, 8},
-		"2016-03-22T13:26:33x", // extra at end
+		toml.LocalTime{20, 12, 1, 2, 9},
-	} {
+	}, d)
-		if _, err := ParseLocalDateTime(str); err == nil {
+
-			t.Errorf("ParseLocalDateTime(%q) succeeded, want error", str)
+	err = d.UnmarshalText([]byte("what"))
-		}
+	assert.Error(t, err)
-	}
+
-}
+	err = d.UnmarshalText([]byte("2021-06-08 20:12:01.000000002 bad"))
-
+	assert.Error(t, err)
-func TestDateTimeOf(t *testing.T) {
-	for _, test := range []struct {
-		time time.Time
-		want LocalDateTime
-	}{
-		{time.Date(2014, 8, 20, 15, 8, 43, 1, time.Local),
-			LocalDateTime{LocalDate{2014, 8, 20}, LocalTime{15, 8, 43, 1}}},
-		{time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC),
-			LocalDateTime{LocalDate{1, 1, 1}, LocalTime{0, 0, 0, 0}}},
-	} {
-		if got := LocalDateTimeOf(test.time); got != test.want {
-			t.Errorf("LocalDateTimeOf(%v) = %+v, want %+v", test.time, got, test.want)
-		}
-	}
-}
-
-func TestDateTimeIsValid(t *testing.T) {
-	// No need to be exhaustive here; it's just LocalDate.IsValid && LocalTime.IsValid.
-	for _, test := range []struct {
-		dt   LocalDateTime
-		want bool
-	}{
-		{LocalDateTime{LocalDate{2016, 3, 20}, LocalTime{0, 0, 0, 0}}, true},
-		{LocalDateTime{LocalDate{2016, -3, 20}, LocalTime{0, 0, 0, 0}}, false},
-		{LocalDateTime{LocalDate{2016, 3, 20}, LocalTime{24, 0, 0, 0}}, false},
-	} {
-		got := test.dt.IsValid()
-		if got != test.want {
-			t.Errorf("%#v: got %t, want %t", test.dt, got, test.want)
-		}
-	}
-}
-
-func TestDateTimeIn(t *testing.T) {
-	dt := LocalDateTime{LocalDate{2016, 1, 2}, LocalTime{3, 4, 5, 6}}
-	got := dt.In(time.UTC)
-	want := time.Date(2016, 1, 2, 3, 4, 5, 6, time.UTC)
-	if !got.Equal(want) {
-		t.Errorf("got %v, want %v", got, want)
-	}
-}
-
-func TestDateTimeBefore(t *testing.T) {
-	d1 := LocalDate{2016, 12, 31}
-	d2 := LocalDate{2017, 1, 1}
-	t1 := LocalTime{5, 6, 7, 8}
-	t2 := LocalTime{5, 6, 7, 9}
-	for _, test := range []struct {
-		dt1, dt2 LocalDateTime
-		want     bool
-	}{
-		{LocalDateTime{d1, t1}, LocalDateTime{d2, t1}, true},
-		{LocalDateTime{d1, t1}, LocalDateTime{d1, t2}, true},
-		{LocalDateTime{d2, t1}, LocalDateTime{d1, t1}, false},
-		{LocalDateTime{d2, t1}, LocalDateTime{d2, t1}, false},
-	} {
-		if got := test.dt1.Before(test.dt2); got != test.want {
-			t.Errorf("%v.Before(%v): got %t, want %t", test.dt1, test.dt2, got, test.want)
-		}
-	}
-}
-
-func TestDateTimeAfter(t *testing.T) {
-	d1 := LocalDate{2016, 12, 31}
-	d2 := LocalDate{2017, 1, 1}
-	t1 := LocalTime{5, 6, 7, 8}
-	t2 := LocalTime{5, 6, 7, 9}
-	for _, test := range []struct {
-		dt1, dt2 LocalDateTime
-		want     bool
-	}{
-		{LocalDateTime{d1, t1}, LocalDateTime{d2, t1}, false},
-		{LocalDateTime{d1, t1}, LocalDateTime{d1, t2}, false},
-		{LocalDateTime{d2, t1}, LocalDateTime{d1, t1}, true},
-		{LocalDateTime{d2, t1}, LocalDateTime{d2, t1}, false},
-	} {
-		if got := test.dt1.After(test.dt2); got != test.want {
-			t.Errorf("%v.After(%v): got %t, want %t", test.dt1, test.dt2, got, test.want)
-		}
-	}
-}
-
-func TestMarshalJSON(t *testing.T) {
-	for _, test := range []struct {
-		value interface{}
-		want  string
-	}{
-		{LocalDate{1987, 4, 15}, `"1987-04-15"`},
-		{LocalTime{18, 54, 2, 0}, `"18:54:02"`},
-		{LocalDateTime{LocalDate{1987, 4, 15}, LocalTime{18, 54, 2, 0}}, `"1987-04-15T18:54:02"`},
-	} {
-		bgot, err := json.Marshal(test.value)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if got := string(bgot); got != test.want {
-			t.Errorf("%#v: got %s, want %s", test.value, got, test.want)
-		}
-	}
-}
-
-func TestUnmarshalJSON(t *testing.T) {
-	var d LocalDate
-	var tm LocalTime
-	var dt LocalDateTime
-	for _, test := range []struct {
-		data string
-		ptr  interface{}
-		want interface{}
-	}{
-		{`"1987-04-15"`, &d, &LocalDate{1987, 4, 15}},
-		{`"1987-04-\u0031\u0035"`, &d, &LocalDate{1987, 4, 15}},
-		{`"18:54:02"`, &tm, &LocalTime{18, 54, 2, 0}},
-		{`"1987-04-15T18:54:02"`, &dt, &LocalDateTime{LocalDate{1987, 4, 15}, LocalTime{18, 54, 2, 0}}},
-	} {
-		if err := json.Unmarshal([]byte(test.data), test.ptr); err != nil {
-			t.Fatalf("%s: %v", test.data, err)
-		}
-		if !cmpEqual(test.ptr, test.want) {
-			t.Errorf("%s: got %#v, want %#v", test.data, test.ptr, test.want)
-		}
-	}
-
-	for _, bad := range []string{"", `""`, `"bad"`, `"1987-04-15x"`,
-		`19870415`,     // a JSON number
-		`11987-04-15x`, // not a JSON string
-
-	} {
-		if json.Unmarshal([]byte(bad), &d) == nil {
-			t.Errorf("%q, LocalDate: got nil, want error", bad)
-		}
-		if json.Unmarshal([]byte(bad), &tm) == nil {
-			t.Errorf("%q, LocalTime: got nil, want error", bad)
-		}
-		if json.Unmarshal([]byte(bad), &dt) == nil {
-			t.Errorf("%q, LocalDateTime: got nil, want error", bad)
-		}
-	}
 }

ossfuzz/fuzz.go

@@ -0,0 +1,44 @@
+// Package ossfuzz provides a fuzzing target for OSS-Fuzz.
+package ossfuzz
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"github.com/pelletier/go-toml/v2"
+)
+
+// FuzzToml is the fuzzing target.
+func FuzzToml(data []byte) int {
+	if len(data) >= 2048 {
+		return 0
+	}
+
+	if strings.Contains(string(data), "nan") {
+		return 0
+	}
+
+	var v interface{}
+	err := toml.Unmarshal(data, &v)
+	if err != nil {
+		return 0
+	}
+
+	encoded, err := toml.Marshal(v)
+	if err != nil {
+		panic(fmt.Sprintf("failed to marshal unmarshaled document: %s", err))
+	}
+
+	var v2 interface{}
+	err = toml.Unmarshal(encoded, &v2)
+	if err != nil {
+		panic(fmt.Sprintf("failed round trip: %s", err))
+	}
+
+	if !reflect.DeepEqual(v, v2) {
+		panic(fmt.Sprintf("not equal: %#+v %#+v", v, v2))
+	}
+
+	return 1
+}

parser.go

@@ -1,920 +0,0 @@
-package toml
-
-import (
-	"bytes"
-	"fmt"
-	"strconv"
-
-	"github.com/pelletier/go-toml/v2/internal/ast"
-)
-
-type parser struct {
-	builder ast.Builder
-	ref     ast.Reference
-	data    []byte
-	left    []byte
-	err     error
-	first   bool
-}
-
-func (p *parser) Reset(b []byte) {
-	p.builder.Reset()
-	p.ref = ast.Reference{}
-	p.data = b
-	p.left = b
-	p.err = nil
-	p.first = true
-}
-
-func (p *parser) NextExpression() bool {
-	if len(p.left) == 0 || p.err != nil {
-		return false
-	}
-
-	p.builder.Reset()
-	p.ref = ast.Reference{}
-
-	for {
-		if len(p.left) == 0 || p.err != nil {
-			return false
-		}
-
-		if !p.first {
-			p.left, p.err = p.parseNewline(p.left)
-		}
-
-		if len(p.left) == 0 || p.err != nil {
-			return false
-		}
-
-		p.ref, p.left, p.err = p.parseExpression(p.left)
-
-		if p.err != nil {
-			return false
-		}
-
-		if p.ref.Valid() {
-			return true
-		}
-
-		p.first = false
-	}
-}
-
-func (p *parser) Expression() ast.Node {
-	return p.builder.NodeAt(p.ref)
-}
-
-func (p *parser) Error() error {
-	return p.err
-}
-
-func (p *parser) parseNewline(b []byte) ([]byte, error) {
-	if b[0] == '\n' {
-		return b[1:], nil
-	}
-	if b[0] == '\r' {
-		_, rest, err := scanWindowsNewline(b)
-		return rest, err
-	}
-	return nil, fmt.Errorf("expected newline but got %#U", b[0])
-}
-
-func (p *parser) parseExpression(b []byte) (ast.Reference, []byte, error) {
-	//expression =  ws [ comment ]
-	//expression =/ ws keyval ws [ comment ]
-	//expression =/ ws table ws [ comment ]
-
-	var ref ast.Reference
-
-	b = p.parseWhitespace(b)
-
-	if len(b) == 0 {
-		return ref, b, nil
-	}
-
-	if b[0] == '#' {
-		_, rest, err := scanComment(b)
-		return ref, rest, err
-	}
-	if b[0] == '\n' || b[0] == '\r' {
-		return ref, b, nil
-	}
-
-	var err error
-	if b[0] == '[' {
-		ref, b, err = p.parseTable(b)
-	} else {
-		ref, b, err = p.parseKeyval(b)
-	}
-	if err != nil {
-		return ref, nil, err
-	}
-
-	b = p.parseWhitespace(b)
-
-	if len(b) > 0 && b[0] == '#' {
-		_, rest, err := scanComment(b)
-		return ref, rest, err
-	}
-
-	return ref, b, nil
-}
-
-func (p *parser) parseTable(b []byte) (ast.Reference, []byte, error) {
-	//table = std-table / array-table
-	if len(b) > 1 && b[1] == '[' {
-		return p.parseArrayTable(b)
-	}
-	return p.parseStdTable(b)
-}
-
-func (p *parser) parseArrayTable(b []byte) (ast.Reference, []byte, error) {
-	//array-table = array-table-open key array-table-close
-	//array-table-open  = %x5B.5B ws  ; [[ Double left square bracket
-	//array-table-close = ws %x5D.5D  ; ]] Double right square bracket
-
-	ref := p.builder.Push(ast.Node{
-		Kind: ast.ArrayTable,
-	})
-
-	b = b[2:]
-	b = p.parseWhitespace(b)
-	k, b, err := p.parseKey(b)
-	if err != nil {
-		return ref, nil, err
-	}
-	p.builder.AttachChild(ref, k)
-	b = p.parseWhitespace(b)
-	b, err = expect(']', b)
-	if err != nil {
-		return ref, nil, err
-	}
-	b, err = expect(']', b)
-	return ref, b, err
-}
-
-func (p *parser) parseStdTable(b []byte) (ast.Reference, []byte, error) {
-	//std-table = std-table-open key std-table-close
-	//std-table-open  = %x5B ws     ; [ Left square bracket
-	//std-table-close = ws %x5D     ; ] Right square bracket
-
-	ref := p.builder.Push(ast.Node{
-		Kind: ast.Table,
-	})
-
-	b = b[1:]
-	b = p.parseWhitespace(b)
-	key, b, err := p.parseKey(b)
-	if err != nil {
-		return ref, nil, err
-	}
-
-	p.builder.AttachChild(ref, key)
-
-	b = p.parseWhitespace(b)
-
-	b, err = expect(']', b)
-
-	return ref, b, err
-}
-
-func (p *parser) parseKeyval(b []byte) (ast.Reference, []byte, error) {
-	//keyval = key keyval-sep val
-
-	ref := p.builder.Push(ast.Node{
-		Kind: ast.KeyValue,
-	})
-
-	key, b, err := p.parseKey(b)
-	if err != nil {
-		return ast.Reference{}, nil, err
-	}
-
-	//keyval-sep = ws %x3D ws ; =
-
-	b = p.parseWhitespace(b)
-	b, err = expect('=', b)
-	if err != nil {
-		return ast.Reference{}, nil, err
-	}
-	b = p.parseWhitespace(b)
-
-	valRef, b, err := p.parseVal(b)
-	if err != nil {
-		return ref, b, err
-	}
-	p.builder.Chain(valRef, key)
-	p.builder.AttachChild(ref, valRef)
-
-	return ref, b, err
-}
-
-func (p *parser) parseVal(b []byte) (ast.Reference, []byte, error) {
-	// val = string / boolean / array / inline-table / date-time / float / integer
-	var ref ast.Reference
-
-	if len(b) == 0 {
-		return ref, nil, fmt.Errorf("expected value, not eof")
-	}
-
-	var err error
-	c := b[0]
-
-	switch c {
-	case '"':
-		var v []byte
-		if scanFollowsMultilineBasicStringDelimiter(b) {
-			v, b, err = p.parseMultilineBasicString(b)
-		} else {
-			v, b, err = p.parseBasicString(b)
-		}
-		if err == nil {
-			ref = p.builder.Push(ast.Node{
-				Kind: ast.String,
-				Data: v,
-			})
-		}
-		return ref, b, err
-	case '\'':
-		var v []byte
-		if scanFollowsMultilineLiteralStringDelimiter(b) {
-			v, b, err = p.parseMultilineLiteralString(b)
-		} else {
-			v, b, err = p.parseLiteralString(b)
-		}
-		if err == nil {
-			ref = p.builder.Push(ast.Node{
-				Kind: ast.String,
-				Data: v,
-			})
-		}
-		return ref, b, err
-	case 't':
-		if !scanFollowsTrue(b) {
-			return ref, nil, fmt.Errorf("expected 'true'")
-		}
-		ref = p.builder.Push(ast.Node{
-			Kind: ast.Bool,
-			Data: b[:4],
-		})
-		return ref, b[4:], nil
-	case 'f':
-		if !scanFollowsFalse(b) {
-			return ast.Reference{}, nil, fmt.Errorf("expected 'false'")
-		}
-		ref = p.builder.Push(ast.Node{
-			Kind: ast.Bool,
-			Data: b[:5],
-		})
-		return ref, b[5:], nil
-	case '[':
-		return p.parseValArray(b)
-	case '{':
-		return p.parseInlineTable(b)
-	default:
-		return p.parseIntOrFloatOrDateTime(b)
-	}
-}
-
-func (p *parser) parseLiteralString(b []byte) ([]byte, []byte, error) {
-	v, rest, err := scanLiteralString(b)
-	if err != nil {
-		return nil, nil, err
-	}
-	return v[1 : len(v)-1], rest, nil
-}
-
-func (p *parser) parseInlineTable(b []byte) (ast.Reference, []byte, error) {
-	//inline-table = inline-table-open [ inline-table-keyvals ] inline-table-close
-	//inline-table-open  = %x7B ws     ; {
-	//inline-table-close = ws %x7D     ; }
-	//inline-table-sep   = ws %x2C ws  ; , Comma
-	//inline-table-keyvals = keyval [ inline-table-sep inline-table-keyvals ]
-
-	parent := p.builder.Push(ast.Node{
-		Kind: ast.InlineTable,
-	})
-
-	first := true
-	var child ast.Reference
-
-	b = b[1:]
-
-	var err error
-	for len(b) > 0 {
-		b = p.parseWhitespace(b)
-		if b[0] == '}' {
-			break
-		}
-
-		if !first {
-			b, err = expect(',', b)
-			if err != nil {
-				return parent, nil, err
-			}
-			b = p.parseWhitespace(b)
-		}
-		var kv ast.Reference
-		kv, b, err = p.parseKeyval(b)
-		if err != nil {
-			return parent, nil, err
-		}
-
-		if first {
-			p.builder.AttachChild(parent, kv)
-			first = false
-		} else {
-			p.builder.Chain(child, kv)
-		}
-		child = kv
-
-		first = false
-	}
-
-	rest, err := expect('}', b)
-	return parent, rest, err
-}
-
-func (p *parser) parseValArray(b []byte) (ast.Reference, []byte, error) {
-	//array = array-open [ array-values ] ws-comment-newline array-close
-	//array-open =  %x5B ; [
-	//array-close = %x5D ; ]
-	//array-values =  ws-comment-newline val ws-comment-newline array-sep array-values
-	//array-values =/ ws-comment-newline val ws-comment-newline [ array-sep ]
-	//array-sep = %x2C  ; , Comma
-	//ws-comment-newline = *( wschar / [ comment ] newline )
-
-	b = b[1:]
-
-	parent := p.builder.Push(ast.Node{
-		Kind: ast.Array,
-	})
-
-	first := true
-	var lastChild ast.Reference
-
-	var err error
-	for len(b) > 0 {
-		b, err = p.parseOptionalWhitespaceCommentNewline(b)
-		if err != nil {
-			return parent, nil, err
-		}
-
-		if len(b) == 0 {
-			return parent, nil, unexpectedCharacter{b: b} // TODO: should be unexpected EOF
-		}
-
-		if b[0] == ']' {
-			break
-		}
-		if b[0] == ',' {
-			if first {
-				return parent, nil, fmt.Errorf("array cannot start with comma")
-			}
-			b = b[1:]
-			b, err = p.parseOptionalWhitespaceCommentNewline(b)
-			if err != nil {
-				return parent, nil, err
-			}
-		}
-
-		// TOML allows trailing commas in arrays.
-		if len(b) > 0 && b[0] == ']' {
-			break
-		}
-
-		var valueRef ast.Reference
-		valueRef, b, err = p.parseVal(b)
-		if err != nil {
-			return parent, nil, err
-		}
-
-		if first {
-			p.builder.AttachChild(parent, valueRef)
-			first = false
-		} else {
-			p.builder.Chain(lastChild, valueRef)
-		}
-		lastChild = valueRef
-
-		b, err = p.parseOptionalWhitespaceCommentNewline(b)
-		if err != nil {
-			return parent, nil, err
-		}
-		first = false
-	}
-
-	rest, err := expect(']', b)
-	return parent, rest, err
-}
-
-func (p *parser) parseOptionalWhitespaceCommentNewline(b []byte) ([]byte, error) {
-	for len(b) > 0 {
-		var err error
-		b = p.parseWhitespace(b)
-		if len(b) > 0 && b[0] == '#' {
-			_, b, err = scanComment(b)
-			if err != nil {
-				return nil, err
-			}
-		}
-		if len(b) == 0 {
-			break
-		}
-		if b[0] == '\n' || b[0] == '\r' {
-			b, err = p.parseNewline(b)
-			if err != nil {
-				return nil, err
-			}
-		} else {
-			break
-		}
-	}
-	return b, nil
-}
-
-func (p *parser) parseMultilineLiteralString(b []byte) ([]byte, []byte, error) {
-	token, rest, err := scanMultilineLiteralString(b)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	i := 3
-
-	// skip the immediate new line
-	if token[i] == '\n' {
-		i++
-	} else if token[i] == '\r' && token[i+1] == '\n' {
-		i += 2
-	}
-	return token[i : len(token)-3], rest, err
-}
-
-func (p *parser) parseMultilineBasicString(b []byte) ([]byte, []byte, error) {
-	//ml-basic-string = ml-basic-string-delim [ newline ] ml-basic-body
-	//ml-basic-string-delim
-	//ml-basic-string-delim = 3quotation-mark
-	//ml-basic-body = *mlb-content *( mlb-quotes 1*mlb-content ) [ mlb-quotes ]
-	//
-	//mlb-content = mlb-char / newline / mlb-escaped-nl
-	//mlb-char = mlb-unescaped / escaped
-	//mlb-quotes = 1*2quotation-mark
-	//mlb-unescaped = wschar / %x21 / %x23-5B / %x5D-7E / non-ascii
-	//mlb-escaped-nl = escape ws newline *( wschar / newline )
-
-	token, rest, err := scanMultilineBasicString(b)
-	if err != nil {
-		return nil, nil, err
-	}
-	var builder bytes.Buffer
-
-	i := 3
-
-	// skip the immediate new line
-	if token[i] == '\n' {
-		i++
-	} else if token[i] == '\r' && token[i+1] == '\n' {
-		i += 2
-	}
-
-	// The scanner ensures that the token starts and ends with quotes and that
-	// escapes are balanced.
-	for ; i < len(token)-3; i++ {
-		c := token[i]
-		if c == '\\' {
-			// When the last non-whitespace character on a line is an unescaped \,
-			// it will be trimmed along with all whitespace (including newlines) up
-			// to the next non-whitespace character or closing delimiter.
-			if token[i+1] == '\n' || (token[i+1] == '\r' && token[i+2] == '\n') {
-				i++ // skip the \
-				for ; i < len(token)-3; i++ {
-					c := token[i]
-					if !(c == '\n' || c == '\r' || c == ' ' || c == '\t') {
-						i--
-						break
-					}
-				}
-				continue
-			}
-
-			// handle escaping
-			i++
-			c = token[i]
-			switch c {
-			case '"', '\\':
-				builder.WriteByte(c)
-			case 'b':
-				builder.WriteByte('\b')
-			case 'f':
-				builder.WriteByte('\f')
-			case 'n':
-				builder.WriteByte('\n')
-			case 'r':
-				builder.WriteByte('\r')
-			case 't':
-				builder.WriteByte('\t')
-			case 'u':
-				x, err := hexToString(token[i+3:len(token)-3], 4)
-				if err != nil {
-					return nil, nil, err
-				}
-				builder.WriteString(x)
-				i += 4
-			case 'U':
-				x, err := hexToString(token[i+3:len(token)-3], 8)
-				if err != nil {
-					return nil, nil, err
-				}
-				builder.WriteString(x)
-				i += 8
-			default:
-				return nil, nil, fmt.Errorf("invalid escaped character: %#U", c)
-			}
-		} else {
-			builder.WriteByte(c)
-		}
-	}
-
-	return builder.Bytes(), rest, nil
-}
-
-func (p *parser) parseKey(b []byte) (ast.Reference, []byte, error) {
-	//key = simple-key / dotted-key
-	//simple-key = quoted-key / unquoted-key
-	//
-	//unquoted-key = 1*( ALPHA / DIGIT / %x2D / %x5F ) ; A-Z / a-z / 0-9 / - / _
-	//quoted-key = basic-string / literal-string
-	//dotted-key = simple-key 1*( dot-sep simple-key )
-	//
-	//dot-sep   = ws %x2E ws  ; . Period
-
-	key, b, err := p.parseSimpleKey(b)
-	if err != nil {
-		return ast.Reference{}, nil, err
-	}
-
-	ref := p.builder.Push(ast.Node{
-		Kind: ast.Key,
-		Data: key,
-	})
-
-	for {
-		b = p.parseWhitespace(b)
-		if len(b) > 0 && b[0] == '.' {
-			b, err = expect('.', b)
-			if err != nil {
-				return ref, nil, err
-			}
-			b = p.parseWhitespace(b)
-			key, b, err = p.parseSimpleKey(b)
-			if err != nil {
-				return ref, nil, err
-			}
-			p.builder.PushAndChain(ast.Node{
-				Kind: ast.Key,
-				Data: key,
-			})
-		} else {
-			break
-		}
-	}
-
-	return ref, b, nil
-}
-
-func (p *parser) parseSimpleKey(b []byte) (key, rest []byte, err error) {
-	//simple-key = quoted-key / unquoted-key
-	//unquoted-key = 1*( ALPHA / DIGIT / %x2D / %x5F ) ; A-Z / a-z / 0-9 / - / _
-	//quoted-key = basic-string / literal-string
-
-	if len(b) == 0 {
-		return nil, nil, unexpectedCharacter{b: b} // TODO: should be unexpected EOF
-	}
-
-	if b[0] == '\'' {
-		key, rest, err = p.parseLiteralString(b)
-	} else if b[0] == '"' {
-		key, rest, err = p.parseBasicString(b)
-	} else if isUnquotedKeyChar(b[0]) {
-		key, rest, err = scanUnquotedKey(b)
-	} else {
-		err = unexpectedCharacter{b: b} // TODO: should contain expected characters
-	}
-	return
-}
-
-func (p *parser) parseBasicString(b []byte) ([]byte, []byte, error) {
-	//basic-string = quotation-mark *basic-char quotation-mark
-	//quotation-mark = %x22            ; "
-	//basic-char = basic-unescaped / escaped
-	//basic-unescaped = wschar / %x21 / %x23-5B / %x5D-7E / non-ascii
-	//escaped = escape escape-seq-char
-	//escape-seq-char =  %x22         ; "    quotation mark  U+0022
-	//escape-seq-char =/ %x5C         ; \    reverse solidus U+005C
-	//escape-seq-char =/ %x62         ; b    backspace       U+0008
-	//escape-seq-char =/ %x66         ; f    form feed       U+000C
-	//escape-seq-char =/ %x6E         ; n    line feed       U+000A
-	//escape-seq-char =/ %x72         ; r    carriage return U+000D
-	//escape-seq-char =/ %x74         ; t    tab             U+0009
-	//escape-seq-char =/ %x75 4HEXDIG ; uXXXX                U+XXXX
-	//escape-seq-char =/ %x55 8HEXDIG ; UXXXXXXXX            U+XXXXXXXX
-
-	token, rest, err := scanBasicString(b)
-	if err != nil {
-		return nil, nil, err
-	}
-	var builder bytes.Buffer
-
-	// The scanner ensures that the token starts and ends with quotes and that
-	// escapes are balanced.
-	for i := 1; i < len(token)-1; i++ {
-		c := token[i]
-		if c == '\\' {
-			i++
-			c = token[i]
-			switch c {
-			case '"', '\\':
-				builder.WriteByte(c)
-			case 'b':
-				builder.WriteByte('\b')
-			case 'f':
-				builder.WriteByte('\f')
-			case 'n':
-				builder.WriteByte('\n')
-			case 'r':
-				builder.WriteByte('\r')
-			case 't':
-				builder.WriteByte('\t')
-			case 'u':
-				x, err := hexToString(token[i+1:len(token)-1], 4)
-				if err != nil {
-					return nil, nil, err
-				}
-				builder.WriteString(x)
-				i += 4
-			case 'U':
-				x, err := hexToString(token[i+1:len(token)-1], 8)
-				if err != nil {
-					return nil, nil, err
-				}
-				builder.WriteString(x)
-				i += 8
-			default:
-				return nil, nil, fmt.Errorf("invalid escaped character: %#U", c)
-			}
-		} else {
-			builder.WriteByte(c)
-		}
-	}
-
-	return builder.Bytes(), rest, nil
-}
-
-func hexToString(b []byte, length int) (string, error) {
-	if len(b) < length {
-		return "", fmt.Errorf("unicode point needs %d hex characters", length)
-	}
-	// TODO: slow
-	intcode, err := strconv.ParseInt(string(b[:length]), 16, 32)
-	if err != nil {
-		return "", err
-	}
-	return string(rune(intcode)), nil
-}
-
-func (p *parser) parseWhitespace(b []byte) []byte {
-	//ws = *wschar
-	//wschar =  %x20  ; Space
-	//wschar =/ %x09  ; Horizontal tab
-
-	_, rest := scanWhitespace(b)
-	return rest
-}
-
-func (p *parser) parseIntOrFloatOrDateTime(b []byte) (ast.Reference, []byte, error) {
-	switch b[0] {
-	case 'i':
-		if !scanFollowsInf(b) {
-			return ast.Reference{}, nil, fmt.Errorf("expected 'inf'")
-		}
-		return p.builder.Push(ast.Node{
-			Kind: ast.Float,
-			Data: b[:3],
-		}), b[3:], nil
-	case 'n':
-		if !scanFollowsNan(b) {
-			return ast.Reference{}, nil, fmt.Errorf("expected 'nan'")
-		}
-		return p.builder.Push(ast.Node{
-			Kind: ast.Float,
-			Data: b[:3],
-		}), b[3:], nil
-	case '+', '-':
-		return p.scanIntOrFloat(b)
-	}
-
-	if len(b) < 3 {
-		return p.scanIntOrFloat(b)
-	}
-	s := 5
-	if len(b) < s {
-		s = len(b)
-	}
-	for idx, c := range b[:s] {
-		if isDigit(c) {
-			continue
-		}
-		if idx == 2 && c == ':' || (idx == 4 && c == '-') {
-			return p.scanDateTime(b)
-		}
-	}
-	return p.scanIntOrFloat(b)
-}
-
-func digitsToInt(b []byte) int {
-	x := 0
-	for _, d := range b {
-		x *= 10
-		x += int(d - '0')
-	}
-	return x
-}
-
-func (p *parser) scanDateTime(b []byte) (ast.Reference, []byte, error) {
-	// scans for contiguous characters in [0-9T:Z.+-], and up to one space if
-	// followed by a digit.
-
-	hasTime := false
-	hasTz := false
-	seenSpace := false
-
-	i := 0
-	for ; i < len(b); i++ {
-		c := b[i]
-		if isDigit(c) || c == '-' {
-		} else if c == 'T' || c == ':' || c == '.' {
-			hasTime = true
-			continue
-		} else if c == '+' || c == '-' || c == 'Z' {
-			hasTz = true
-		} else if c == ' ' {
-			if !seenSpace && i+1 < len(b) && isDigit(b[i+1]) {
-				i += 2
-				seenSpace = true
-				hasTime = true
-			} else {
-				break
-			}
-		} else {
-			break
-		}
-	}
-
-	var kind ast.Kind
-
-	if hasTime {
-		if hasTz {
-			kind = ast.DateTime
-		} else {
-			kind = ast.LocalDateTime
-		}
-	} else {
-		if hasTz {
-			return ast.Reference{}, nil, fmt.Errorf("possible DateTime cannot have a timezone but no time component")
-		}
-		kind = ast.LocalDate
-	}
-
-	return p.builder.Push(ast.Node{
-		Kind: kind,
-		Data: b[:i],
-	}), b[i:], nil
-}
-
-func (p *parser) scanIntOrFloat(b []byte) (ast.Reference, []byte, error) {
-	i := 0
-
-	if len(b) > 2 && b[0] == '0' && b[1] != '.' {
-		var isValidRune validRuneFn
-		switch b[1] {
-		case 'x':
-			isValidRune = isValidHexRune
-		case 'o':
-			isValidRune = isValidOctalRune
-		case 'b':
-			isValidRune = isValidBinaryRune
-		default:
-			i++
-		}
-
-		if isValidRune != nil {
-			i += 2
-			for ; i < len(b); i++ {
-				if !isValidRune(b[i]) {
-					break
-				}
-			}
-		}
-
-		return p.builder.Push(ast.Node{
-			Kind: ast.Integer,
-			Data: b[:i],
-		}), b[i:], nil
-	}
-
-	isFloat := false
-
-	for ; i < len(b); i++ {
-		c := b[i]
-
-		if c >= '0' && c <= '9' || c == '+' || c == '-' || c == '_' {
-			continue
-		}
-
-		if c == '.' || c == 'e' || c == 'E' {
-			isFloat = true
-			continue
-		}
-
-		if c == 'i' {
-			if scanFollowsInf(b[i:]) {
-				return p.builder.Push(ast.Node{
-					Kind: ast.Float,
-					Data: b[:i+3],
-				}), b[i+3:], nil
-			}
-			return ast.Reference{}, nil, fmt.Errorf("unexpected character i while scanning for a number")
-		}
-		if c == 'n' {
-			if scanFollowsNan(b[i:]) {
-				return p.builder.Push(ast.Node{
-					Kind: ast.Float,
-					Data: b[:i+3],
-				}), b[i+3:], nil
-			}
-			return ast.Reference{}, nil, fmt.Errorf("unexpected character n while scanning for a number")
-		}
-
-		break
-	}
-
-	if i == 0 {
-		return ast.Reference{}, b, fmt.Errorf("expected integer or float")
-	}
-
-	kind := ast.Integer
-
-	if isFloat {
-		kind = ast.Float
-	}
-
-	return p.builder.Push(ast.Node{
-		Kind: kind,
-		Data: b[:i],
-	}), b[i:], nil
-}
-
-func isDigit(r byte) bool {
-	return r >= '0' && r <= '9'
-}
-
-type validRuneFn func(r byte) bool
-
-func isValidHexRune(r byte) bool {
-	return r >= 'a' && r <= 'f' ||
-		r >= 'A' && r <= 'F' ||
-		r >= '0' && r <= '9' ||
-		r == '_'
-}
-
-func isValidOctalRune(r byte) bool {
-	return r >= '0' && r <= '7' || r == '_'
-}
-
-func isValidBinaryRune(r byte) bool {
-	return r == '0' || r == '1' || r == '_'
-}
-
-func expect(x byte, b []byte) ([]byte, error) {
-	if len(b) == 0 {
-		return nil, newDecodeError(b[:0], "expecting %#U", x)
-	}
-	if b[0] != x {
-		return nil, newDecodeError(b[0:1], "expected character %U", x)
-	}
-	return b[1:], nil
-}
-
-type unexpectedCharacter struct {
-	r byte
-	b []byte
-}
-
-func (u unexpectedCharacter) Error() string {
-	if len(u.b) == 0 {
-		return fmt.Sprintf("expected %#U, not EOF", u.r)
-
-	}
-	return fmt.Sprintf("expected %#U, not %#U", u.r, u.b[0])
-}

parser_test.go

@@ -1,396 +0,0 @@
-package toml
-
-import (
-	"testing"
-
-	"github.com/pelletier/go-toml/v2/internal/ast"
-	"github.com/stretchr/testify/require"
-)
-
-func TestParser_AST_Numbers(t *testing.T) {
-	examples := []struct {
-		desc  string
-		input string
-		kind  ast.Kind
-		err   bool
-	}{
-		{
-			desc:  "integer just digits",
-			input: `1234`,
-			kind:  ast.Integer,
-		},
-		{
-			desc:  "integer zero",
-			input: `0`,
-			kind:  ast.Integer,
-		},
-		{
-			desc:  "integer sign",
-			input: `+99`,
-			kind:  ast.Integer,
-		},
-		{
-			desc:  "integer hex uppercase",
-			input: `0xDEADBEEF`,
-			kind:  ast.Integer,
-		},
-		{
-			desc:  "integer hex lowercase",
-			input: `0xdead_beef`,
-			kind:  ast.Integer,
-		},
-		{
-			desc:  "integer octal",
-			input: `0o01234567`,
-			kind:  ast.Integer,
-		},
-		{
-			desc:  "integer binary",
-			input: `0b11010110`,
-			kind:  ast.Integer,
-		},
-		{
-			desc:  "float zero",
-			input: `0.0`,
-			kind:  ast.Float,
-		},
-		{
-			desc:  "float positive zero",
-			input: `+0.0`,
-			kind:  ast.Float,
-		},
-		{
-			desc:  "float negative zero",
-			input: `-0.0`,
-			kind:  ast.Float,
-		},
-		{
-			desc:  "float pi",
-			input: `3.1415`,
-			kind:  ast.Float,
-		},
-		{
-			desc:  "float negative",
-			input: `-0.01`,
-			kind:  ast.Float,
-		},
-		{
-			desc:  "float signed exponent",
-			input: `5e+22`,
-			kind:  ast.Float,
-		},
-		{
-			desc:  "float exponent lowercase",
-			input: `1e06`,
-			kind:  ast.Float,
-		},
-		{
-			desc:  "float exponent uppercase",
-			input: `-2E-2`,
-			kind:  ast.Float,
-		},
-		{
-			desc:  "float fractional with exponent",
-			input: `6.626e-34`,
-			kind:  ast.Float,
-		},
-		{
-			desc:  "float underscores",
-			input: `224_617.445_991_228`,
-			kind:  ast.Float,
-		},
-		{
-			desc:  "inf",
-			input: `inf`,
-			kind:  ast.Float,
-		},
-		{
-			desc:  "inf negative",
-			input: `-inf`,
-			kind:  ast.Float,
-		},
-		{
-			desc:  "inf positive",
-			input: `+inf`,
-			kind:  ast.Float,
-		},
-		{
-			desc:  "nan",
-			input: `nan`,
-			kind:  ast.Float,
-		},
-		{
-			desc:  "nan negative",
-			input: `-nan`,
-			kind:  ast.Float,
-		},
-		{
-			desc:  "nan positive",
-			input: `+nan`,
-			kind:  ast.Float,
-		},
-	}
-
-	for _, e := range examples {
-		t.Run(e.desc, func(t *testing.T) {
-			p := parser{}
-			p.Reset([]byte(`A = ` + e.input))
-			p.NextExpression()
-			err := p.Error()
-			if e.err {
-				require.Error(t, err)
-			} else {
-				require.NoError(t, err)
-
-				expected := astNode{
-					Kind: ast.KeyValue,
-					Children: []astNode{
-						{Kind: e.kind, Data: []byte(e.input)},
-						{Kind: ast.Key, Data: []byte(`A`)},
-					},
-				}
-				compareNode(t, expected, p.Expression())
-			}
-		})
-	}
-}
-
-type astRoot []astNode
-type astNode struct {
-	Kind     ast.Kind
-	Data     []byte
-	Children []astNode
-}
-
-func compareAST(t *testing.T, expected astRoot, actual *ast.Root) {
-	it := actual.Iterator()
-	compareIterator(t, expected, it)
-}
-
-func compareNode(t *testing.T, e astNode, n ast.Node) {
-	require.Equal(t, e.Kind, n.Kind)
-	require.Equal(t, e.Data, n.Data)
-
-	compareIterator(t, e.Children, n.Children())
-}
-
-func compareIterator(t *testing.T, expected []astNode, actual ast.Iterator) {
-	idx := 0
-
-	for actual.Next() {
-		n := actual.Node()
-
-		if idx >= len(expected) {
-			t.Fatal("extra child in actual tree")
-		}
-		e := expected[idx]
-
-		compareNode(t, e, n)
-
-		idx++
-	}
-
-	if idx < len(expected) {
-		t.Fatal("missing children in actual", "idx =", idx, "expected =", len(expected))
-	}
-}
-
-func (r astRoot) toOrig() *ast.Root {
-	builder := &ast.Builder{}
-
-	var last ast.Reference
-
-	for i, n := range r {
-		ref := builder.Push(ast.Node{
-			Kind: n.Kind,
-			Data: n.Data,
-		})
-
-		if i > 0 {
-			builder.Chain(last, ref)
-		}
-		last = ref
-
-		if len(n.Children) > 0 {
-			c := childrenToOrig(builder, n.Children)
-			builder.AttachChild(ref, c)
-		}
-	}
-
-	return builder.Tree()
-}
-
-func childrenToOrig(b *ast.Builder, nodes []astNode) ast.Reference {
-	var first ast.Reference
-	var last ast.Reference
-	for i, n := range nodes {
-		ref := b.Push(ast.Node{
-			Kind: n.Kind,
-			Data: n.Data,
-		})
-		if i == 0 {
-			first = ref
-		} else {
-			b.Chain(last, ref)
-		}
-		last = ref
-
-		if len(n.Children) > 0 {
-			c := childrenToOrig(b, n.Children)
-			b.AttachChild(ref, c)
-		}
-	}
-	return first
-}
-
-func TestParser_AST(t *testing.T) {
-	examples := []struct {
-		desc  string
-		input string
-		ast   astNode
-		err   bool
-	}{
-		{
-			desc:  "simple string assignment",
-			input: `A = "hello"`,
-			ast: astNode{
-				Kind: ast.KeyValue,
-				Children: []astNode{
-					{
-						Kind: ast.String,
-						Data: []byte(`hello`),
-					},
-					{
-						Kind: ast.Key,
-						Data: []byte(`A`),
-					},
-				},
-			},
-		},
-		{
-			desc:  "simple bool assignment",
-			input: `A = true`,
-			ast: astNode{
-				Kind: ast.KeyValue,
-				Children: []astNode{
-					{
-						Kind: ast.Bool,
-						Data: []byte(`true`),
-					},
-					{
-						Kind: ast.Key,
-						Data: []byte(`A`),
-					},
-				},
-			},
-		},
-		{
-			desc:  "array of strings",
-			input: `A = ["hello", ["world", "again"]]`,
-			ast: astNode{
-				Kind: ast.KeyValue,
-				Children: []astNode{
-					{
-						Kind: ast.Array,
-						Children: []astNode{
-							{
-								Kind: ast.String,
-								Data: []byte(`hello`),
-							},
-							{
-								Kind: ast.Array,
-								Children: []astNode{
-									{
-										Kind: ast.String,
-										Data: []byte(`world`),
-									},
-									{
-										Kind: ast.String,
-										Data: []byte(`again`),
-									},
-								},
-							},
-						},
-					},
-					{
-						Kind: ast.Key,
-						Data: []byte(`A`),
-					},
-				},
-			},
-		},
-		{
-			desc:  "array of arrays of strings",
-			input: `A = ["hello", "world"]`,
-			ast: astNode{
-				Kind: ast.KeyValue,
-				Children: []astNode{
-					{
-						Kind: ast.Array,
-						Children: []astNode{
-							{
-								Kind: ast.String,
-								Data: []byte(`hello`),
-							},
-							{
-								Kind: ast.String,
-								Data: []byte(`world`),
-							},
-						},
-					},
-					{
-						Kind: ast.Key,
-						Data: []byte(`A`),
-					},
-				},
-			},
-		},
-		{
-			desc:  "inline table",
-			input: `name = { first = "Tom", last = "Preston-Werner" }`,
-			ast: astNode{
-				Kind: ast.KeyValue,
-				Children: []astNode{
-					{
-						Kind: ast.InlineTable,
-						Children: []astNode{
-							{
-								Kind: ast.KeyValue,
-								Children: []astNode{
-									{Kind: ast.String, Data: []byte(`Tom`)},
-									{Kind: ast.Key, Data: []byte(`first`)},
-								},
-							},
-							{
-								Kind: ast.KeyValue,
-								Children: []astNode{
-									{Kind: ast.String, Data: []byte(`Preston-Werner`)},
-									{Kind: ast.Key, Data: []byte(`last`)},
-								},
-							},
-						},
-					},
-					{
-						Kind: ast.Key,
-						Data: []byte(`name`),
-					},
-				},
-			},
-		},
-	}
-
-	for _, e := range examples {
-		t.Run(e.desc, func(t *testing.T) {
-			p := parser{}
-			p.Reset([]byte(e.input))
-			p.NextExpression()
-			err := p.Error()
-			if e.err {
-				require.Error(t, err)
-			} else {
-				require.NoError(t, err)
-				compareNode(t, e.ast, p.Expression())
-			}
-		})
-	}
-}

scanner.go

@@ -1,168 +0,0 @@
-package toml
-
-import "fmt"
-
-func scanFollows(pattern []byte) func(b []byte) bool {
-	return func(b []byte) bool {
-		if len(b) < len(pattern) {
-			return false
-		}
-		for i, c := range pattern {
-			if b[i] != c {
-				return false
-			}
-		}
-		return true
-	}
-}
-
-var scanFollowsMultilineBasicStringDelimiter = scanFollows([]byte{'"', '"', '"'})
-var scanFollowsMultilineLiteralStringDelimiter = scanFollows([]byte{'\'', '\'', '\''})
-var scanFollowsTrue = scanFollows([]byte{'t', 'r', 'u', 'e'})
-var scanFollowsFalse = scanFollows([]byte{'f', 'a', 'l', 's', 'e'})
-var scanFollowsInf = scanFollows([]byte{'i', 'n', 'f'})
-var scanFollowsNan = scanFollows([]byte{'n', 'a', 'n'})
-
-func scanUnquotedKey(b []byte) ([]byte, []byte, error) {
-	//unquoted-key = 1*( ALPHA / DIGIT / %x2D / %x5F ) ; A-Z / a-z / 0-9 / - / _
-	for i := 0; i < len(b); i++ {
-		if !isUnquotedKeyChar(b[i]) {
-			return b[:i], b[i:], nil
-		}
-	}
-	return b, b[len(b):], nil
-}
-
-func isUnquotedKeyChar(r byte) bool {
-	return (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '-' || r == '_'
-}
-
-func scanLiteralString(b []byte) ([]byte, []byte, error) {
-	//literal-string = apostrophe *literal-char apostrophe
-	//apostrophe = %x27 ; ' apostrophe
-	//literal-char = %x09 / %x20-26 / %x28-7E / non-ascii
-	for i := 1; i < len(b); i++ {
-		switch b[i] {
-		case '\'':
-			return b[:i+1], b[i+1:], nil
-		case '\n':
-			return nil, nil, newDecodeError(b[i:i+1], "literal strings cannot have new lines")
-		}
-	}
-	return nil, nil, newDecodeError(b[len(b):], "unterminated literal string")
-}
-
-func scanMultilineLiteralString(b []byte) ([]byte, []byte, error) {
-	//ml-literal-string = ml-literal-string-delim [ newline ] ml-literal-body
-	//ml-literal-string-delim
-	//ml-literal-string-delim = 3apostrophe
-	//ml-literal-body = *mll-content *( mll-quotes 1*mll-content ) [ mll-quotes ]
-	//
-	//mll-content = mll-char / newline
-	//mll-char = %x09 / %x20-26 / %x28-7E / non-ascii
-	//mll-quotes = 1*2apostrophe
-	for i := 3; i < len(b); i++ {
-		switch b[i] {
-		case '\'':
-			if scanFollowsMultilineLiteralStringDelimiter(b[i:]) {
-				return b[:i+3], b[i+3:], nil
-			}
-		}
-	}
-
-	return nil, nil, newDecodeError(b[len(b):], `multiline literal string not terminated by '''`)
-}
-
-func scanWindowsNewline(b []byte) ([]byte, []byte, error) {
-	if len(b) < 2 {
-		return nil, nil, fmt.Errorf(`windows new line missing \n`)
-	}
-	if b[1] != '\n' {
-		return nil, nil, fmt.Errorf(`windows new line should be \r\n`)
-	}
-	return b[:2], b[2:], nil
-}
-
-func scanWhitespace(b []byte) ([]byte, []byte) {
-	for i := 0; i < len(b); i++ {
-		switch b[i] {
-		case ' ', '\t':
-			continue
-		default:
-			return b[:i], b[i:]
-		}
-	}
-	return b, b[len(b):]
-}
-
-func scanComment(b []byte) ([]byte, []byte, error) {
-	//;; Comment
-	//
-	//comment-start-symbol = %x23 ; #
-	//non-ascii = %x80-D7FF / %xE000-10FFFF
-	//non-eol = %x09 / %x20-7F / non-ascii
-	//
-	//comment = comment-start-symbol *non-eol
-
-	for i := 1; i < len(b); i++ {
-		switch b[i] {
-		case '\n':
-			return b[:i], b[i:], nil
-		}
-	}
-	return b, nil, nil
-}
-
-// TODO perform validation on the string?
-func scanBasicString(b []byte) ([]byte, []byte, error) {
-	//basic-string = quotation-mark *basic-char quotation-mark
-	//quotation-mark = %x22            ; "
-	//basic-char = basic-unescaped / escaped
-	//basic-unescaped = wschar / %x21 / %x23-5B / %x5D-7E / non-ascii
-	//escaped = escape escape-seq-char
-	for i := 1; i < len(b); i++ {
-		switch b[i] {
-		case '"':
-			return b[:i+1], b[i+1:], nil
-		case '\n':
-			return nil, nil, newDecodeError(b[i:i+1], "basic strings cannot have new lines")
-		case '\\':
-			if len(b) < i+2 {
-				return nil, nil, newDecodeError(b[i:i+1], "need a character after \\")
-			}
-			i++ // skip the next character
-		}
-	}
-
-	return nil, nil, fmt.Errorf(`basic string not terminated by "`)
-}
-
-// TODO perform validation on the string?
-func scanMultilineBasicString(b []byte) ([]byte, []byte, error) {
-	//ml-basic-string = ml-basic-string-delim [ newline ] ml-basic-body
-	//ml-basic-string-delim
-	//ml-basic-string-delim = 3quotation-mark
-	//ml-basic-body = *mlb-content *( mlb-quotes 1*mlb-content ) [ mlb-quotes ]
-	//
-	//mlb-content = mlb-char / newline / mlb-escaped-nl
-	//mlb-char = mlb-unescaped / escaped
-	//mlb-quotes = 1*2quotation-mark
-	//mlb-unescaped = wschar / %x21 / %x23-5B / %x5D-7E / non-ascii
-	//mlb-escaped-nl = escape ws newline *( wschar / newline )
-
-	for i := 3; i < len(b); i++ {
-		switch b[i] {
-		case '"':
-			if scanFollowsMultilineBasicStringDelimiter(b[i:]) {
-				return b[:i+3], b[i+3:], nil
-			}
-		case '\\':
-			if len(b) < i+2 {
-				return nil, nil, newDecodeError(b[len(b):], "need a character after \\")
-			}
-			i++ // skip the next character
-		}
-	}
-
-	return nil, nil, newDecodeError(b[len(b):], `multiline basic string not terminated by """`)
-}

strict.go

@@ -0,0 +1,114 @@
+package toml
+
+import (
+	"github.com/pelletier/go-toml/v2/internal/tracker"
+	"github.com/pelletier/go-toml/v2/unstable"
+)
+
+type strict struct {
+	Enabled bool
+
+	// Tracks the current key being processed.
+	key tracker.KeyTracker
+
+	missing []unstable.ParserError
+
+	// Reference to the document for computing key ranges.
+	doc []byte
+}
+
+func (s *strict) EnterTable(node *unstable.Node) {
+	if !s.Enabled {
+		return
+	}
+
+	s.key.UpdateTable(node)
+}
+
+func (s *strict) EnterArrayTable(node *unstable.Node) {
+	if !s.Enabled {
+		return
+	}
+
+	s.key.UpdateArrayTable(node)
+}
+
+func (s *strict) EnterKeyValue(node *unstable.Node) {
+	if !s.Enabled {
+		return
+	}
+
+	s.key.Push(node)
+}
+
+func (s *strict) ExitKeyValue(node *unstable.Node) {
+	if !s.Enabled {
+		return
+	}
+
+	s.key.Pop(node)
+}
+
+func (s *strict) MissingTable(node *unstable.Node) {
+	if !s.Enabled {
+		return
+	}
+
+	s.missing = append(s.missing, unstable.ParserError{
+		Highlight: s.keyLocation(node),
+		Message:   "missing table",
+		Key:       s.key.Key(),
+	})
+}
+
+func (s *strict) MissingField(node *unstable.Node) {
+	if !s.Enabled {
+		return
+	}
+
+	s.missing = append(s.missing, unstable.ParserError{
+		Highlight: s.keyLocation(node),
+		Message:   "missing field",
+		Key:       s.key.Key(),
+	})
+}
+
+func (s *strict) Error(doc []byte) error {
+	if !s.Enabled || len(s.missing) == 0 {
+		return nil
+	}
+
+	err := &StrictMissingError{
+		Errors: make([]DecodeError, 0, len(s.missing)),
+	}
+
+	for _, derr := range s.missing {
+		derr := derr
+		err.Errors = append(err.Errors, *wrapDecodeError(doc, &derr))
+	}
+
+	return err
+}
+
+func (s *strict) keyLocation(node *unstable.Node) []byte {
+	k := node.Key()
+
+	hasOne := k.Next()
+	if !hasOne {
+		panic("should not be called with empty key")
+	}
+
+	// Get the range from the first key to the last key.
+	firstRaw := k.Node().Raw
+	lastRaw := firstRaw
+
+	for k.Next() {
+		lastRaw = k.Node().Raw
+	}
+
+	// Compute the slice from the document using the ranges.
+	start := firstRaw.Offset
+	end := lastRaw.Offset + lastRaw.Length
+
+	return s.doc[start:end]
+}

targets.go

@@ -1,554 +0,0 @@
-package toml
-
-import (
-	"fmt"
-	"math"
-	"reflect"
-	"strings"
-	"sync"
-)
-
-type target interface {
-	// Dereferences the target.
-	get() reflect.Value
-
-	// Store a string at the target.
-	setString(v string) error
-
-	// Store a boolean at the target
-	setBool(v bool) error
-
-	// Store an int64 at the target
-	setInt64(v int64) error
-
-	// Store a float64 at the target
-	setFloat64(v float64) error
-
-	// Stores any  value at the target
-	set(v reflect.Value) error
-}
-
-// valueTarget just contains a reflect.Value that can be set.
-// It is used for struct fields.
-type valueTarget reflect.Value
-
-func (t valueTarget) get() reflect.Value {
-	return reflect.Value(t)
-}
-
-func (t valueTarget) set(v reflect.Value) error {
-	reflect.Value(t).Set(v)
-	return nil
-}
-
-func (t valueTarget) setString(v string) error {
-	t.get().SetString(v)
-	return nil
-}
-
-func (t valueTarget) setBool(v bool) error {
-	t.get().SetBool(v)
-	return nil
-}
-
-func (t valueTarget) setInt64(v int64) error {
-	t.get().SetInt(v)
-	return nil
-}
-
-func (t valueTarget) setFloat64(v float64) error {
-	t.get().SetFloat(v)
-	return nil
-}
-
-// interfaceTarget wraps an other target to dereference on get.
-type interfaceTarget struct {
-	x target
-}
-
-func (t interfaceTarget) get() reflect.Value {
-	return t.x.get().Elem()
-}
-
-func (t interfaceTarget) set(v reflect.Value) error {
-	return t.x.set(v)
-}
-
-func (t interfaceTarget) setString(v string) error {
-	return t.x.setString(v)
-}
-
-func (t interfaceTarget) setBool(v bool) error {
-	return t.x.setBool(v)
-}
-
-func (t interfaceTarget) setInt64(v int64) error {
-	return t.x.setInt64(v)
-}
-
-func (t interfaceTarget) setFloat64(v float64) error {
-	return t.x.setFloat64(v)
-}
-
-// mapTarget targets a specific key of a map.
-type mapTarget struct {
-	v reflect.Value
-	k reflect.Value
-}
-
-func (t mapTarget) get() reflect.Value {
-	return t.v.MapIndex(t.k)
-}
-
-func (t mapTarget) set(v reflect.Value) error {
-	t.v.SetMapIndex(t.k, v)
-	return nil
-}
-
-func (t mapTarget) setString(v string) error {
-	return t.set(reflect.ValueOf(v))
-}
-
-func (t mapTarget) setBool(v bool) error {
-	return t.set(reflect.ValueOf(v))
-}
-
-func (t mapTarget) setInt64(v int64) error {
-	return t.set(reflect.ValueOf(v))
-}
-
-func (t mapTarget) setFloat64(v float64) error {
-	return t.set(reflect.ValueOf(v))
-}
-
-// makes sure that the value pointed at by t is indexable (Slice, Array), or
-// dereferences to an indexable (Ptr, Interface).
-func ensureValueIndexable(t target) error {
-	f := t.get()
-
-	switch f.Type().Kind() {
-	case reflect.Slice:
-		if f.IsNil() {
-			return t.set(reflect.MakeSlice(f.Type(), 0, 0))
-		}
-	case reflect.Interface:
-		if f.IsNil() || f.Elem().Type() != sliceInterfaceType {
-			return t.set(reflect.MakeSlice(sliceInterfaceType, 0, 0))
-		}
-		if f.Elem().Type().Kind() != reflect.Slice {
-			return fmt.Errorf("interface is pointing to a %s, not a slice", f.Kind())
-		}
-	case reflect.Ptr:
-		if f.IsNil() {
-			ptr := reflect.New(f.Type().Elem())
-			err := t.set(ptr)
-			if err != nil {
-				return err
-			}
-			f = t.get()
-		}
-		return ensureValueIndexable(valueTarget(f.Elem()))
-	case reflect.Array:
-		// arrays are always initialized.
-	default:
-		return fmt.Errorf("cannot initialize a slice in %s", f.Kind())
-	}
-	return nil
-}
-
-var sliceInterfaceType = reflect.TypeOf([]interface{}{})
-var mapStringInterfaceType = reflect.TypeOf(map[string]interface{}{})
-
-func ensureMapIfInterface(x target) {
-	v := x.get()
-	if v.Kind() == reflect.Interface && v.IsNil() {
-		newElement := reflect.MakeMap(mapStringInterfaceType)
-		x.set(newElement)
-	}
-}
-
-func setString(t target, v string) error {
-	f := t.get()
-
-	switch f.Kind() {
-	case reflect.String:
-		return t.setString(v)
-	case reflect.Interface:
-		return t.set(reflect.ValueOf(v))
-	default:
-		return fmt.Errorf("cannot assign string to a %s", f.Kind())
-	}
-}
-
-func setBool(t target, v bool) error {
-	f := t.get()
-
-	switch f.Kind() {
-	case reflect.Bool:
-		return t.setBool(v)
-	case reflect.Interface:
-		return t.set(reflect.ValueOf(v))
-	default:
-		return fmt.Errorf("cannot assign bool to a %s", f.String())
-	}
-}
-
-const maxInt = int64(^uint(0) >> 1)
-const minInt = -maxInt - 1
-
-func setInt64(t target, v int64) error {
-	f := t.get()
-
-	switch f.Kind() {
-	case reflect.Int64:
-		return t.setInt64(v)
-	case reflect.Int32:
-		if v < math.MinInt32 || v > math.MaxInt32 {
-			return fmt.Errorf("integer %d does not fit in an int32", v)
-		}
-		return t.set(reflect.ValueOf(int32(v)))
-	case reflect.Int16:
-		if v < math.MinInt16 || v > math.MaxInt16 {
-			return fmt.Errorf("integer %d does not fit in an int16", v)
-		}
-		return t.set(reflect.ValueOf(int16(v)))
-	case reflect.Int8:
-		if v < math.MinInt8 || v > math.MaxInt8 {
-			return fmt.Errorf("integer %d does not fit in an int8", v)
-		}
-		return t.set(reflect.ValueOf(int8(v)))
-	case reflect.Int:
-		if v < minInt || v > maxInt {
-			return fmt.Errorf("integer %d does not fit in an int", v)
-		}
-		return t.set(reflect.ValueOf(int(v)))
-
-	case reflect.Uint64:
-		if v < 0 {
-			return fmt.Errorf("negative integer %d cannot be stored in an uint64", v)
-		}
-		return t.set(reflect.ValueOf(uint64(v)))
-	case reflect.Uint32:
-		if v < 0 {
-			return fmt.Errorf("negative integer %d cannot be stored in an uint32", v)
-		}
-		if v > math.MaxUint32 {
-			return fmt.Errorf("integer %d cannot be stored in an uint32", v)
-		}
-		return t.set(reflect.ValueOf(uint32(v)))
-	case reflect.Uint16:
-		if v < 0 {
-			return fmt.Errorf("negative integer %d cannot be stored in an uint16", v)
-		}
-		if v > math.MaxUint16 {
-			return fmt.Errorf("integer %d cannot be stored in an uint16", v)
-		}
-		return t.set(reflect.ValueOf(uint16(v)))
-	case reflect.Uint8:
-		if v < 0 {
-			return fmt.Errorf("negative integer %d cannot be stored in an uint8", v)
-		}
-		if v > math.MaxUint8 {
-			return fmt.Errorf("integer %d cannot be stored in an uint8", v)
-		}
-		return t.set(reflect.ValueOf(uint8(v)))
-	case reflect.Uint:
-		if v < 0 {
-			return fmt.Errorf("negative integer %d cannot be stored in an uint", v)
-		}
-		return t.set(reflect.ValueOf(uint(v)))
-	case reflect.Interface:
-		return t.set(reflect.ValueOf(v))
-	default:
-		return fmt.Errorf("cannot assign int64 to a %s", f.String())
-	}
-}
-
-func setFloat64(t target, v float64) error {
-	f := t.get()
-
-	switch f.Kind() {
-	case reflect.Float64:
-		return t.setFloat64(v)
-	case reflect.Float32:
-		if v > math.MaxFloat32 {
-			return fmt.Errorf("float %f cannot be stored in a float32", v)
-		}
-		return t.set(reflect.ValueOf(float32(v)))
-	case reflect.Interface:
-		return t.set(reflect.ValueOf(v))
-	default:
-		return fmt.Errorf("cannot assign float64 to a %s", f.String())
-	}
-}
-
-// Returns the element at idx of the value pointed at by target, or an error if
-// t does not point to an indexable.
-// If the target points to an Array and idx is out of bounds, it returns
-// (nil, nil) as this is not a fatal error (the unmarshaler will skip).
-func elementAt(t target, idx int) (target, error) {
-	f := t.get()
-
-	switch f.Kind() {
-	case reflect.Slice:
-		// TODO: use the idx function argument and avoid alloc if possible.
-		idx := f.Len()
-		err := t.set(reflect.Append(f, reflect.New(f.Type().Elem()).Elem()))
-		if err != nil {
-			return nil, err
-		}
-		return valueTarget(t.get().Index(idx)), nil
-	case reflect.Array:
-		if idx >= f.Len() {
-			return nil, nil
-		}
-		return valueTarget(f.Index(idx)), nil
-	case reflect.Interface:
-		if f.IsNil() {
-			panic("interface should have been initialized")
-		}
-		ifaceElem := f.Elem()
-		if ifaceElem.Kind() != reflect.Slice {
-			return nil, fmt.Errorf("cannot elementAt on a %s", f.Kind())
-		}
-		idx := ifaceElem.Len()
-		newElem := reflect.New(ifaceElem.Type().Elem()).Elem()
-		newSlice := reflect.Append(ifaceElem, newElem)
-		err := t.set(newSlice)
-		if err != nil {
-			return nil, err
-		}
-		return valueTarget(t.get().Elem().Index(idx)), nil
-	case reflect.Ptr:
-		return elementAt(valueTarget(f.Elem()), idx)
-	default:
-		return nil, fmt.Errorf("cannot elementAt on a %s", f.Kind())
-	}
-}
-
-func (d *decoder) scopeTableTarget(append bool, t target, name string) (target, bool, error) {
-	x := t.get()
-
-	switch x.Kind() {
-	// Kinds that need to recurse
-
-	case reflect.Interface:
-		t, err := scopeInterface(append, t)
-		if err != nil {
-			return t, false, err
-		}
-		return d.scopeTableTarget(append, t, name)
-	case reflect.Ptr:
-		t, err := scopePtr(t)
-		if err != nil {
-			return t, false, err
-		}
-		return d.scopeTableTarget(append, t, name)
-	case reflect.Slice:
-		t, err := scopeSlice(append, t)
-		if err != nil {
-			return t, false, err
-		}
-		append = false
-		return d.scopeTableTarget(append, t, name)
-	case reflect.Array:
-		t, err := d.scopeArray(append, t)
-		if err != nil {
-			return t, false, err
-		}
-		append = false
-		return d.scopeTableTarget(append, t, name)
-
-	// Terminal kinds
-
-	case reflect.Struct:
-		return scopeStruct(x, name)
-	case reflect.Map:
-		if x.IsNil() {
-			t.set(reflect.MakeMap(x.Type()))
-			x = t.get()
-		}
-
-		return scopeMap(x, name)
-	default:
-		panic(fmt.Errorf("can't scope on a %s", x.Kind()))
-	}
-}
-
-func scopeInterface(append bool, t target) (target, error) {
-	err := initInterface(append, t)
-	if err != nil {
-		return t, err
-	}
-	return interfaceTarget{t}, nil
-}
-
-func scopePtr(t target) (target, error) {
-	err := initPtr(t)
-	if err != nil {
-		return t, err
-	}
-	return valueTarget(t.get().Elem()), nil
-}
-
-func initPtr(t target) error {
-	x := t.get()
-	if !x.IsNil() {
-		return nil
-	}
-	return t.set(reflect.New(x.Type().Elem()))
-}
-
-// initInterface makes sure that the interface pointed at by the target is not
-// nil.
-// Returns the target to the initialized value of the target.
-func initInterface(append bool, t target) error {
-	x := t.get()
-
-	if x.Kind() != reflect.Interface {
-		panic("this should only be called on interfaces")
-	}
-
-	if !x.IsNil() && (x.Elem().Type() == sliceInterfaceType || x.Elem().Type() == mapStringInterfaceType) {
-		return nil
-	}
-
-	var newElement reflect.Value
-	if append {
-		newElement = reflect.MakeSlice(sliceInterfaceType, 0, 0)
-	} else {
-		newElement = reflect.MakeMap(mapStringInterfaceType)
-	}
-	err := t.set(newElement)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func scopeSlice(append bool, t target) (target, error) {
-	v := t.get()
-
-	if append {
-		newElem := reflect.New(v.Type().Elem())
-		newSlice := reflect.Append(v, newElem.Elem())
-		err := t.set(newSlice)
-		if err != nil {
-			return t, err
-		}
-		v = t.get()
-	}
-	return valueTarget(v.Index(v.Len() - 1)), nil
-}
-
-func (d *decoder) scopeArray(append bool, t target) (target, error) {
-	v := t.get()
-
-	idx := d.arrayIndex(append, v)
-
-	if idx >= v.Len() {
-		return nil, fmt.Errorf("not enough space in the array")
-	}
-
-	return valueTarget(v.Index(idx)), nil
-}
-
-func scopeMap(v reflect.Value, name string) (target, bool, error) {
-	k := reflect.ValueOf(name)
-
-	keyType := v.Type().Key()
-	if !k.Type().AssignableTo(keyType) {
-		if !k.Type().ConvertibleTo(keyType) {
-			return nil, false, fmt.Errorf("cannot convert string into map key type %s", keyType)
-		}
-		k = k.Convert(keyType)
-	}
-
-	if !v.MapIndex(k).IsValid() {
-		newElem := reflect.New(v.Type().Elem())
-		v.SetMapIndex(k, newElem.Elem())
-	}
-
-	return mapTarget{
-		v: v,
-		k: k,
-	}, true, nil
-}
-
-type fieldPathsMap = map[string][]int
-
-type fieldPathsCache struct {
-	m map[reflect.Type]fieldPathsMap
-	l sync.RWMutex
-}
-
-func (c *fieldPathsCache) get(t reflect.Type) (fieldPathsMap, bool) {
-	c.l.RLock()
-	paths, ok := c.m[t]
-	c.l.RUnlock()
-	return paths, ok
-}
-
-func (c *fieldPathsCache) set(t reflect.Type, m fieldPathsMap) {
-	c.l.Lock()
-	c.m[t] = m
-	c.l.Unlock()
-}
-
-var globalFieldPathsCache = fieldPathsCache{
-	m: map[reflect.Type]fieldPathsMap{},
-	l: sync.RWMutex{},
-}
-
-func scopeStruct(v reflect.Value, name string) (target, bool, error) {
-	// TODO: cache this, and reduce allocations
-
-	fieldPaths, ok := globalFieldPathsCache.get(v.Type())
-	if !ok {
-		fieldPaths = map[string][]int{}
-
-		path := make([]int, 0, 16)
-		var walk func(reflect.Value)
-		walk = func(v reflect.Value) {
-			t := v.Type()
-			for i := 0; i < t.NumField(); i++ {
-				l := len(path)
-				path = append(path, i)
-				f := t.Field(i)
-				if f.PkgPath != "" {
-					// only consider exported fields
-				} else if f.Anonymous {
-					walk(v.Field(i))
-				} else {
-					fieldName, ok := f.Tag.Lookup("toml")
-					if !ok {
-						fieldName = f.Name
-					}
-
-					pathCopy := make([]int, len(path))
-					copy(pathCopy, path)
-
-					fieldPaths[fieldName] = pathCopy
-					// extra copy for the case-insensitive match
-					fieldPaths[strings.ToLower(fieldName)] = pathCopy
-				}
-				path = path[:l]
-			}
-		}
-
-		walk(v)
-
-		globalFieldPathsCache.set(v.Type(), fieldPaths)
-	}
-
-	path, ok := fieldPaths[name]
-	if !ok {
-		path, ok = fieldPaths[strings.ToLower(name)]
-	}
-	if !ok {
-		return nil, false, nil
-	}
-
-	return valueTarget(v.FieldByIndex(path)), true, nil
-}

targets_test.go

@@ -1,184 +0,0 @@
-package toml
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestStructTarget_Ensure(t *testing.T) {
-	examples := []struct {
-		desc  string
-		input reflect.Value
-		name  string
-		test  func(v reflect.Value, err error)
-	}{
-		{
-			desc:  "handle a nil slice of string",
-			input: reflect.ValueOf(&struct{ A []string }{}).Elem(),
-			name:  "A",
-			test: func(v reflect.Value, err error) {
-				assert.NoError(t, err)
-				assert.False(t, v.IsNil())
-			},
-		},
-		{
-			desc:  "handle an existing slice of string",
-			input: reflect.ValueOf(&struct{ A []string }{A: []string{"foo"}}).Elem(),
-			name:  "A",
-			test: func(v reflect.Value, err error) {
-				assert.NoError(t, err)
-				require.False(t, v.IsNil())
-				s := v.Interface().([]string)
-				assert.Equal(t, []string{"foo"}, s)
-			},
-		},
-	}
-
-	for _, e := range examples {
-		t.Run(e.desc, func(t *testing.T) {
-			d := decoder{}
-			target, _, err := d.scopeTableTarget(false, valueTarget(e.input), e.name)
-			require.NoError(t, err)
-			err = ensureValueIndexable(target)
-			v := target.get()
-			e.test(v, err)
-		})
-	}
-}
-
-func TestStructTarget_SetString(t *testing.T) {
-	str := "value"
-
-	examples := []struct {
-		desc  string
-		input reflect.Value
-		name  string
-		test  func(v reflect.Value, err error)
-	}{
-		{
-			desc:  "sets a string",
-			input: reflect.ValueOf(&struct{ A string }{}).Elem(),
-			name:  "A",
-			test: func(v reflect.Value, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, str, v.String())
-			},
-		},
-		{
-			desc:  "fails on a float",
-			input: reflect.ValueOf(&struct{ A float64 }{}).Elem(),
-			name:  "A",
-			test: func(v reflect.Value, err error) {
-				assert.Error(t, err)
-			},
-		},
-		{
-			desc:  "fails on a slice",
-			input: reflect.ValueOf(&struct{ A []string }{}).Elem(),
-			name:  "A",
-			test: func(v reflect.Value, err error) {
-				assert.Error(t, err)
-			},
-		},
-	}
-
-	for _, e := range examples {
-		t.Run(e.desc, func(t *testing.T) {
-			d := decoder{}
-			target, _, err := d.scopeTableTarget(false, valueTarget(e.input), e.name)
-			require.NoError(t, err)
-			err = setString(target, str)
-			v := target.get()
-			e.test(v, err)
-		})
-	}
-}
-
-func TestPushNew(t *testing.T) {
-	t.Run("slice of strings", func(t *testing.T) {
-		type Doc struct {
-			A []string
-		}
-		d := Doc{}
-
-		dec := decoder{}
-		x, _, err := dec.scopeTableTarget(false, valueTarget(reflect.ValueOf(&d).Elem()), "A")
-		require.NoError(t, err)
-
-		n, err := elementAt(x, 0)
-		require.NoError(t, err)
-		require.NoError(t, n.setString("hello"))
-		require.Equal(t, []string{"hello"}, d.A)
-
-		n, err = elementAt(x, 1)
-		require.NoError(t, err)
-		require.NoError(t, n.setString("world"))
-		require.Equal(t, []string{"hello", "world"}, d.A)
-	})
-
-	t.Run("slice of interfaces", func(t *testing.T) {
-		type Doc struct {
-			A []interface{}
-		}
-		d := Doc{}
-
-		dec := decoder{}
-		x, _, err := dec.scopeTableTarget(false, valueTarget(reflect.ValueOf(&d).Elem()), "A")
-		require.NoError(t, err)
-
-		n, err := elementAt(x, 0)
-		require.NoError(t, err)
-		require.NoError(t, setString(n, "hello"))
-		require.Equal(t, []interface{}{"hello"}, d.A)
-
-		n, err = elementAt(x, 1)
-		require.NoError(t, err)
-		require.NoError(t, setString(n, "world"))
-		require.Equal(t, []interface{}{"hello", "world"}, d.A)
-	})
-}
-
-func TestScope_Struct(t *testing.T) {
-	examples := []struct {
-		desc  string
-		input reflect.Value
-		name  string
-		err   bool
-		found bool
-		idx   []int
-	}{
-		{
-			desc:  "simple field",
-			input: reflect.ValueOf(&struct{ A string }{}).Elem(),
-			name:  "A",
-			idx:   []int{0},
-			found: true,
-		},
-		{
-			desc:  "fails not-exported field",
-			input: reflect.ValueOf(&struct{ a string }{}).Elem(),
-			name:  "a",
-			err:   false,
-			found: false,
-		},
-	}
-
-	for _, e := range examples {
-		t.Run(e.desc, func(t *testing.T) {
-			dec := decoder{}
-			x, found, err := dec.scopeTableTarget(false, valueTarget(e.input), e.name)
-			assert.Equal(t, e.found, found)
-			if e.err {
-				assert.Error(t, err)
-			}
-			if found {
-				x2, ok := x.(valueTarget)
-				require.True(t, ok)
-				x2.get()
-			}
-		})
-	}
-}

test-go-versions.sh

@@ -0,0 +1,597 @@
+#!/usr/bin/env bash
+
+set -uo pipefail
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Go versions to test (1.11 through 1.26)
+GO_VERSIONS=(
+    "1.11"
+    "1.12"
+    "1.13"
+    "1.14"
+    "1.15"
+    "1.16"
+    "1.17"
+    "1.18"
+    "1.19"
+    "1.20"
+    "1.21"
+    "1.22"
+    "1.23"
+    "1.24"
+    "1.25"
+    "1.26"
+)
+
+# Default values
+PARALLEL=true
+VERBOSE=false
+OUTPUT_DIR="test-results"
+DOCKER_TIMEOUT="10m"
+
+usage() {
+    cat << EOF
+Usage: $0 [OPTIONS] [GO_VERSIONS...]
+
+Test go-toml across multiple Go versions using Docker containers.
+
+The script reports the lowest continuous supported Go version (where all subsequent 
+versions pass) and only exits with non-zero status if either of the two most recent 
+Go versions fail, indicating immediate attention is needed.
+
+Note: For Go versions < 1.21, the script automatically updates go.mod to match the 
+target version, but older versions may still fail due to missing standard library 
+features (e.g., the 'slices' package introduced in Go 1.21).
+
+OPTIONS:
+    -h, --help          Show this help message
+    -s, --sequential    Run tests sequentially instead of in parallel
+    -v, --verbose       Enable verbose output
+    -o, --output DIR    Output directory for test results (default: test-results)
+    -t, --timeout TIME  Docker timeout for each test (default: 10m)
+    --list              List available Go versions and exit
+
+ARGUMENTS:
+    GO_VERSIONS         Specific Go versions to test (default: all supported versions)
+                        Examples: 1.21 1.22 1.23
+
+EXAMPLES:
+    $0                          # Test all Go versions in parallel
+    $0 --sequential             # Test all Go versions sequentially
+    $0 1.21 1.22 1.23          # Test specific versions
+    $0 --verbose --output ./results 1.25 1.26  # Verbose output to custom directory
+
+EXIT CODES:
+    0                   Recent Go versions pass (good compatibility)
+    1                   Recent Go versions fail (needs attention) or script error
+
+EOF
+}
+
+log() {
+    echo -e "${BLUE}[$(date +'%H:%M:%S')]${NC} $*" >&2
+}
+
+log_success() {
+    echo -e "${GREEN}[$(date +'%H:%M:%S')] ✓${NC} $*" >&2
+}
+
+log_error() {
+    echo -e "${RED}[$(date +'%H:%M:%S')] ✗${NC} $*" >&2
+}
+
+log_warning() {
+    echo -e "${YELLOW}[$(date +'%H:%M:%S')] ⚠${NC} $*" >&2
+}
+
+# Parse command line arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        -h|--help)
+            usage
+            exit 0
+            ;;
+        -s|--sequential)
+            PARALLEL=false
+            shift
+            ;;
+        -v|--verbose)
+            VERBOSE=true
+            shift
+            ;;
+        -o|--output)
+            OUTPUT_DIR="$2"
+            shift 2
+            ;;
+        -t|--timeout)
+            DOCKER_TIMEOUT="$2"
+            shift 2
+            ;;
+        --list)
+            echo "Available Go versions:"
+            printf '%s\n' "${GO_VERSIONS[@]}"
+            exit 0
+            ;;
+        -*)
+            echo "Unknown option: $1" >&2
+            usage
+            exit 1
+            ;;
+        *)
+            # Remaining arguments are Go versions
+            break
+            ;;
+    esac
+done
+
+# If specific versions provided, use those instead of defaults
+if [[ $# -gt 0 ]]; then
+    GO_VERSIONS=("$@")
+fi
+
+# Validate Go versions
+for version in "${GO_VERSIONS[@]}"; do
+    if ! [[ "$version" =~ ^1\.(1[1-9]|2[0-6])$ ]]; then
+        log_error "Invalid Go version: $version. Supported versions: 1.11-1.26"
+        exit 1
+    fi
+done
+
+# Check if Docker is available
+if ! command -v docker &> /dev/null; then
+    log_error "Docker is required but not installed or not in PATH"
+    exit 1
+fi
+
+# Check if Docker daemon is running
+if ! docker info &> /dev/null; then
+    log_error "Docker daemon is not running"
+    exit 1
+fi
+
+# Create output directory
+mkdir -p "$OUTPUT_DIR"
+
+# Function to test a single Go version
+test_go_version() {
+    local go_version="$1"
+    local container_name="go-toml-test-${go_version}"
+    local result_file="${OUTPUT_DIR}/go-${go_version}.txt"
+    local dockerfile_content
+
+    log "Testing Go $go_version..."
+
+    # Create a temporary Dockerfile for this version
+    # For Go versions < 1.21, we need to update go.mod to match the Go version
+    local needs_go_mod_update=false
+    if [[ $(echo "$go_version 1.21" | tr ' ' '\n' | sort -V | head -n1) == "$go_version" && "$go_version" != "1.21" ]]; then
+        needs_go_mod_update=true
+    fi
+    
+    dockerfile_content="FROM golang:${go_version}-alpine
+
+# Install git (required for go mod)
+RUN apk add --no-cache git
+
+# Set working directory
+WORKDIR /app
+
+# Copy source code
+COPY . ."
+
+    # Add go.mod update step for older Go versions
+    if [[ "$needs_go_mod_update" == true ]]; then
+        dockerfile_content="$dockerfile_content
+
+# Update go.mod to match Go version (required for Go < 1.21)
+RUN if [ -f go.mod ]; then sed -i 's/^go [0-9]\\+\\.[0-9]\\+\\(\\.[0-9]\\+\\)\\?/go $go_version/' go.mod; fi
+
+# Note: Go versions < 1.21 may fail due to missing standard library packages (e.g., slices)
+# This is expected for projects that use Go 1.21+ features"
+    fi
+    
+    dockerfile_content="$dockerfile_content
+
+# Run tests
+CMD [\"sh\", \"-c\", \"go version && echo '--- Running go test ./... ---' && go test ./...\"]"
+
+    # Create temporary directory for this test
+    local temp_dir
+    temp_dir=$(mktemp -d)
+
+    # Copy source to temp directory (excluding test results and git)
+    rsync -a --exclude="$OUTPUT_DIR" --exclude=".git" --exclude="*.test" . "$temp_dir/"
+
+    # Create Dockerfile in temp directory
+    echo "$dockerfile_content" > "$temp_dir/Dockerfile"
+
+    # Build and run container
+    local exit_code=0
+    local output
+
+    if $VERBOSE; then
+        log "Building Docker image for Go $go_version..."
+    fi
+
+    # Capture both stdout and stderr, and the exit code
+    if output=$(cd "$temp_dir" && timeout "$DOCKER_TIMEOUT" docker build -t "$container_name" . 2>&1 && \
+                timeout "$DOCKER_TIMEOUT" docker run --rm "$container_name" 2>&1); then
+        log_success "Go $go_version: PASSED"
+        echo "PASSED" > "${result_file}.status"
+    else
+        exit_code=$?
+        log_error "Go $go_version: FAILED (exit code: $exit_code)"
+        echo "FAILED" > "${result_file}.status"
+    fi
+
+    # Save full output
+    echo "$output" > "$result_file"
+
+    # Clean up
+    docker rmi "$container_name" &> /dev/null || true
+    rm -rf "$temp_dir"
+
+    if $VERBOSE; then
+        echo "--- Go $go_version output ---"
+        echo "$output"
+        echo "--- End Go $go_version output ---"
+    fi
+
+    return $exit_code
+}
+
+# Function to run tests in parallel
+run_parallel() {
+    local pids=()
+    local failed_versions=()
+
+    log "Starting parallel tests for ${#GO_VERSIONS[@]} Go versions..."
+
+    # Start all tests in background
+    for version in "${GO_VERSIONS[@]}"; do
+        test_go_version "$version" &
+        pids+=($!)
+    done
+
+    # Wait for all tests to complete
+    for i in "${!pids[@]}"; do
+        local pid=${pids[$i]}
+        local version=${GO_VERSIONS[$i]}
+
+        if ! wait $pid; then
+            failed_versions+=("$version")
+        fi
+    done
+
+    return ${#failed_versions[@]}
+}
+
+# Function to run tests sequentially
+run_sequential() {
+    local failed_versions=()
+
+    log "Starting sequential tests for ${#GO_VERSIONS[@]} Go versions..."
+
+    for version in "${GO_VERSIONS[@]}"; do
+        if ! test_go_version "$version"; then
+            failed_versions+=("$version")
+        fi
+    done
+
+    return ${#failed_versions[@]}
+}
+
+# Main execution
+main() {
+    local start_time
+    start_time=$(date +%s)
+
+    log "Starting Go version compatibility tests..."
+    log "Testing versions: ${GO_VERSIONS[*]}"
+    log "Output directory: $OUTPUT_DIR"
+    log "Parallel execution: $PARALLEL"
+
+    local failed_count
+    if $PARALLEL; then
+        run_parallel
+        failed_count=$?
+    else
+        run_sequential
+        failed_count=$?
+    fi
+
+    local end_time
+    end_time=$(date +%s)
+    local duration=$((end_time - start_time))
+
+    # Collect results for display
+    local passed_versions=()
+    local failed_versions=()
+    local unknown_versions=()
+    local passed_count=0
+
+    for version in "${GO_VERSIONS[@]}"; do
+        local status_file="${OUTPUT_DIR}/go-${version}.txt.status"
+        if [[ -f "$status_file" ]]; then
+            local status
+            status=$(cat "$status_file")
+            if [[ "$status" == "PASSED" ]]; then
+                passed_versions+=("$version")
+                ((passed_count++))
+            else
+                failed_versions+=("$version")
+            fi
+        else
+            unknown_versions+=("$version")
+        fi
+    done
+
+    # Generate summary report
+    local summary_file="${OUTPUT_DIR}/summary.txt"
+    {
+        echo "Go Version Compatibility Test Summary"
+        echo "====================================="
+        echo "Date: $(date)"
+        echo "Duration: ${duration}s"
+        echo "Parallel: $PARALLEL"
+        echo ""
+        echo "Results:"
+
+        for version in "${GO_VERSIONS[@]}"; do
+            local status_file="${OUTPUT_DIR}/go-${version}.txt.status"
+            if [[ -f "$status_file" ]]; then
+                local status
+                status=$(cat "$status_file")
+                if [[ "$status" == "PASSED" ]]; then
+                    echo "  Go $version: ✓ PASSED"
+                else
+                    echo "  Go $version: ✗ FAILED"
+                fi
+            else
+                echo "  Go $version: ? UNKNOWN (no status file)"
+            fi
+        done
+
+        echo ""
+        echo "Summary: $passed_count/${#GO_VERSIONS[@]} versions passed"
+
+        if [[ $failed_count -gt 0 ]]; then
+            echo ""
+            echo "Failed versions details:"
+            for version in "${failed_versions[@]}"; do
+                echo ""
+                echo "--- Go $version (FAILED) ---"
+                local result_file="${OUTPUT_DIR}/go-${version}.txt"
+                if [[ -f "$result_file" ]]; then
+                    tail -n 30 "$result_file"
+                fi
+            done
+        fi
+    } > "$summary_file"
+
+        # Find lowest continuous supported version and check recent versions
+    local lowest_continuous_version=""
+    local recent_versions_failed=false
+    
+    # Sort versions to ensure proper order
+    local sorted_versions=()
+    for version in "${GO_VERSIONS[@]}"; do
+        sorted_versions+=("$version")
+    done
+    # Sort versions numerically (1.11, 1.12, ..., 1.25)
+    IFS=$'\n' sorted_versions=($(sort -V <<< "${sorted_versions[*]}"))
+    
+    # Find lowest continuous supported version (all versions from this point onwards pass)
+    for version in "${sorted_versions[@]}"; do
+        local status_file="${OUTPUT_DIR}/go-${version}.txt.status"
+        local all_subsequent_pass=true
+        
+        # Check if this version and all subsequent versions pass
+        local found_current=false
+        for check_version in "${sorted_versions[@]}"; do
+            if [[ "$check_version" == "$version" ]]; then
+                found_current=true
+            fi
+            
+            if [[ "$found_current" == true ]]; then
+                local check_status_file="${OUTPUT_DIR}/go-${check_version}.txt.status"
+                if [[ -f "$check_status_file" ]]; then
+                    local status
+                    status=$(cat "$check_status_file")
+                    if [[ "$status" != "PASSED" ]]; then
+                        all_subsequent_pass=false
+                        break
+                    fi
+                else
+                    all_subsequent_pass=false
+                    break
+                fi
+            fi
+        done
+        
+        if [[ "$all_subsequent_pass" == true ]]; then
+            lowest_continuous_version="$version"
+            break
+        fi
+    done
+    
+    # Check if the two most recent versions failed
+    local num_versions=${#sorted_versions[@]}
+    if [[ $num_versions -ge 2 ]]; then
+        local second_recent="${sorted_versions[$((num_versions-2))]}"
+        local most_recent="${sorted_versions[$((num_versions-1))]}"
+        
+        local second_recent_status_file="${OUTPUT_DIR}/go-${second_recent}.txt.status"
+        local most_recent_status_file="${OUTPUT_DIR}/go-${most_recent}.txt.status"
+        
+        local second_recent_failed=false
+        local most_recent_failed=false
+        
+        if [[ -f "$second_recent_status_file" ]]; then
+            local status
+            status=$(cat "$second_recent_status_file")
+            if [[ "$status" != "PASSED" ]]; then
+                second_recent_failed=true
+            fi
+        else
+            second_recent_failed=true
+        fi
+        
+        if [[ -f "$most_recent_status_file" ]]; then
+            local status
+            status=$(cat "$most_recent_status_file")
+            if [[ "$status" != "PASSED" ]]; then
+                most_recent_failed=true
+            fi
+        else
+            most_recent_failed=true
+        fi
+        
+        if [[ "$second_recent_failed" == true || "$most_recent_failed" == true ]]; then
+            recent_versions_failed=true
+        fi
+    elif [[ $num_versions -eq 1 ]]; then
+        # Only one version tested, check if it's the most recent and failed
+        local only_version="${sorted_versions[0]}"
+        local only_status_file="${OUTPUT_DIR}/go-${only_version}.txt.status"
+        
+        if [[ -f "$only_status_file" ]]; then
+            local status
+            status=$(cat "$only_status_file")
+            if [[ "$status" != "PASSED" ]]; then
+                recent_versions_failed=true
+            fi
+        else
+            recent_versions_failed=true
+        fi
+    fi
+    
+    # Display summary
+    echo ""
+    log "Test completed in ${duration}s"
+    log "Summary report: $summary_file"
+    
+    echo ""
+    echo "========================================"
+    echo "           FINAL RESULTS"
+    echo "========================================"
+    echo ""
+    
+    # Display passed versions
+    if [[ ${#passed_versions[@]} -gt 0 ]]; then
+        log_success "PASSED (${#passed_versions[@]}/${#GO_VERSIONS[@]}):"
+        # Sort passed versions for display
+        local sorted_passed=()
+        for version in "${sorted_versions[@]}"; do
+            for passed_version in "${passed_versions[@]}"; do
+                if [[ "$version" == "$passed_version" ]]; then
+                    sorted_passed+=("$version")
+                    break
+                fi
+            done
+        done
+        for version in "${sorted_passed[@]}"; do
+            echo -e "  ${GREEN}✓${NC} Go $version"
+        done
+        echo ""
+    fi
+    
+    # Display failed versions
+    if [[ ${#failed_versions[@]} -gt 0 ]]; then
+        log_error "FAILED (${#failed_versions[@]}/${#GO_VERSIONS[@]}):"
+        # Sort failed versions for display
+        local sorted_failed=()
+        for version in "${sorted_versions[@]}"; do
+            for failed_version in "${failed_versions[@]}"; do
+                if [[ "$version" == "$failed_version" ]]; then
+                    sorted_failed+=("$version")
+                    break
+                fi
+            done
+        done
+        for version in "${sorted_failed[@]}"; do
+            echo -e "  ${RED}✗${NC} Go $version"
+        done
+        echo ""
+        
+        # Show failure details
+        echo "========================================"
+        echo "         FAILURE DETAILS"
+        echo "========================================"
+        echo ""
+        
+        for version in "${sorted_failed[@]}"; do
+            echo -e "${RED}--- Go $version FAILURE LOGS (last 30 lines) ---${NC}"
+            local result_file="${OUTPUT_DIR}/go-${version}.txt"
+            if [[ -f "$result_file" ]]; then
+                tail -n 30 "$result_file" | sed 's/^/  /'
+            else
+                echo "  No log file found: $result_file"
+            fi
+            echo ""
+        done
+    fi
+    
+    # Display unknown versions
+    if [[ ${#unknown_versions[@]} -gt 0 ]]; then
+        log_warning "UNKNOWN (${#unknown_versions[@]}/${#GO_VERSIONS[@]}):"
+        for version in "${unknown_versions[@]}"; do
+            echo -e "  ${YELLOW}?${NC} Go $version (no status file)"
+        done
+        echo ""
+    fi
+    
+    echo "========================================"
+    echo "         COMPATIBILITY SUMMARY"
+    echo "========================================"
+    echo ""
+    
+    if [[ -n "$lowest_continuous_version" ]]; then
+        log_success "Lowest continuous supported version: Go $lowest_continuous_version"
+        echo "  (All versions from Go $lowest_continuous_version onwards pass)"
+    else
+        log_error "No continuous version support found"
+        echo "  (No version has all subsequent versions passing)"
+    fi
+    
+    echo ""
+    echo "========================================"
+    echo "Full detailed logs available in: $OUTPUT_DIR"
+    echo "========================================"
+    
+    # Determine exit code based on recent versions
+    if [[ "$recent_versions_failed" == true ]]; then
+        log_error "OVERALL RESULT: Recent Go versions failed - this needs attention!"
+        if [[ -n "$lowest_continuous_version" ]]; then
+            echo "Note: Continuous support starts from Go $lowest_continuous_version"
+        fi
+        exit 1
+    else
+        log_success "OVERALL RESULT: Recent Go versions pass - compatibility looks good!"
+        if [[ -n "$lowest_continuous_version" ]]; then
+            echo "Continuous support starts from Go $lowest_continuous_version"
+        fi
+        exit 0
+    fi
+}
+
+# Trap to clean up on exit
+cleanup() {
+    # Kill any remaining background processes
+    jobs -p | xargs -r kill 2>/dev/null || true
+
+    # Clean up any remaining Docker containers
+    docker ps -q --filter "name=go-toml-test-" | xargs -r docker stop 2>/dev/null || true
+    docker images -q --filter "reference=go-toml-test-*" | xargs -r docker rmi 2>/dev/null || true
+}
+
+trap cleanup EXIT
+
+# Run main function
+main

testdata/fuzz/FuzzUnmarshal/0c08b924aa26af23d16b77029b4f5567a96af93402e0472fef7b837b37580d7c

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0=0000-01-01 00:00:00")

testdata/fuzz/FuzzUnmarshal/249a017d8ffa0d88d41c594ada5399f764833f64050180cb39f106d12666853f

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("\"\\n\"=\"\"")

testdata/fuzz/FuzzUnmarshal/391ce67b866d58464d067c5981e99951fd499896453a2fe2779a6bfe7df11bf5

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("''=0")

testdata/fuzz/FuzzUnmarshal/49ae83283c5cfbed874bcacbfb342de107b69c2a3d3c35c2d99f67345fe89946

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0=0000-01-01")

testdata/fuzz/FuzzUnmarshal/69ea82e85bb4ad966ae86bb05eea3af69ed1a826c846f1bf2282f329b4d8fb36

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0=\"\"\"\\U00000000\"\"\"")

testdata/fuzz/FuzzUnmarshal/746910fac6deb42e7e62dce60b333c81c39d844a122c9075894c023400e8fdbf

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0=[[{}]]")

testdata/fuzz/FuzzUnmarshal/844d1171a3adc95e51627f0e9378bbaa193fe2d0284f4ba8ed19a5226a8cbc74

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("\"\\b\"=\"\"")

testdata/fuzz/FuzzUnmarshal/900c54b5071113ae2a5365b3156377ddd775b9d38add61629544903cb9c94b00

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0=inf")

testdata/fuzz/FuzzUnmarshal/c87e8eb4e8fa40fd3c89d8ed16a049ce81592ded710965ee29a4e506eb5427b3

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0=0000-01-01 00:00:00+00:00")

testdata/fuzz/FuzzUnmarshal/d0e5d6fc3b865cfae5480c01f301b87c932722ae0c1d692deea413349ea028be

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0=[{}]")

testdata/fuzz/FuzzUnmarshal/d2cecea5b8ee5f148419671cef0644178cdba1ee91d3f295be38da576e89ef40

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0=nan")

toml.abnf

@@ -59,6 +59,7 @@ val = string / boolean / array / inline-table / date-time / float / integer
 ;; String
 
 string = ml-basic-string / basic-string / ml-literal-string / literal-string
+
 ;; Basic String
 
 basic-string = quotation-mark *basic-char quotation-mark

toml_testgen_support_test.go

@@ -1,15 +1,16 @@
-// This is a support file for toml_testgen_test.go
+//go:generate go run github.com/toml-lang/toml-test/cmd/toml-test@v1.6.0 -copy ./tests
+//go:generate go run ./cmd/tomltestgen/main.go -r v1.6.0 -o toml_testgen_test.go
+
 package toml_test
 
 import (
 	"encoding/json"
-	"fmt"
+	"errors"
-	"strconv"
 	"testing"
-	"time"
 
 	"github.com/pelletier/go-toml/v2"
-	"github.com/stretchr/testify/require"
+	"github.com/pelletier/go-toml/v2/internal/assert"
+	"github.com/pelletier/go-toml/v2/internal/testsuite"
 )
 
 func testgenInvalid(t *testing.T, input string) {
@@ -17,10 +18,14 @@ func testgenInvalid(t *testing.T, input string) {
 	t.Logf("Input TOML:\n%s", input)
 
 	doc := map[string]interface{}{}
-	err := toml.Unmarshal([]byte(input), &doc)
+	err := testsuite.Unmarshal([]byte(input), &doc)
 
 	if err == nil {
-		t.Log(json.Marshal(doc))
+		out, err := json.Marshal(doc)
+		if err != nil {
+			panic("could not marshal map to json")
+		}
+		t.Log("JSON output from unmarshal:", string(out))
 		t.Fatalf("test did not fail")
 	}
 }
@@ -29,110 +34,27 @@ func testgenValid(t *testing.T, input string, jsonRef string) {
 	t.Helper()
 	t.Logf("Input TOML:\n%s", input)
 
-	doc := map[string]interface{}{}
+	// TODO: change this to interface{}
-	err := toml.Unmarshal([]byte(input), &doc)
+	var doc map[string]interface{}
+
+	err := testsuite.Unmarshal([]byte(input), &doc)
 	if err != nil {
+		de := &toml.DecodeError{}
+		if errors.As(err, &de) {
+			t.Logf("%s\n%s", err, de)
+		}
 		t.Fatalf("failed parsing toml: %s", err)
 	}
+	j, err := testsuite.ValueToTaggedJSON(doc)
+	assert.NoError(t, err)
 
-	refDoc := testgenBuildRefDoc(jsonRef)
+	var ref interface{}
+	err = json.Unmarshal([]byte(jsonRef), &ref)
+	assert.NoError(t, err)
 
-	require.Equal(t, refDoc, doc)
+	var actual interface{}
+	err = json.Unmarshal(j, &actual)
+	assert.NoError(t, err)
 
-	out, err := toml.Marshal(doc)
+	testsuite.CmpJSON(t, "", ref, actual)
-	require.NoError(t, err)
-
-	doc2 := map[string]interface{}{}
-	err = toml.Unmarshal(out, &doc2)
-	require.NoError(t, err)
-
-	require.Equal(t, refDoc, doc2)
-}
-
-type testGenDescNode struct {
-	Type  string
-	Value interface{}
-}
-
-func testgenBuildRefDoc(jsonRef string) map[string]interface{} {
-	descTree := map[string]interface{}{}
-	err := json.Unmarshal([]byte(jsonRef), &descTree)
-	if err != nil {
-		panic(fmt.Errorf("reference doc should be valid JSON: %s", err))
-	}
-
-	doc := testGenTranslateDesc(descTree)
-	if doc == nil {
-		return map[string]interface{}{}
-	}
-	return doc.(map[string]interface{})
-}
-
-func testGenTranslateDesc(input interface{}) interface{} {
-	a, ok := input.([]interface{})
-	if ok {
-		xs := make([]interface{}, len(a))
-		for i, v := range a {
-			xs[i] = testGenTranslateDesc(v)
-		}
-		return xs
-	}
-
-	d := input.(map[string]interface{})
-
-	var dtype string
-	var dvalue interface{}
-
-	if len(d) == 2 {
-		dtypeiface, ok := d["type"]
-		if ok {
-			dvalue, ok = d["value"]
-			if ok {
-				dtype = dtypeiface.(string)
-				switch dtype {
-				case "string":
-					return dvalue.(string)
-				case "float":
-					v, err := strconv.ParseFloat(dvalue.(string), 64)
-					if err != nil {
-						panic(fmt.Errorf("invalid float '%s': %s", dvalue, err))
-					}
-					return v
-				case "integer":
-					v, err := strconv.ParseInt(dvalue.(string), 10, 64)
-					if err != nil {
-						panic(fmt.Errorf("invalid int '%s': %s", dvalue, err))
-					}
-					return v
-				case "bool":
-					return dvalue.(string) == "true"
-				case "datetime":
-					dt, err := time.Parse("2006-01-02T15:04:05Z", dvalue.(string))
-					if err != nil {
-						panic(fmt.Errorf("invalid datetime '%s': %s", dvalue, err))
-					}
-					return dt
-				case "array":
-					if dvalue == nil {
-						return nil
-					}
-					a := dvalue.([]interface{})
-					xs := make([]interface{}, len(a))
-
-					for i, v := range a {
-						xs[i] = testGenTranslateDesc(v)
-					}
-
-					return xs
-				}
-				panic(fmt.Errorf("unknown type: %s", dtype))
-			}
-		}
-	}
-
-	dest := map[string]interface{}{}
-	for k, v := range d {
-		dest[k] = testGenTranslateDesc(v)
-	}
-	return dest
 }

types.go

@@ -0,0 +1,23 @@
+package toml
+
+import (
+	"encoding"
+	"reflect"
+	"time"
+)
+
+// isZeroer is used to check if a type has a custom IsZero method.
+// This allows custom types to define their own zero-value semantics.
+type isZeroer interface {
+	IsZero() bool
+}
+
+var (
+	timeType               = reflect.TypeOf((*time.Time)(nil)).Elem()
+	textMarshalerType      = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
+	textUnmarshalerType    = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
+	isZeroerType           = reflect.TypeOf((*isZeroer)(nil)).Elem()
+	mapStringInterfaceType = reflect.TypeOf(map[string]interface{}(nil))
+	sliceInterfaceType     = reflect.TypeOf([]interface{}(nil))
+	stringType             = reflect.TypeOf("")
+)

unstable/ast.go

@@ -0,0 +1,149 @@
+package unstable
+
+import (
+	"errors"
+	"fmt"
+)
+
+// Iterator over a sequence of nodes.
+//
+// Starts uninitialized, you need to call Next() first.
+//
+// For example:
+//
+//	it := n.Children()
+//	for it.Next() {
+//		n := it.Node()
+//		// do something with n
+//	}
+type Iterator struct {
+	nodes   *[]Node
+	idx     int32
+	started bool
+}
+
+// Next moves the iterator forward and returns true if points to a
+// node, false otherwise.
+func (c *Iterator) Next() bool {
+	if c.nodes == nil {
+		return false
+	}
+	nodes := *c.nodes
+	if !c.started {
+		c.started = true
+	} else {
+		idx := c.idx
+		if idx >= 0 && int(idx) < len(nodes) {
+			c.idx = nodes[idx].next
+		}
+	}
+	return c.idx >= 0 && int(c.idx) < len(nodes)
+}
+
+// IsLast returns true if the current node of the iterator is the last
+// one.  Subsequent calls to Next() will return false.
+func (c *Iterator) IsLast() bool {
+	return c.nodes == nil || c.idx < 0 || (*c.nodes)[c.idx].next < 0
+}
+
+// Node returns a pointer to the node pointed at by the iterator.
+func (c *Iterator) Node() *Node {
+	if c.nodes == nil || c.idx < 0 {
+		return nil
+	}
+	n := &(*c.nodes)[c.idx]
+	n.nodes = c.nodes
+	return n
+}
+
+// Node in a TOML expression AST.
+//
+// Depending on Kind, its sequence of children should be interpreted
+// differently.
+//
+//   - Array have one child per element in the array.
+//   - InlineTable have one child per key-value in the table (each of kind
+//     InlineTable).
+//   - KeyValue have at least two children. The first one is the value. The rest
+//     make a potentially dotted key.
+//   - Table and ArrayTable's children represent a dotted key (same as
+//     KeyValue, but without the first node being the value).
+//
+// When relevant, Raw describes the range of bytes this node is referring to in
+// the input document. Use Parser.Raw() to retrieve the actual bytes.
+type Node struct {
+	Kind Kind
+	Raw  Range  // Raw bytes from the input.
+	Data []byte // Node value (either allocated or referencing the input).
+
+	// Absolute indices into the backing nodes slice. -1 means none.
+	next  int32
+	child int32
+
+	// Reference to the backing nodes slice for navigation.
+	nodes *[]Node
+}
+
+// Range of bytes in the document.
+type Range struct {
+	Offset uint32
+	Length uint32
+}
+
+// Next returns a pointer to the next node, or nil if there is no next node.
+func (n *Node) Next() *Node {
+	if n.next < 0 {
+		return nil
+	}
+	next := &(*n.nodes)[n.next]
+	next.nodes = n.nodes
+	return next
+}
+
+// Child returns a pointer to the first child node of this node. Other children
+// can be accessed calling Next on the first child.  Returns nil if this Node
+// has no child.
+func (n *Node) Child() *Node {
+	if n.child < 0 {
+		return nil
+	}
+	child := &(*n.nodes)[n.child]
+	child.nodes = n.nodes
+	return child
+}
+
+// Valid returns true if the node's kind is set (not to Invalid).
+func (n *Node) Valid() bool {
+	return n != nil
+}
+
+// Key returns the children nodes making the Key on a supported node. Panics
+// otherwise.  They are guaranteed to be all be of the Kind Key. A simple key
+// would return just one element.
+func (n *Node) Key() Iterator {
+	switch n.Kind {
+	case KeyValue:
+		child := n.child
+		if child < 0 {
+			panic(errors.New("KeyValue should have at least two children"))
+		}
+		valueNode := &(*n.nodes)[child]
+		return Iterator{nodes: n.nodes, idx: valueNode.next}
+	case Table, ArrayTable:
+		return Iterator{nodes: n.nodes, idx: n.child}
+	default:
+		panic(fmt.Errorf("Key() is not supported on a %s", n.Kind))
+	}
+}
+
+// Value returns a pointer to the value node of a KeyValue.
+// Guaranteed to be non-nil.  Panics if not called on a KeyValue node,
+// or if the Children are malformed.
+func (n *Node) Value() *Node {
+	return n.Child()
+}
+
+// Children returns an iterator over a node's children.
+func (n *Node) Children() Iterator {
+	return Iterator{nodes: n.nodes, idx: n.child}
+}

unstable/benchmark_test.go

@@ -0,0 +1,73 @@
+package unstable
+
+import (
+	"bytes"
+	"testing"
+)
+
+var (
+	valid10ASCII = []byte("1234567890")
+	valid10Utf8  = []byte("日本語a")
+	valid1kUtf8  = bytes.Repeat([]byte("0123456789日本語日本語日本語日abcdefghijklmnopqrstuvwx"), 16)
+	valid1MUtf8  = bytes.Repeat(valid1kUtf8, 1024)
+	valid1kASCII = bytes.Repeat([]byte("012345678998jhjklasDJKLAAdjdfjsdklfjdslkabcdefghijklmnopqrstuvwx"), 16)
+	valid1MASCII = bytes.Repeat(valid1kASCII, 1024)
+)
+
+func BenchmarkScanComments(b *testing.B) {
+	wrap := func(x []byte) []byte {
+		return []byte("# " + string(x) + "\n")
+	}
+
+	inputs := map[string][]byte{
+		"10Valid":     wrap(valid10ASCII),
+		"1kValid":     wrap(valid1kASCII),
+		"1MValid":     wrap(valid1MASCII),
+		"10ValidUtf8": wrap(valid10Utf8),
+		"1kValidUtf8": wrap(valid1kUtf8),
+		"1MValidUtf8": wrap(valid1MUtf8),
+	}
+
+	for name, input := range inputs {
+		b.Run(name, func(b *testing.B) {
+			b.SetBytes(int64(len(input)))
+			b.ReportAllocs()
+			b.ResetTimer()
+
+			for i := 0; i < b.N; i++ {
+				_, _, _ = scanComment(input)
+			}
+		})
+	}
+}
+
+func BenchmarkParseLiteralStringValid(b *testing.B) {
+	wrap := func(x []byte) []byte {
+		return []byte("'" + string(x) + "'")
+	}
+
+	inputs := map[string][]byte{
+		"10Valid":     wrap(valid10ASCII),
+		"1kValid":     wrap(valid1kASCII),
+		"1MValid":     wrap(valid1MASCII),
+		"10ValidUtf8": wrap(valid10Utf8),
+		"1kValidUtf8": wrap(valid1kUtf8),
+		"1MValidUtf8": wrap(valid1MUtf8),
+	}
+
+	for name, input := range inputs {
+		b.Run(name, func(b *testing.B) {
+			p := Parser{}
+			b.SetBytes(int64(len(input)))
+			b.ReportAllocs()
+			b.ResetTimer()
+
+			for i := 0; i < b.N; i++ {
+				_, _, _, err := p.parseLiteralString(input)
+				if err != nil {
+					b.Error(err)
+				}
+			}
+		})
+	}
+}

unstable/builder.go

@@ -0,0 +1,64 @@
+package unstable
+
+// root contains a full AST.
+//
+// It is immutable once constructed with Builder.
+type root struct {
+	nodes []Node
+}
+
+func (r *root) at(idx reference) *Node {
+	return &r.nodes[idx]
+}
+
+type reference int
+
+const invalidReference reference = -1
+
+func (r reference) Valid() bool {
+	return r != invalidReference
+}
+
+type builder struct {
+	tree    root
+	lastIdx int
+}
+
+func (b *builder) NodeAt(ref reference) *Node {
+	n := b.tree.at(ref)
+	n.nodes = &b.tree.nodes
+	return n
+}
+
+func (b *builder) Reset() {
+	b.tree.nodes = b.tree.nodes[:0]
+	b.lastIdx = 0
+}
+
+func (b *builder) Push(n Node) reference {
+	b.lastIdx = len(b.tree.nodes)
+	n.next = -1
+	n.child = -1
+	b.tree.nodes = append(b.tree.nodes, n)
+	return reference(b.lastIdx)
+}
+
+func (b *builder) PushAndChain(n Node) reference {
+	newIdx := len(b.tree.nodes)
+	n.next = -1
+	n.child = -1
+	b.tree.nodes = append(b.tree.nodes, n)
+	if b.lastIdx >= 0 {
+		b.tree.nodes[b.lastIdx].next = int32(newIdx) //nolint:gosec // TOML ASTs are small
+	}
+	b.lastIdx = newIdx
+	return reference(b.lastIdx)
+}
+
+func (b *builder) AttachChild(parent reference, child reference) {
+	b.tree.nodes[parent].child = int32(child) //nolint:gosec // TOML ASTs are small
+}
+
+func (b *builder) Chain(from reference, to reference) {
+	b.tree.nodes[from].next = int32(to) //nolint:gosec // TOML ASTs are small
+}

unstable/doc.go

@@ -0,0 +1,3 @@
+// Package unstable provides APIs that do not meet the backward compatibility
+// guarantees yet.
+package unstable

unstable/kind.go

@@ -0,0 +1,83 @@
+package unstable
+
+import "fmt"
+
+// Kind represents the type of TOML structure contained in a given Node.
+type Kind int
+
+const (
+	// Invalid represents an invalid meta node.
+	Invalid Kind = iota
+	// Comment represents a comment meta node.
+	Comment
+	// Key represents a key meta node.
+	Key
+
+	// Table represents a top-level table.
+	Table
+	// ArrayTable represents a top-level array table.
+	ArrayTable
+	// KeyValue represents a top-level key value.
+	KeyValue
+
+	// Array represents an array container value.
+	Array
+	// InlineTable represents an inline table container value.
+	InlineTable
+
+	// String represents a string value.
+	String
+	// Bool represents a boolean value.
+	Bool
+	// Float represents a floating point value.
+	Float
+	// Integer represents an integer value.
+	Integer
+	// LocalDate represents a a local date value.
+	LocalDate
+	// LocalTime represents a local time value.
+	LocalTime
+	// LocalDateTime represents a local date/time value.
+	LocalDateTime
+	// DateTime represents a data/time value.
+	DateTime
+)
+
+// String implementation of fmt.Stringer.
+func (k Kind) String() string {
+	switch k {
+	case Invalid:
+		return "Invalid"
+	case Comment:
+		return "Comment"
+	case Key:
+		return "Key"
+	case Table:
+		return "Table"
+	case ArrayTable:
+		return "ArrayTable"
+	case KeyValue:
+		return "KeyValue"
+	case Array:
+		return "Array"
+	case InlineTable:
+		return "InlineTable"
+	case String:
+		return "String"
+	case Bool:
+		return "Bool"
+	case Float:
+		return "Float"
+	case Integer:
+		return "Integer"
+	case LocalDate:
+		return "LocalDate"
+	case LocalTime:
+		return "LocalTime"
+	case LocalDateTime:
+		return "LocalDateTime"
+	case DateTime:
+		return "DateTime"
+	}
+	panic(fmt.Errorf("Kind.String() not implemented for '%d'", k))
+}