Rename branch v2-wip -> v2

Marshal results into JSON and ensure all runners match

.dockerignore

@@ -0,0 +1,2 @@
+cmd/tomll/tomll
+cmd/tomljson/tomljson

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,22 @@
+---
+name: Bug report
+about: Create a report to help us improve
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior. Including TOML files.
+
+**Expected behavior**
+A clear and concise description of what you expected to happen, if other than "should work".
+
+**Versions**
+ - go-toml: version (git sha)
+ - go: version
+ - operating system: e.g. macOS, Windows, Linux
+
+**Additional context**
+Add any other context about the problem here that you think may help to diagnose.

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,5 @@
+**Issue:** add link to pelletier/go-toml issue here
+
+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).

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "gomod"
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "daily"

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,67 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ master, v2 ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '26 19 * * 0'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'go' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # 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).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

.github/workflows/workflow.yml

@@ -0,0 +1,28 @@
+name: test
+on:
+  push:
+    branches:
+      - v2
+  pull_request:
+    branches:
+      - v2
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ 'ubuntu-latest', 'windows-latest', 'macos-latest']
+        go: [ '1.15', '1.16' ]
+    runs-on: ${{ matrix.os }}
+    name: ${{ matrix.go }}/${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@master
+      - name: Setup go ${{ matrix.go }}
+        uses: actions/setup-go@master
+        with:
+          go-version: ${{ matrix.go }}
+      - name: Run unit tests
+        run: go test -race ./...
+      - name: Run benchmark tests
+        run: go test -race ./...
+        working-directory: benchmark

.gitignore

@@ -0,0 +1,5 @@
+test_program/test_program_bin
+fuzz/
+cmd/tomll/tomll
+cmd/tomljson/tomljson
+cmd/tomltestgen/tomltestgen

.golangci.toml

@@ -0,0 +1,81 @@
+[service]
+golangci-lint-version =  "1.39.0"
+
+[linters-settings.wsl]
+allow-assign-and-anything = true
+
+[linters]
+disable-all = true
+enable = [
+    "asciicheck",
+    "bodyclose",
+    "cyclop",
+    "deadcode",
+    "depguard",
+    "dogsled",
+    "dupl",
+    "durationcheck",
+    "errcheck",
+    "errorlint",
+    "exhaustive",
+    "exhaustivestruct",
+    "exportloopref",
+    "forbidigo",
+    "forcetypeassert",
+    "funlen",
+    "gci",
+    "gochecknoglobals",
+    "gochecknoinits",
+    "gocognit",
+    "goconst",
+    "gocritic",
+    "gocyclo",
+    "godot",
+    "godox",
+    "goerr113",
+    "gofmt",
+    "gofumpt",
+    "goheader",
+    "goimports",
+    "golint",
+    "gomnd",
+    # "gomoddirectives",
+    "gomodguard",
+    "goprintffuncname",
+    "gosec",
+    "gosimple",
+    "govet",
+    "ifshort",
+    "importas",
+    "ineffassign",
+    "lll",
+    "makezero",
+    "misspell",
+    "nakedret",
+    "nestif",
+    "nilerr",
+    "nlreturn",
+    "noctx",
+    "nolintlint",
+    "paralleltest",
+    "prealloc",
+    "predeclared",
+    "revive",
+    "rowserrcheck",
+    "sqlclosecheck",
+    "staticcheck",
+    "structcheck",
+    "stylecheck",
+    # "testpackage",
+    "thelper",
+    "tparallel",
+    "typecheck",
+    "unconvert",
+    "unparam",
+    "unused",
+    "varcheck",
+    "wastedassign",
+    "whitespace",
+    "wrapcheck",
+    "wsl"
+]

.travis.yml

@@ -1 +0,0 @@
-language: go

CONTRIBUTING.md

@@ -0,0 +1,132 @@
+## 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
+implementation for Go that gets the job done and gets out of your way –
+dealing 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
+small, is more than welcomed!
+
+### Ask questions
+
+Any question you may have, somebody else might have it too. Always feel
+free to ask them on the [issues tracker][issues-tracker].  We will try to
+answer them as 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
+ask away!
+
+### Improve the documentation
+
+The best way to share your knowledge and experience with go-toml is to
+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
+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.
+
+### Report a bug
+
+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
+  text with no code. Code speaks louder than words.
+* No backward-incompatible patch will be accepted unless discussed.
+  Sometimes it's hard, and Go's lack of versioning by default does not
+  help, 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
+  to write some documentation.
+* Bug fixes need to be accompanied with regression tests.
+* New code needs to be tested.
+* Your commit messages need to explain why the change is needed, even if
+  already included in the PR description.
+
+It does sound like a lot, but those best practices are here to save time
+overall and continuously improve the quality of the project, which is
+something everyone benefits from.
+
+#### Get started
+
+The fairly standard code contribution process looks like that:
+
+1. [Fork the project][fork].
+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!
+
+Feel free to ask for help! You can create draft pull requests to gather
+some early feedback!
+
+#### Run the tests
+
+You can run tests for go-toml using Go's test tool: `go test ./...`.
+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
+
+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
+
+#### Merge pull request
+
+Checklist:
+
+* Passing CI.
+* Does not introduce backward-incompatible changes (unless discussed).
+* Has relevant doc changes.
+* Has relevant unit tests.
+
+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
+
+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
+[pkg.go.dev]: https://pkg.go.dev/github.com/pelletier/go-toml
+[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

LICENSE

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

README.md

@@ -1,80 +1,58 @@
-# go-toml
+# go-toml V2
 
-Go library for the [TOML](https://github.com/mojombo/toml) format.
+Development branch. Use at your own risk.
 
-This library supports TOML version
+[👉 Discussion on github](https://github.com/pelletier/go-toml/discussions/471).
-[v0.1.0](https://github.com/mojombo/toml/blob/master/versions/toml-v0.1.0.md)
 
-[![Build Status](https://travis-ci.org/pelletier/go-toml.png?branch=master)](https://travis-ci.org/pelletier/go-toml)
+* `toml.Unmarshal()` should work as well as v1.
 
-## Import
+## Must do
 
-    import "github.com/pelletier/go-toml"
+### Unmarshal
 
-## Usage
+- [x] Unmarshal into maps.
+- [x] Support Array Tables.
+- [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
 
-Say you have a TOML file that looks like this:
+### Marshal
 
-```toml
+- [x] Minimal implementation
-[postgres]
+- [x] Multiline strings
-user = "pelletier"
+- [ ] Multiline arrays
-password = "mypassword"
+- [ ] `inline` tag for tables
-```
+- [ ] Optional indentation
+- [ ] Option to pick default quotes
 
-Read the username and password like this:
+### Document
 
-```go
+- [ ] Gather requirements and design API.
-import (
-    "fmt"
-    "github.com/pelletier/go-toml"
-)
 
-config, err := toml.LoadFile("config.toml")
+## Ideas
-if err != nil {
-    fmt.Println("Error ", err.Error())
-} else {
-    // retrieve data directly
-    user := config.Get("postgres.user").(string)
-    password := config.Get("postgres.password").(string)
 
-    // or using an intermediate object
+- [ ] Allow types to implement a `ASTUnmarshaler` interface to unmarshal
-    configTree := config.Get("postgres").(*toml.TomlTree)
+      straight from the AST?
-    user = configTree.Get("user").(string)
+- [x] Rewrite AST to use a single array as storage instead of one allocation per
-    password = configTree.Get("password").(string)
+      node.
-    fmt.Println("User is ", user, ". Password is ", password)
+- [ ] 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.
 
-## Documentation
+## Differences with v1
-
-The documentation is available at
-[godoc.org](http://godoc.org/github.com/pelletier/go-toml).
-
-## Contribute
-
-Feel free to report bugs and patches using GitHub's pull requests system on
-[pelletier/go-toml](https://github.com/pelletier/go-toml). Any feedback would be
-much appreciated!
 
+* [unmarshal](https://github.com/pelletier/go-toml/discussions/488)
 
 ## License
 
-Copyright (c) 2013 Thomas Pelletier
+The MIT License (MIT). Read [LICENSE](LICENSE).
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

benchmark/bench_datasets_test.go

@@ -0,0 +1,94 @@
+package benchmark_test
+
+import (
+	"compress/gzip"
+	"encoding/json"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+var bench_inputs = []struct {
+	name    string
+	jsonLen int
+}{
+	// from https://gist.githubusercontent.com/feeeper/2197d6d734729625a037af1df14cf2aa/raw/2f22b120e476d897179be3c1e2483d18067aa7df/config.toml
+	{"config", 806507},
+
+	// converted from https://github.com/miloyip/nativejson-benchmark
+	{"canada", 2090234},
+	{"citm_catalog", 479897},
+	{"twitter", 428778},
+	{"code", 1940472},
+
+	// converted from https://raw.githubusercontent.com/mailru/easyjson/master/benchmark/example.json
+	{"example", 7779},
+}
+
+func TestUnmarshalDatasetCode(t *testing.T) {
+	for _, tc := range bench_inputs {
+		buf := fixture(t, tc.name)
+		t.Run(tc.name, func(t *testing.T) {
+			for _, r := range runners {
+				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{}
+					check(t, r.unmarshal(buf, &v))
+
+					b, err := json.Marshal(v)
+					check(t, err)
+					require.Equal(t, len(b), tc.jsonLen)
+				})
+			}
+		})
+	}
+}
+
+func BenchmarkUnmarshalDataset(b *testing.B) {
+	for _, tc := range bench_inputs {
+		buf := fixture(b, tc.name)
+		b.Run(tc.name, func(b *testing.B) {
+			bench(b, func(r runner, b *testing.B) {
+				if r.name == "bs" && tc.name == "canada" {
+					b.Skip("skipping: burntsushi can't handle mixed arrays")
+				}
+
+				b.SetBytes(int64(len(buf)))
+				b.ReportAllocs()
+				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"))
+	check(tb, err)
+	defer f.Close()
+
+	gz, err := gzip.NewReader(f)
+	check(tb, err)
+
+	buf, err := ioutil.ReadAll(gz)
+	check(tb, err)
+
+	return buf
+}
+
+func check(tb testing.TB, err error) {
+	if err != nil {
+		tb.Helper()
+		tb.Fatal(err)
+	}
+}

benchmark/benchmark.toml

@@ -0,0 +1,244 @@
+################################################################################
+## Comment
+
+# Speak your mind with the hash symbol. They go from the symbol to the end of
+# the line.
+
+
+################################################################################
+## Table
+
+# Tables (also known as hash tables or dictionaries) are collections of
+# key/value pairs. They appear in square brackets on a line by themselves.
+
+[table]
+
+key = "value" # Yeah, you can do this.
+
+# Nested tables are denoted by table names with dots in them. Name your tables
+# whatever crap you please, just don't use #, ., [ or ].
+
+[table.subtable]
+
+key = "another value"
+
+# You don't need to specify all the super-tables if you don't want to. TOML
+# knows how to do it for you.
+
+# [x] you
+# [x.y] don't
+# [x.y.z] need these
+[x.y.z.w] # for this to work
+
+
+################################################################################
+## Inline Table
+
+# Inline tables provide a more compact syntax for expressing tables. They are
+# especially useful for grouped data that can otherwise quickly become verbose.
+# Inline tables are enclosed in curly braces `{` and `}`. No newlines are
+# allowed between the curly braces unless they are valid within a value.
+
+[table.inline]
+
+name = { first = "Tom", last = "Preston-Werner" }
+point = { x = 1, y = 2 }
+
+
+################################################################################
+## String
+
+# There are four ways to express strings: basic, multi-line basic, literal, and
+# multi-line literal. All strings must contain only valid UTF-8 characters.
+
+[string.basic]
+
+basic = "I'm a string. \"You can quote me\". Name\tJos\u00E9\nLocation\tSF."
+
+[string.multiline]
+
+# The following strings are byte-for-byte equivalent:
+key1 = "One\nTwo"
+key2 = """One\nTwo"""
+key3 = """
+One
+Two"""
+
+[string.multiline.continued]
+
+# The following strings are byte-for-byte equivalent:
+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.\
+       """
+
+[string.literal]
+
+# What you see is what you get.
+winpath  = 'C:\Users\nodejs\templates'
+winpath2 = '\\ServerX\admin$\system32\'
+quoted   = 'Tom "Dubs" Preston-Werner'
+regex    = '<\i\c*\s*>'
+
+
+[string.literal.multiline]
+
+regex2 = '''I [dw]on't need \d{2} apples'''
+lines  = '''
+The first newline is
+trimmed in raw strings.
+   All other whitespace
+   is preserved.
+'''
+
+
+################################################################################
+## Integer
+
+# Integers are whole numbers. Positive numbers may be prefixed with a plus sign.
+# Negative numbers are prefixed with a minus sign.
+
+[integer]
+
+key1 = +99
+key2 = 42
+key3 = 0
+key4 = -17
+
+[integer.underscores]
+
+# For large numbers, you may use underscores to enhance readability. Each
+# underscore must be surrounded by at least one digit.
+key1 = 1_000
+key2 = 5_349_221
+key3 = 1_2_3_4_5     # valid but inadvisable
+
+
+################################################################################
+## Float
+
+# A float consists of an integer part (which may be prefixed with a plus or
+# minus sign) followed by a fractional part and/or an exponent part.
+
+[float.fractional]
+
+key1 = +1.0
+key2 = 3.1415
+key3 = -0.01
+
+[float.exponent]
+
+key1 = 5e+22
+key2 = 1e6
+key3 = -2E-2
+
+[float.both]
+
+key = 6.626e-34
+
+[float.underscores]
+
+key1 = 9_224_617.445_991_228_313
+key2 = 1e1_00
+
+
+################################################################################
+## Boolean
+
+# Booleans are just the tokens you're used to. Always lowercase.
+
+[boolean]
+
+True = true
+False = false
+
+
+################################################################################
+## Datetime
+
+# Datetimes are RFC 3339 dates.
+
+[datetime]
+
+key1 = 1979-05-27T07:32:00Z
+key2 = 1979-05-27T00:32:00-07:00
+key3 = 1979-05-27T00:32:00.999999-07:00
+
+
+################################################################################
+## Array
+
+# Arrays are square brackets with other primitives inside. Whitespace is
+# ignored. Elements are separated by commas. Data types may not be mixed.
+
+[array]
+
+key1 = [ 1, 2, 3 ]
+key2 = [ "red", "yellow", "green" ]
+key3 = [ [ 1, 2 ], [3, 4, 5] ]
+#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
+# the closing bracket.
+
+key5 = [
+  1, 2, 3
+]
+key6 = [
+  1,
+  2, # this is ok
+]
+
+
+################################################################################
+## Array of Tables
+
+# These can be expressed by using a table name in double brackets. Each table
+# with the same double bracketed name will be an element in the array. The
+# tables are inserted in the order encountered.
+
+[[products]]
+
+name = "Hammer"
+sku = 738594937
+
+[[products]]
+
+[[products]]
+
+name = "Nail"
+sku = 284758393
+color = "gray"
+
+
+# You can create nested arrays of tables as well.
+
+[[fruit]]
+  name = "apple"
+
+  [fruit.physical]
+    color = "red"
+    shape = "round"
+
+  [[fruit.variety]]
+    name = "red delicious"
+
+  [[fruit.variety]]
+    name = "granny smith"
+
+[[fruit]]
+  name = "banana"
+
+  [[fruit.variety]]
+    name = "plantain"

benchmark/benchmark_test.go

@@ -0,0 +1,179 @@
+package benchmark_test
+
+import (
+	"io/ioutil"
+	"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"
+)
+
+type runner struct {
+	name      string
+	unmarshal func([]byte, interface{}) error
+}
+
+var runners = []runner{
+	{"v2", toml.Unmarshal},
+	{"v1", tomlv1.Unmarshal},
+	{"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) {
+	bench(b, func(r runner, b *testing.B) {
+		d := struct {
+			A string
+		}{}
+		doc := []byte(`A = "hello"`)
+		for i := 0; i < b.N; i++ {
+			err := r.unmarshal(doc, &d)
+			if err != nil {
+				panic(err)
+			}
+		}
+	})
+}
+
+type benchmarkDoc struct {
+	Table struct {
+		Key      string
+		Subtable struct {
+			Key string
+		}
+		Inline struct {
+			Name struct {
+				First string
+				Last  string
+			}
+			Point struct {
+				X int64
+				U int64
+			}
+		}
+	}
+	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
+			}
+		}
+	}
+	Integer struct {
+		Key1        int64
+		Key2        int64
+		Key3        int64
+		Key4        int64
+		Underscores struct {
+			Key1 int64
+			Key2 int64
+			Key3 int64
+		}
+	}
+	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
+		}
+	}
+	Boolean struct {
+		True  bool
+		False bool
+	}
+	Datetime struct {
+		Key1 time.Time
+		Key2 time.Time
+		Key3 time.Time
+	}
+	Array struct {
+		Key1 []int64
+		Key2 []string
+		Key3 [][]int64
+		// TODO: Key4 not supported by go-toml's Unmarshal
+		Key5 []int64
+		Key6 []int64
+	}
+	Products []struct {
+		Name  string
+		Sku   int64
+		Color string
+	}
+	Fruit []struct {
+		Name     string
+		Physical struct {
+			Color   string
+			Shape   string
+			Variety []struct {
+				Name string
+			}
+		}
+	}
+}
+
+func BenchmarkReferenceFile(b *testing.B) {
+	bench(b, func(r runner, b *testing.B) {
+		bytes, err := ioutil.ReadFile("benchmark.toml")
+		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)
+}

benchmark/go.mod

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,16 @@
+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=

decode.go

@@ -0,0 +1,381 @@
+package toml
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func parseInteger(b []byte) (int64, error) {
+	if len(b) > 2 && b[0] == '0' {
+		switch b[1] {
+		case 'x':
+			return parseIntHex(b)
+		case 'b':
+			return parseIntBin(b)
+		case 'o':
+			return parseIntOct(b)
+		default:
+			return 0, newDecodeError(b[1:2], "invalid base: '%c'", b[1])
+		}
+	}
+
+	return parseIntDec(b)
+}
+
+func parseLocalDate(b []byte) (LocalDate, error) {
+	// full-date      = date-fullyear "-" date-month "-" date-mday
+	// date-fullyear  = 4DIGIT
+	// date-month     = 2DIGIT  ; 01-12
+	// date-mday      = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31 based on month/year
+	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")
+	}
+
+	var err error
+
+	date.Year, err = parseDecimalDigits(b[0:4])
+	if err != nil {
+		return date, err
+	}
+
+	v, err := parseDecimalDigits(b[5:7])
+	if err != nil {
+		return date, err
+	}
+
+	date.Month = time.Month(v)
+
+	date.Day, err = parseDecimalDigits(b[8:10])
+	if err != nil {
+		return date, err
+	}
+
+	return date, nil
+}
+
+var errNotDigit = errors.New("not a digit")
+
+func parseDecimalDigits(b []byte) (int, error) {
+	v := 0
+
+	for _, c := range b {
+		if !isDigit(c) {
+			return 0, fmt.Errorf("%s: %w", b, errNotDigit)
+		}
+
+		v *= 10
+		v += int(c - '0')
+	}
+
+	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
+	}
+
+	var zone *time.Location
+
+	if len(b) == 0 {
+		return time.Time{}, errParseDateTimeMissingInfo
+	}
+
+	if 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")
+		}
+		direction := 1
+		switch b[0] {
+		case '+':
+		case '-':
+			direction = -1
+		default:
+			return time.Time{}, newDecodeError(b[0:1], "invalid timezone offset character")
+		}
+
+		hours := digitsToInt(b[1:3])
+		minutes := digitsToInt(b[4:6])
+		seconds := direction * (hours*3600 + minutes*60)
+		zone = time.FixedZone("", seconds)
+	}
+
+	if len(b) > 0 {
+		return time.Time{}, newDecodeError(b, "extra bytes at the end of the timezone")
+	}
+
+	t := time.Date(
+		dt.Date.Year,
+		dt.Date.Month,
+		dt.Date.Day,
+		dt.Time.Hour,
+		dt.Time.Minute,
+		dt.Time.Second,
+		dt.Time.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
+	if len(b) < localDateTimeByteLen {
+		return dt, nil, errParseLocalDateTimeWrongLength
+	}
+
+	date, err := parseLocalDate(b[:10])
+	if err != nil {
+		return dt, nil, err
+	}
+	dt.Date = date
+
+	sep := b[10]
+	if sep != 'T' && sep != ' ' {
+		return dt, nil, errParseLocalDateTimeWrongSeparator
+	}
+
+	t, rest, err := parseLocalTime(b[11:])
+	if err != nil {
+		return dt, nil, err
+	}
+	dt.Time = 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
+
+	const localTimeByteLen = 8
+	if len(b) < localTimeByteLen {
+		return t, nil, errParseLocalTimeWrongLength
+	}
+
+	var err error
+
+	t.Hour, err = parseDecimalDigits(b[0:2])
+	if err != nil {
+		return t, nil, err
+	}
+
+	if b[2] != ':' {
+		return t, nil, newDecodeError(b[2:3], "expecting colon between hours and minutes")
+	}
+
+	t.Minute, err = parseDecimalDigits(b[3:5])
+	if err != nil {
+		return t, nil, err
+	}
+
+	if b[5] != ':' {
+		return t, nil, newDecodeError(b[5:6], "expecting colon between minutes and seconds")
+	}
+
+	t.Second, err = parseDecimalDigits(b[6:8])
+	if err != nil {
+		return t, nil, err
+	}
+
+	if len(b) >= 15 && b[8] == '.' {
+		t.Nanosecond, err = parseDecimalDigits(b[9:15])
+		if err != nil {
+			return t, nil, err
+		}
+
+		return t, b[15:], nil
+	}
+
+	return t, b[8:], 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)
+
+	err := numberContainsInvalidUnderscore(tok)
+	if err != nil {
+		return 0, err
+	}
+
+	cleanedVal := cleanupNumberToken(tok)
+	if cleanedVal[0] == '.' {
+		return 0, errParseFloatStartDot
+	}
+
+	if cleanedVal[len(cleanedVal)-1] == '.' {
+		return 0, errParseFloatEndDot
+	}
+
+	f, err := strconv.ParseFloat(cleanedVal, 64)
+	if err != nil {
+		return 0, fmt.Errorf("coudn't ParseFloat %w", err)
+	}
+
+	return f, nil
+}
+
+func parseIntHex(b []byte) (int64, error) {
+	tok := string(b)
+	cleanedVal := cleanupNumberToken(tok)
+
+	err := hexNumberContainsInvalidUnderscore(cleanedVal)
+	if err != nil {
+		return 0, err
+	}
+
+	i, err := strconv.ParseInt(cleanedVal[2:], 16, 64)
+	if err != nil {
+		return 0, fmt.Errorf("coudn't ParseIntHex %w", err)
+	}
+
+	return i, nil
+}
+
+func parseIntOct(b []byte) (int64, error) {
+	tok := string(b)
+	cleanedVal := cleanupNumberToken(tok)
+
+	err := numberContainsInvalidUnderscore(cleanedVal)
+	if err != nil {
+		return 0, err
+	}
+
+	i, err := strconv.ParseInt(cleanedVal[2:], 8, 64)
+	if err != nil {
+		return 0, fmt.Errorf("coudn't ParseIntOct %w", err)
+	}
+
+	return i, nil
+}
+
+func parseIntBin(b []byte) (int64, error) {
+	tok := string(b)
+	cleanedVal := cleanupNumberToken(tok)
+
+	err := numberContainsInvalidUnderscore(cleanedVal)
+	if err != nil {
+		return 0, err
+	}
+
+	i, err := strconv.ParseInt(cleanedVal[2:], 2, 64)
+	if err != nil {
+		return 0, fmt.Errorf("coudn't ParseIntBin %w", err)
+	}
+
+	return i, nil
+}
+
+func parseIntDec(b []byte) (int64, error) {
+	tok := string(b)
+	cleanedVal := cleanupNumberToken(tok)
+
+	err := numberContainsInvalidUnderscore(cleanedVal)
+	if err != nil {
+		return 0, err
+	}
+
+	i, err := strconv.ParseInt(cleanedVal, 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("coudn't parseIntDec %w", err)
+	}
+
+	return i, nil
+}
+
+func numberContainsInvalidUnderscore(value string) error {
+	// For large numbers, you may use underscores between digits to enhance
+	// readability. Each underscore must be surrounded by at least one digit on
+	// each side.
+	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
+}
+
+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
+}
+
+func cleanupNumberToken(value string) string {
+	cleanedVal := strings.ReplaceAll(value, "_", "")
+
+	return cleanedVal
+}
+
+func isHexDigit(r rune) bool {
+	return isDigitRune(r) ||
+		(r >= 'a' && r <= 'f') ||
+		(r >= 'A' && r <= 'F')
+}
+
+func isDigitRune(r rune) bool {
+	return r >= '0' && r <= '9'
+}
+
+var (
+	errInvalidUnderscore    = errors.New("invalid use of _ in number")
+	errInvalidUnderscoreHex = errors.New("invalid use of _ in hex number")
+)

errors.go

@@ -0,0 +1,223 @@
+package toml
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/pelletier/go-toml/v2/internal/unsafe"
+)
+
+// DecodeError represents an error encountered during the parsing or decoding
+// of a TOML document.
+//
+// In addition to the error message, it contains the position in the document
+// where it happened, as well as a human-readable representation that shows
+// where the error occurred in the document.
+type DecodeError struct {
+	message string
+	line    int
+	column  int
+
+	human string
+}
+
+// internal version of DecodeError that is used as the base to create a
+// DecodeError with full context.
+type decodeError struct {
+	highlight []byte
+	message   string
+}
+
+func (de *decodeError) Error() string {
+	return de.message
+}
+
+func newDecodeError(highlight []byte, format string, args ...interface{}) error {
+	return &decodeError{
+		highlight: highlight,
+		message:   fmt.Sprintf(format, args...),
+	}
+}
+
+// Error returns the error message contained in the DecodeError.
+func (e *DecodeError) Error() string {
+	return e.message
+}
+
+// String returns the human-readable contextualized error. This string is multi-line.
+func (e *DecodeError) String() string {
+	return e.human
+}
+
+// Position returns the (line, column) pair indicating where the error
+// occurred in the document. Positions are 1-indexed.
+func (e *DecodeError) Position() (row int, column int) {
+	return e.line, e.column
+}
+
+// decodeErrorFromHighlight creates a DecodeError referencing to 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 {
+	if de == nil {
+		return nil
+	}
+
+	offset := unsafe.SubsliceOffset(document, de.highlight)
+
+	errMessage := de.message
+	errLine, errColumn := positionAtEnd(document[:offset])
+	before, after := linesOfContext(document, de.highlight, offset, 3)
+
+	var buf strings.Builder
+
+	maxLine := errLine + len(after) - 1
+	lineColumnWidth := len(strconv.Itoa(maxLine))
+
+	for i := len(before) - 1; i > 0; i-- {
+		line := errLine - i
+		buf.WriteString(formatLineNumber(line, lineColumnWidth))
+		buf.WriteString("|")
+
+		if len(before[i]) > 0 {
+			buf.WriteString(" ")
+			buf.Write(before[i])
+		}
+
+		buf.WriteRune('\n')
+	}
+
+	buf.WriteString(formatLineNumber(errLine, lineColumnWidth))
+	buf.WriteString("| ")
+
+	if len(before) > 0 {
+		buf.Write(before[0])
+	}
+
+	buf.Write(de.highlight)
+
+	if len(after) > 0 {
+		buf.Write(after[0])
+	}
+
+	buf.WriteRune('\n')
+	buf.WriteString(strings.Repeat(" ", lineColumnWidth))
+	buf.WriteString("| ")
+
+	if len(before) > 0 {
+		buf.WriteString(strings.Repeat(" ", len(before[0])))
+	}
+
+	buf.WriteString(strings.Repeat("~", len(de.highlight)))
+
+	if len(errMessage) > 0 {
+		buf.WriteString(" ")
+		buf.WriteString(errMessage)
+	}
+
+	for i := 1; i < len(after); i++ {
+		buf.WriteRune('\n')
+		line := errLine + i
+		buf.WriteString(formatLineNumber(line, lineColumnWidth))
+		buf.WriteString("|")
+
+		if len(after[i]) > 0 {
+			buf.WriteString(" ")
+			buf.Write(after[i])
+		}
+	}
+
+	return &DecodeError{
+		message: errMessage,
+		line:    errLine,
+		column:  errColumn,
+		human:   buf.String(),
+	}
+}
+
+func formatLineNumber(line int, width int) string {
+	format := "%" + strconv.Itoa(width) + "d"
+
+	return fmt.Sprintf(format, line)
+}
+
+func linesOfContext(document []byte, highlight []byte, offset int, linesAround int) ([][]byte, [][]byte) {
+	return beforeLines(document, offset, linesAround), afterLines(document, highlight, offset, linesAround)
+}
+
+func beforeLines(document []byte, offset int, linesAround int) [][]byte {
+	var beforeLines [][]byte
+
+	// Walk the document backward from the highlight to find previous lines
+	// of context.
+	rest := document[:offset]
+backward:
+	for o := len(rest) - 1; o >= 0 && len(beforeLines) <= linesAround && len(rest) > 0; {
+		switch {
+		case rest[o] == '\n':
+			// handle individual lines
+			beforeLines = append(beforeLines, rest[o+1:])
+			rest = rest[:o]
+			o = len(rest) - 1
+		case o == 0:
+			// add the first line only if it's non-empty
+			beforeLines = append(beforeLines, rest)
+
+			break backward
+		default:
+			o--
+		}
+	}
+
+	return beforeLines
+}
+
+func afterLines(document []byte, highlight []byte, offset int, linesAround int) [][]byte {
+	var afterLines [][]byte
+
+	// Walk the document forward from the highlight to find the following
+	// lines of context.
+	rest := document[offset+len(highlight):]
+forward:
+	for o := 0; o < len(rest) && len(afterLines) <= linesAround; {
+		switch {
+		case rest[o] == '\n':
+			// handle individual lines
+			afterLines = append(afterLines, rest[:o])
+			rest = rest[o+1:]
+			o = 0
+
+		case o == len(rest)-1 && o > 0:
+			// add last line only if it's non-empty
+			afterLines = append(afterLines, rest)
+
+			break forward
+		default:
+			o++
+		}
+	}
+
+	return afterLines
+}
+
+func positionAtEnd(b []byte) (row int, column int) {
+	row = 1
+	column = 1
+
+	for _, c := range b {
+		if c == '\n' {
+			row++
+			column = 1
+		} else {
+			column++
+		}
+	}
+
+	return
+}

errors_test.go

@@ -0,0 +1,181 @@
+package toml
+
+import (
+	"bytes"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+//nolint:funlen
+func TestDecodeError(t *testing.T) {
+	t.Parallel()
+
+	examples := []struct {
+		desc     string
+		doc      [3]string
+		msg      string
+		expected string
+	}{
+		{
+			desc: "no context",
+			doc:  [3]string{"", "morning", ""},
+			msg:  "this is wrong",
+			expected: `
+1| morning
+ | ~~~~~~~ this is wrong`,
+		},
+		{
+			desc: "one line",
+			doc:  [3]string{"good ", "morning", " everyone"},
+			msg:  "this is wrong",
+			expected: `
+1| good morning everyone
+ |      ~~~~~~~ this is wrong`,
+		},
+		{
+			desc: "exactly 3 lines",
+			doc: [3]string{`line1
+line2
+line3
+before `, "highlighted", ` after
+post line 1
+post line 2
+post line 3`},
+			msg: "this is wrong",
+			expected: `
+1| line1
+2| line2
+3| line3
+4| before highlighted after
+ |        ~~~~~~~~~~~ this is wrong
+5| post line 1
+6| post line 2
+7| post line 3`,
+		},
+		{
+			desc: "more than 3 lines",
+			doc: [3]string{`should not be seen1
+should not be seen2
+line1
+line2
+line3
+before `, "highlighted", ` after
+post line 1
+post line 2
+post line 3
+should not be seen3
+should not be seen4`},
+			msg: "this is wrong",
+			expected: `
+3| line1
+4| line2
+5| line3
+6| before highlighted after
+ |        ~~~~~~~~~~~ this is wrong
+7| post line 1
+8| post line 2
+9| post line 3`,
+		},
+		{
+			desc: "more than 10 total lines",
+			doc: [3]string{`should not be seen 0
+should not be seen1
+should not be seen2
+should not be seen3
+line1
+line2
+line3
+before `, "highlighted", ` after
+post line 1
+post line 2
+post line 3
+should not be seen3
+should not be seen4`},
+			msg: "this is wrong",
+			expected: `
+ 5| line1
+ 6| line2
+ 7| line3
+ 8| before highlighted after
+  |        ~~~~~~~~~~~ this is wrong
+ 9| post line 1
+10| post line 2
+11| post line 3`,
+		},
+		{
+			desc: "last line of more than 10",
+			doc: [3]string{`should not be seen
+should not be seen
+should not be seen
+should not be seen
+should not be seen
+should not be seen
+should not be seen
+line1
+line2
+line3
+before `, "highlighted", ``},
+			msg: "this is wrong",
+			expected: `
+ 8| line1
+ 9| line2
+10| line3
+11| before highlighted
+  |        ~~~~~~~~~~~ this is wrong
+`,
+		},
+		{
+			desc: "handle empty lines in the before/after blocks",
+			doc: [3]string{
+				`line1
+
+line 2
+before `, "highlighted", ` after
+line 3
+
+line 4
+line 5`,
+			},
+			expected: `1| line1
+2|
+3| line 2
+4| before highlighted after
+ |        ~~~~~~~~~~~
+5| line 3
+6|
+7| line 4`,
+		},
+	}
+
+	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]))
+			start := b.Len()
+			b.Write([]byte(e.doc[1]))
+			end := b.Len()
+			b.Write([]byte(e.doc[2]))
+			doc := b.Bytes()
+			hl := doc[start:end]
+
+			err := wrapDecodeError(doc, &decodeError{
+				highlight: hl,
+				message:   e.msg,
+			})
+
+			var derr *DecodeError
+			if !errors.As(err, &derr) {
+				t.Errorf("error not in expected format")
+
+				return
+			}
+
+			assert.Equal(t, strings.Trim(e.expected, "\n"), derr.String())
+		})
+	}
+}

example.toml

@@ -1,29 +0,0 @@
-# This is a TOML document. Boom.
-
-title = "TOML Example"
-
-[owner]
-name = "Tom Preston-Werner"
-organization = "GitHub"
-bio = "GitHub Cofounder & CEO\nLikes tater tots and beer."
-dob = 1979-05-27T07:32:00Z # First class dates? Why not?
-
-[database]
-server = "192.168.1.1"
-ports = [ 8001, 8001, 8002 ]
-connection_max = 5000
-enabled = true
-
-[servers]
-
-  # You can indent as you please. Tabs or spaces. TOML don't care.
-  [servers.alpha]
-  ip = "10.0.0.1"
-  dc = "eqdc10"
-
-  [servers.beta]
-  ip = "10.0.0.2"
-  dc = "eqdc10"
-
-[clients]
-data = [ ["gamma", "delta"], [1, 2] ] # just an update to make sure parsers support it

go.mod

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

go.sum

@@ -0,0 +1,11 @@
+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/ast/ast.go

@@ -0,0 +1,138 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,69 @@
+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/imported_tests/marshal_imported_test.go

@@ -0,0 +1,166 @@
+package imported_tests
+
+// Those tests have been imported from v1, but adjust to match the new
+// defaults of v2.
+
+import (
+	"testing"
+	"time"
+
+	"github.com/pelletier/go-toml/v2"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDocMarshal(t *testing.T) {
+	type testDoc struct {
+		Title       string            `toml:"title"`
+		BasicLists  testDocBasicLists `toml:"basic_lists"`
+		SubDocPtrs  []*testSubDoc     `toml:"subdocptrs"`
+		BasicMap    map[string]string `toml:"basic_map"`
+		Subdocs     testDocSubs       `toml:"subdoc"`
+		Basics      testDocBasics     `toml:"basic"`
+		SubDocList  []testSubDoc      `toml:"subdoclist"`
+		err         int               `toml:"shouldntBeHere"`
+		unexported  int               `toml:"shouldntBeHere"`
+		Unexported2 int               `toml:"-"`
+	}
+
+	var docData = testDoc{
+		Title:       "TOML Marshal Testing",
+		unexported:  0,
+		Unexported2: 0,
+		Basics: testDocBasics{
+			Bool:       true,
+			Date:       time.Date(1979, 5, 27, 7, 32, 0, 0, time.UTC),
+			Float32:    123.4,
+			Float64:    123.456782132399,
+			Int:        5000,
+			Uint:       5001,
+			String:     &biteMe,
+			unexported: 0,
+		},
+		BasicLists: testDocBasicLists{
+			Floats: []*float32{&float1, &float2, &float3},
+			Bools:  []bool{true, false, true},
+			Dates: []time.Time{
+				time.Date(1979, 5, 27, 7, 32, 0, 0, time.UTC),
+				time.Date(1980, 5, 27, 7, 32, 0, 0, time.UTC),
+			},
+			Ints:    []int{8001, 8001, 8002},
+			Strings: []string{"One", "Two", "Three"},
+			UInts:   []uint{5002, 5003},
+		},
+		BasicMap: map[string]string{
+			"one": "one",
+			"two": "two",
+		},
+		Subdocs: testDocSubs{
+			First:  testSubDoc{"First", 0},
+			Second: &subdoc,
+		},
+		SubDocList: []testSubDoc{
+			{"List.First", 0},
+			{"List.Second", 0},
+		},
+		SubDocPtrs: []*testSubDoc{&subdoc},
+	}
+
+	marshalTestToml := `title = 'TOML Marshal Testing'
+[basic_lists]
+floats = [12.3, 45.6, 78.9]
+bools = [true, false, true]
+dates = [1979-05-27T07:32:00Z, 1980-05-27T07:32:00Z]
+ints = [8001, 8001, 8002]
+uints = [5002, 5003]
+strings = ['One', 'Two', 'Three']
+
+[[subdocptrs]]
+name = 'Second'
+
+[basic_map]
+one = 'one'
+two = 'two'
+
+[subdoc]
+[subdoc.second]
+name = 'Second'
+
+[subdoc.first]
+name = 'First'
+
+
+[basic]
+uint = 5001
+bool = true
+float = 123.4
+float64 = 123.456782132399
+int = 5000
+string = 'Bite me'
+date = 1979-05-27T07:32:00Z
+
+[[subdoclist]]
+name = 'List.First'
+[[subdoclist]]
+name = 'List.Second'
+
+`
+
+	result, err := toml.Marshal(docData)
+	require.NoError(t, err)
+	require.Equal(t, marshalTestToml, string(result))
+}
+
+func TestBasicMarshalQuotedKey(t *testing.T) {
+	result, err := toml.Marshal(quotedKeyMarshalTestData)
+	require.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))
+
+}
+
+func TestEmptyMarshal(t *testing.T) {
+	type emptyMarshalTestStruct struct {
+		Title      string                  `toml:"title"`
+		Bool       bool                    `toml:"bool"`
+		Int        int                     `toml:"int"`
+		String     string                  `toml:"string"`
+		StringList []string                `toml:"stringlist"`
+		Ptr        *basicMarshalTestStruct `toml:"ptr"`
+		Map        map[string]string       `toml:"map"`
+	}
+
+	doc := emptyMarshalTestStruct{
+		Title:      "Placeholder",
+		Bool:       false,
+		Int:        0,
+		String:     "",
+		StringList: []string{},
+		Ptr:        nil,
+		Map:        map[string]string{},
+	}
+	result, err := toml.Marshal(doc)
+	require.NoError(t, err)
+
+	expected := `title = 'Placeholder'
+bool = false
+int = 0
+string = ''
+stringlist = []
+[map]
+
+`
+
+	require.Equal(t, string(expected), string(result))
+}

internal/tracker/tracker.go

@@ -0,0 +1,200 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,79 @@
+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)
+			})
+		})
+	}
+}

lexer.go

@@ -1,436 +0,0 @@
-// TOML lexer.// Written using the principles developped by Rob Pike in
-// http://www.youtube.com/watch?v=HxaD_trXwRE
-
-package toml
-
-import (
-	"fmt"
-	"regexp"
-	"strconv"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-)
-
-var dateRegexp *regexp.Regexp
-
-// Define tokens
-type tokenType int
-
-const (
-	eof = -(iota + 1)
-)
-
-const (
-	tokenError tokenType = iota
-	tokenEOF
-	tokenComment
-	tokenKey
-	tokenEqual
-	tokenString
-	tokenInteger
-	tokenTrue
-	tokenFalse
-	tokenFloat
-	tokenLeftBracket
-	tokenRightBracket
-	tokenDate
-	tokenKeyGroup
-	tokenComma
-	tokenEOL
-)
-
-type token struct {
-	typ tokenType
-	val string
-}
-
-func (i token) String() string {
-	switch i.typ {
-	case tokenEOF:
-		return "EOF"
-	case tokenError:
-		return i.val
-	}
-
-	if len(i.val) > 10 {
-		return fmt.Sprintf("%.10q...", i.val)
-	}
-	return fmt.Sprintf("%q", i.val)
-}
-
-func isSpace(r rune) bool {
-	return r == ' ' || r == '\t'
-}
-
-func isAlphanumeric(r rune) bool {
-	return unicode.IsLetter(r) || r == '_'
-}
-
-func isDigit(r rune) bool {
-	return unicode.IsNumber(r)
-}
-
-func isHexDigit(r rune) bool {
-	return isDigit(r) ||
-		r == 'A' || r == 'B' || r == 'C' || r == 'D' || r == 'E' || r == 'F'
-}
-
-// Define lexer
-type lexer struct {
-	input  string
-	start  int
-	pos    int
-	width  int
-	tokens chan token
-	depth  int
-}
-
-func (l *lexer) run() {
-	for state := lexVoid; state != nil; {
-		state = state(l)
-	}
-	close(l.tokens)
-}
-
-func (l *lexer) emit(t tokenType) {
-	l.tokens <- token{t, l.input[l.start:l.pos]}
-	l.start = l.pos
-}
-
-func (l *lexer) emitWithValue(t tokenType, value string) {
-	l.tokens <- token{t, value}
-	l.start = l.pos
-}
-
-func (l *lexer) next() rune {
-	if l.pos >= len(l.input) {
-		l.width = 0
-		return eof
-	}
-	var r rune
-	r, l.width = utf8.DecodeRuneInString(l.input[l.pos:])
-	l.pos += l.width
-	return r
-}
-
-func (l *lexer) ignore() {
-	l.start = l.pos
-}
-
-func (l *lexer) backup() {
-	l.pos -= l.width
-}
-
-func (l *lexer) errorf(format string, args ...interface{}) stateFn {
-	l.tokens <- token{
-		tokenError,
-		fmt.Sprintf(format, args...),
-	}
-	return nil
-}
-
-func (l *lexer) peek() rune {
-	r := l.next()
-	l.backup()
-	return r
-}
-
-func (l *lexer) accept(valid string) bool {
-	if strings.IndexRune(valid, l.next()) >= 0 {
-		return true
-	}
-	l.backup()
-	return false
-}
-
-func (l *lexer) follow(next string) bool {
-	return strings.HasPrefix(l.input[l.pos:], next)
-}
-
-// Define state functions
-type stateFn func(*lexer) stateFn
-
-func lexVoid(l *lexer) stateFn {
-	for {
-		next := l.peek()
-		switch next {
-		case '[':
-			return lexKeyGroup
-		case '#':
-			return lexComment
-		case '=':
-			return lexEqual
-		}
-
-		if isAlphanumeric(next) {
-			return lexKey
-		}
-
-		if isSpace(next) {
-			l.ignore()
-		}
-
-		if l.next() == eof {
-			break
-		}
-	}
-
-	l.emit(tokenEOF)
-	return nil
-}
-
-func lexRvalue(l *lexer) stateFn {
-	for {
-		next := l.peek()
-		switch next {
-		case '[':
-			l.depth += 1
-			return lexLeftBracket
-		case ']':
-			l.depth -= 1
-			return lexRightBracket
-		case '#':
-			return lexComment
-		case '"':
-			return lexString
-		case ',':
-			return lexComma
-		case '\n':
-			l.ignore()
-			l.pos += 1
-			if l.depth == 0 {
-				return lexVoid
-			} else {
-				return lexRvalue
-			}
-		}
-
-		if l.follow("true") {
-			return lexTrue
-		}
-
-		if l.follow("false") {
-			return lexFalse
-		}
-
-		if isAlphanumeric(next) {
-			return lexKey
-		}
-
-		if dateRegexp.FindString(l.input[l.pos:]) != "" {
-			return lexDate
-		}
-
-		if next == '+' || next == '-' || isDigit(next) {
-			return lexNumber
-		}
-
-		if isSpace(next) {
-			l.ignore()
-		}
-
-		if l.next() == eof {
-			break
-		}
-	}
-
-	l.emit(tokenEOF)
-	return nil
-}
-
-func lexDate(l *lexer) stateFn {
-	l.ignore()
-	l.pos += 20 // Fixed size of a date in TOML
-	l.emit(tokenDate)
-	return lexRvalue
-}
-
-func lexTrue(l *lexer) stateFn {
-	l.ignore()
-	l.pos += 4
-	l.emit(tokenTrue)
-	return lexRvalue
-}
-
-func lexFalse(l *lexer) stateFn {
-	l.ignore()
-	l.pos += 5
-	l.emit(tokenFalse)
-	return lexRvalue
-}
-
-func lexEqual(l *lexer) stateFn {
-	l.ignore()
-	l.accept("=")
-	l.emit(tokenEqual)
-	return lexRvalue
-}
-
-func lexComma(l *lexer) stateFn {
-	l.ignore()
-	l.accept(",")
-	l.emit(tokenComma)
-	return lexRvalue
-}
-
-func lexKey(l *lexer) stateFn {
-	l.ignore()
-	for isAlphanumeric(l.next()) {
-	}
-	l.backup()
-	l.emit(tokenKey)
-	return lexVoid
-}
-
-func lexComment(l *lexer) stateFn {
-	for {
-		next := l.next()
-		if next == '\n' || next == eof {
-			break
-		}
-	}
-	l.ignore()
-	return lexVoid
-}
-
-func lexLeftBracket(l *lexer) stateFn {
-	l.ignore()
-	l.pos += 1
-	l.emit(tokenLeftBracket)
-	return lexRvalue
-}
-
-func lexString(l *lexer) stateFn {
-	l.pos += 1
-	l.ignore()
-	growing_string := ""
-
-	for {
-		if l.peek() == '"' {
-			l.emitWithValue(tokenString, growing_string)
-			l.pos += 1
-			l.ignore()
-			return lexRvalue
-		}
-
-		if l.follow("\\\"") {
-			l.pos += 1
-			growing_string += "\""
-		} else if l.follow("\\n") {
-			l.pos += 1
-			growing_string += "\n"
-		} else if l.follow("\\t") {
-			l.pos += 1
-			growing_string += "\t"
-		} else if l.follow("\\r") {
-			l.pos += 1
-			growing_string += "\r"
-		} else if l.follow("\\\\") {
-			l.pos += 1
-			growing_string += "\\"
-		} else if l.follow("\\u") {
-			l.pos += 2
-			code := ""
-			for i := 0; i < 4; i++ {
-				c := l.peek()
-				l.pos += 1
-				if !isHexDigit(c) {
-					return l.errorf("unfinished unicode escape")
-				}
-				code = code + string(c)
-			}
-			l.pos -= 1
-			intcode, err := strconv.ParseInt(code, 16, 32)
-			if err != nil {
-				return l.errorf("invalid unicode escape: \\u" + code)
-			}
-			growing_string += string(rune(intcode))
-		} else {
-			growing_string += string(l.peek())
-		}
-
-		if l.next() == eof {
-			break
-		}
-	}
-
-	return l.errorf("unclosed string")
-}
-
-func lexKeyGroup(l *lexer) stateFn {
-	l.ignore()
-	l.pos += 1
-	l.emit(tokenLeftBracket)
-	return lexInsideKeyGroup
-}
-
-func lexInsideKeyGroup(l *lexer) stateFn {
-	for {
-		if l.peek() == ']' {
-			if l.pos > l.start {
-				l.emit(tokenKeyGroup)
-			}
-			l.ignore()
-			l.pos += 1
-			l.emit(tokenRightBracket)
-			return lexVoid
-		}
-
-		if l.next() == eof {
-			break
-		}
-	}
-	return l.errorf("unclosed key group")
-}
-
-func lexRightBracket(l *lexer) stateFn {
-	l.ignore()
-	l.pos += 1
-	l.emit(tokenRightBracket)
-	return lexRvalue
-}
-
-func lexNumber(l *lexer) stateFn {
-	l.ignore()
-	if !l.accept("+") {
-		l.accept("-")
-	}
-	point_seen := false
-	digit_seen := false
-	for {
-		next := l.next()
-		if next == '.' {
-			point_seen = true
-		} else if isDigit(next) {
-			digit_seen = true
-		} else {
-			l.backup()
-			break
-		}
-	}
-
-	if !digit_seen {
-		return l.errorf("no digit in that number")
-	}
-	if point_seen {
-		l.emit(tokenFloat)
-	} else {
-		l.emit(tokenInteger)
-	}
-	return lexRvalue
-}
-
-func init() {
-	dateRegexp = regexp.MustCompile("^\\d{1,4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z")
-}
-
-// Entry point
-func lex(input string) (*lexer, chan token) {
-	l := &lexer{
-		input:  input,
-		tokens: make(chan token),
-	}
-	go l.run()
-	return l, l.tokens
-}

lexer_test.go

@@ -1,320 +0,0 @@
-package toml
-
-import "testing"
-
-func testFlow(t *testing.T, input string, expectedFlow []token) {
-	_, ch := lex(input)
-	for _, expected := range expectedFlow {
-		token := <-ch
-		if token != expected {
-			t.Log("compared", token, "to", expected)
-			t.Log(token.val, "<->", expected.val)
-			t.Log(token.typ, "<->", expected.typ)
-			t.FailNow()
-		}
-	}
-
-	tok, ok := <-ch
-	if ok {
-		t.Log("channel is not closed!")
-		t.Log(len(ch)+1, "tokens remaining:")
-
-		t.Log("token ->", tok)
-		for token := range ch {
-			t.Log("token ->", token)
-		}
-		t.FailNow()
-	}
-}
-
-func TestValidKeyGroup(t *testing.T) {
-	testFlow(t, "[hello world]", []token{
-		token{tokenLeftBracket, "["},
-		token{tokenKeyGroup, "hello world"},
-		token{tokenRightBracket, "]"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestUnclosedKeyGroup(t *testing.T) {
-	testFlow(t, "[hello world", []token{
-		token{tokenLeftBracket, "["},
-		token{tokenError, "unclosed key group"},
-	})
-}
-
-func TestComment(t *testing.T) {
-	testFlow(t, "# blahblah", []token{
-		token{tokenEOF, ""},
-	})
-}
-
-func TestKeyGroupComment(t *testing.T) {
-	testFlow(t, "[hello world] # blahblah", []token{
-		token{tokenLeftBracket, "["},
-		token{tokenKeyGroup, "hello world"},
-		token{tokenRightBracket, "]"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestMultipleKeyGroupsComment(t *testing.T) {
-	testFlow(t, "[hello world] # blahblah\n[test]", []token{
-		token{tokenLeftBracket, "["},
-		token{tokenKeyGroup, "hello world"},
-		token{tokenRightBracket, "]"},
-		token{tokenLeftBracket, "["},
-		token{tokenKeyGroup, "test"},
-		token{tokenRightBracket, "]"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestBasicKey(t *testing.T) {
-	testFlow(t, "hello", []token{
-		token{tokenKey, "hello"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestBasicKeyWithUnderscore(t *testing.T) {
-	testFlow(t, "hello_hello", []token{
-		token{tokenKey, "hello_hello"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestBasicKeyWithUppercaseMix(t *testing.T) {
-	testFlow(t, "helloHELLOHello", []token{
-		token{tokenKey, "helloHELLOHello"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestBasicKeyWithInternationalCharacters(t *testing.T) {
-	testFlow(t, "héllÖ", []token{
-		token{tokenKey, "héllÖ"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestBasicKeyAndEqual(t *testing.T) {
-	testFlow(t, "hello =", []token{
-		token{tokenKey, "hello"},
-		token{tokenEqual, "="},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestKeyEqualStringEscape(t *testing.T) {
-	testFlow(t, "foo = \"hello\\\"\"", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenString, "hello\""},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestKeyEqualStringUnfinished(t *testing.T) {
-	testFlow(t, "foo = \"bar", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenError, "unclosed string"},
-	})
-}
-
-func TestKeyEqualString(t *testing.T) {
-	testFlow(t, "foo = \"bar\"", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenString, "bar"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestKeyEqualTrue(t *testing.T) {
-	testFlow(t, "foo = true", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenTrue, "true"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestKeyEqualFalse(t *testing.T) {
-	testFlow(t, "foo = false", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenFalse, "false"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestArrayNestedString(t *testing.T) {
-	testFlow(t, "a = [ [\"hello\", \"world\"] ]", []token{
-		token{tokenKey, "a"},
-		token{tokenEqual, "="},
-		token{tokenLeftBracket, "["},
-		token{tokenLeftBracket, "["},
-		token{tokenString, "hello"},
-		token{tokenComma, ","},
-		token{tokenString, "world"},
-		token{tokenRightBracket, "]"},
-		token{tokenRightBracket, "]"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestArrayNestedInts(t *testing.T) {
-	testFlow(t, "a = [ [42, 21], [10] ]", []token{
-		token{tokenKey, "a"},
-		token{tokenEqual, "="},
-		token{tokenLeftBracket, "["},
-		token{tokenLeftBracket, "["},
-		token{tokenInteger, "42"},
-		token{tokenComma, ","},
-		token{tokenInteger, "21"},
-		token{tokenRightBracket, "]"},
-		token{tokenComma, ","},
-		token{tokenLeftBracket, "["},
-		token{tokenInteger, "10"},
-		token{tokenRightBracket, "]"},
-		token{tokenRightBracket, "]"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestArrayInts(t *testing.T) {
-	testFlow(t, "a = [ 42, 21, 10, ]", []token{
-		token{tokenKey, "a"},
-		token{tokenEqual, "="},
-		token{tokenLeftBracket, "["},
-		token{tokenInteger, "42"},
-		token{tokenComma, ","},
-		token{tokenInteger, "21"},
-		token{tokenComma, ","},
-		token{tokenInteger, "10"},
-		token{tokenComma, ","},
-		token{tokenRightBracket, "]"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestKeyEqualArrayBools(t *testing.T) {
-	testFlow(t, "foo = [true, false, true]", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenLeftBracket, "["},
-		token{tokenTrue, "true"},
-		token{tokenComma, ","},
-		token{tokenFalse, "false"},
-		token{tokenComma, ","},
-		token{tokenTrue, "true"},
-		token{tokenRightBracket, "]"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestKeyEqualArrayBoolsWithComments(t *testing.T) {
-	testFlow(t, "foo = [true, false, true] # YEAH", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenLeftBracket, "["},
-		token{tokenTrue, "true"},
-		token{tokenComma, ","},
-		token{tokenFalse, "false"},
-		token{tokenComma, ","},
-		token{tokenTrue, "true"},
-		token{tokenRightBracket, "]"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestDateRegexp(t *testing.T) {
-	if dateRegexp.FindString("1979-05-27T07:32:00Z") == "" {
-		t.Fail()
-	}
-}
-
-func TestKeyEqualDate(t *testing.T) {
-	testFlow(t, "foo = 1979-05-27T07:32:00Z", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenDate, "1979-05-27T07:32:00Z"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestKeyEqualNumber(t *testing.T) {
-	testFlow(t, "foo = 42", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenInteger, "42"},
-		token{tokenEOF, ""},
-	})
-
-	testFlow(t, "foo = +42", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenInteger, "+42"},
-		token{tokenEOF, ""},
-	})
-
-	testFlow(t, "foo = -42", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenInteger, "-42"},
-		token{tokenEOF, ""},
-	})
-
-	testFlow(t, "foo = 4.2", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenFloat, "4.2"},
-		token{tokenEOF, ""},
-	})
-
-	testFlow(t, "foo = +4.2", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenFloat, "+4.2"},
-		token{tokenEOF, ""},
-	})
-
-	testFlow(t, "foo = -4.2", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenFloat, "-4.2"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestMultiline(t *testing.T) {
-	testFlow(t, "foo = 42\nbar=21", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenInteger, "42"},
-		token{tokenKey, "bar"},
-		token{tokenEqual, "="},
-		token{tokenInteger, "21"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestKeyEqualStringUnicodeEscape(t *testing.T) {
-	testFlow(t, "foo = \"hello \\u2665\"", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenString, "hello ♥"},
-		token{tokenEOF, ""},
-	})
-}
-
-func TestUnicodeString(t *testing.T) {
-	testFlow(t, "foo = \"hello ♥ world\"", []token{
-		token{tokenKey, "foo"},
-		token{tokenEqual, "="},
-		token{tokenString, "hello ♥ world"},
-		token{tokenEOF, ""},
-	})
-}

localtime.go

@@ -0,0 +1,281 @@
+// 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"
+	"time"
+)
+
+// A LocalDate represents a date (year, month, day).
+//
+// 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).
+	Month time.Month // Month of the year (January = 1, ...).
+	Day   int        // Day of the month, starting at 1.
+}
+
+// LocalDateOf returns the LocalDate in which a time occurs in that time's location.
+func LocalDateOf(t time.Time) LocalDate {
+	var d LocalDate
+	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.
+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.
+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.
+// The date is expected to be a string in a format accepted by ParseLocalDate.
+func (d *LocalDate) UnmarshalText(data []byte) error {
+	var err error
+	*d, err = ParseLocalDate(string(data))
+	return err
+}
+
+// A LocalTime represents a time with nanosecond precision.
+//
+// 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]
+	Minute     int // The minute of the hour; range [0-59]
+	Second     int // The second of the minute; range [0-59]
+	Nanosecond int // The nanosecond of the second; range [0-999999999]
+}
+
+// LocalTimeOf returns the LocalTime representing the time of day in which a time occurs
+// in that time's location. It ignores the date.
+func LocalTimeOf(t time.Time) LocalTime {
+	var tm LocalTime
+	tm.Hour, tm.Minute, tm.Second = t.Clock()
+	tm.Nanosecond = t.Nanosecond()
+	return tm
+}
+
+// ParseLocalTime parses a string and returns the time value it represents.
+// ParseLocalTime accepts an extended form of the RFC3339 partial-time format. After
+// the HH:MM:SS part of the string, an optional fractional part may appear,
+// 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) {
+	t, err := time.Parse("15:04:05.999999999", s)
+	if err != nil {
+		return LocalTime{}, err
+	}
+	return LocalTimeOf(t), nil
+}
+
+// String returns the date in the format described in ParseLocalTime. If Nanoseconds
+// 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
+	Time LocalTime
+}
+
+// Note: We deliberately do not embed LocalDate into LocalDateTime, to avoid promoting AddDays and Sub.
+
+// LocalDateTimeOf returns the LocalDateTime in which a time occurs in that time's location.
+func LocalDateTimeOf(t time.Time) LocalDateTime {
+	return LocalDateTime{
+		Date: LocalDateOf(t),
+		Time: LocalTimeOf(t),
+	}
+}
+
+// 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)
+		if err != nil {
+			return LocalDateTime{}, err
+		}
+	}
+	return LocalDateTimeOf(t), nil
+}
+
+// String returns the date in the format described in ParseLocalDate.
+func (dt LocalDateTime) String() string {
+	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

@@ -0,0 +1,446 @@
+// 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 toml
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func cmpEqual(x, y interface{}) bool {
+	return reflect.DeepEqual(x, y)
+}
+
+func TestDates(t *testing.T) {
+	for _, test := range []struct {
+		date     LocalDate
+		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) {
+	for _, test := range []struct {
+		date LocalDate
+		want bool
+	}{
+		{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) {
+	for _, test := range []struct {
+		str  string
+		want LocalDate // if empty, expect an error
+	}{
+		{"2016-01-02", LocalDate{2016, 1, 2}},
+		{"2016-12-31", LocalDate{2016, 12, 31}},
+		{"0003-02-04", LocalDate{3, 2, 4}},
+		{"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) {
+	for _, test := range []struct {
+		desc  string
+		start LocalDate
+		end   LocalDate
+		days  int
+	}{
+		{
+			desc:  "zero days noop",
+			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) {
+	for _, test := range []struct {
+		d1, d2 LocalDate
+		want   bool
+	}{
+		{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) {
+	for _, test := range []struct {
+		d1, d2 LocalDate
+		want   bool
+	}{
+		{LocalDate{2016, 12, 31}, LocalDate{2017, 1, 1}, false},
+		{LocalDate{2016, 1, 1}, LocalDate{2016, 1, 1}, false},
+		{LocalDate{2016, 12, 30}, LocalDate{2016, 12, 31}, false},
+	} {
+		if got := test.d1.After(test.d2); got != test.want {
+			t.Errorf("%v.After(%v): got %t, want %t", test.d1, test.d2, got, test.want)
+		}
+	}
+}
+
+func TestTimeToString(t *testing.T) {
+	for _, test := range []struct {
+		str       string
+		time      LocalTime
+		roundTrip bool // ParseLocalTime(str).String() == str?
+	}{
+		{"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) {
+	for _, test := range []struct {
+		time time.Time
+		want LocalTime
+	}{
+		{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)
+		}
+	}
+}
+
+func TestTimeIsValid(t *testing.T) {
+	for _, test := range []struct {
+		time LocalTime
+		want bool
+	}{
+		{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)
+		}
+	}
+}
+
+func TestDateTimeToString(t *testing.T) {
+	for _, test := range []struct {
+		str       string
+		dateTime  LocalDateTime
+		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)
+			}
+		}
+	}
+}
+
+func TestParseDateTimeErrors(t *testing.T) {
+	for _, str := range []string{
+		"",
+		"2016-03-22",           // just a date
+		"13:26:33",             // just a time
+		"2016-03-22 13:26:33",  // wrong separating character
+		"2016-03-22T13:26:33x", // extra at end
+	} {
+		if _, err := ParseLocalDateTime(str); err == nil {
+			t.Errorf("ParseLocalDateTime(%q) succeeded, want error", str)
+		}
+	}
+}
+
+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)
+		}
+	}
+}

marshaler.go

@@ -0,0 +1,661 @@
+package toml
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Marshal serializes a Go value as a TOML document.
+//
+// It is a shortcut for Encoder.Encode() with the default options.
+func Marshal(v interface{}) ([]byte, error) {
+	var buf bytes.Buffer
+	enc := NewEncoder(&buf)
+	err := enc.Encode(v)
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+// Encoder writes a TOML document to an output stream.
+type Encoder struct {
+	w io.Writer
+}
+
+type encoderCtx struct {
+	// Current top-level key.
+	parentKey []string
+
+	// Key that should be used for a KV.
+	key string
+	// Extra flag to account for the empty string
+	hasKey bool
+
+	// Set to true to indicate that the encoder is inside a KV, so that all
+	// tables need to be inlined.
+	insideKv bool
+
+	// Set to true to skip the first table header in an array table.
+	skipTableHeader bool
+
+	options valueOptions
+}
+
+type valueOptions struct {
+	multiline bool
+}
+
+func (ctx *encoderCtx) shiftKey() {
+	if ctx.hasKey {
+		ctx.parentKey = append(ctx.parentKey, ctx.key)
+		ctx.clearKey()
+	}
+}
+
+func (ctx *encoderCtx) setKey(k string) {
+	ctx.key = k
+	ctx.hasKey = true
+}
+
+func (ctx *encoderCtx) clearKey() {
+	ctx.key = ""
+	ctx.hasKey = false
+}
+
+// NewEncoder returns a new Encoder that writes to w.
+func NewEncoder(w io.Writer) *Encoder {
+	return &Encoder{
+		w: w,
+	}
+}
+
+// Encode writes a TOML representation of v to the stream.
+//
+// If v cannot be represented to TOML it returns an error.
+//
+// Encoding rules:
+//
+// 1. A top level slice containing only maps or structs is encoded as [[table
+// array]].
+//
+// 2. All slices not matching rule 1 are encoded as [array]. As a result, any
+// map or struct they contain is encoded as an {inline table}.
+//
+// 3. Nil interfaces and nil pointers are not supported.
+//
+// 4. Keys in key-values always have one part.
+//
+// 5. Intermediate tables are always printed.
+//
+// By default, strings are encoded as literal string, unless they contain either
+// a newline character or a single quote. In that case they are emited as quoted
+// strings.
+//
+// When encoding structs, fields are encoded in order of definition, with their
+// exact name. The following struct tags are available:
+//
+//   `toml:"foo"`: changes the name of the key to use for the field to foo.
+//
+//   `multiline:"true"`: when the field contains a string, it will be emitted as
+//   a quoted multi-line TOML string.
+func (enc *Encoder) Encode(v interface{}) error {
+	var b []byte
+	var ctx encoderCtx
+	b, err := enc.encode(b, ctx, reflect.ValueOf(v))
+	if err != nil {
+		return err
+	}
+	_, err = enc.w.Write(b)
+	return err
+}
+
+func (enc *Encoder) encode(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, error) {
+	switch i := v.Interface().(type) {
+	case time.Time: // TODO: add TextMarshaler
+		b = i.AppendFormat(b, time.RFC3339)
+		return b, nil
+	}
+
+	// containers
+	switch v.Kind() {
+	case reflect.Map:
+		return enc.encodeMap(b, ctx, v)
+	case reflect.Struct:
+		return enc.encodeStruct(b, ctx, v)
+	case reflect.Slice:
+		return enc.encodeSlice(b, ctx, v)
+	case reflect.Interface:
+		if v.IsNil() {
+			return nil, errNilInterface
+		}
+		return enc.encode(b, ctx, v.Elem())
+	case reflect.Ptr:
+		if v.IsNil() {
+			return enc.encode(b, ctx, reflect.Zero(v.Type().Elem()))
+		}
+		return enc.encode(b, ctx, v.Elem())
+	}
+
+	// values
+	var err error
+	switch v.Kind() {
+	case reflect.String:
+		b, err = enc.encodeString(b, v.String(), ctx.options)
+	case reflect.Float32:
+		b = strconv.AppendFloat(b, v.Float(), 'f', -1, 32)
+	case reflect.Float64:
+		b = strconv.AppendFloat(b, v.Float(), 'f', -1, 64)
+	case reflect.Bool:
+		if v.Bool() {
+			b = append(b, "true"...)
+		} else {
+			b = append(b, "false"...)
+		}
+	case reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8, reflect.Uint:
+		b = strconv.AppendUint(b, v.Uint(), 10)
+	case reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8, reflect.Int:
+		b = strconv.AppendInt(b, v.Int(), 10)
+	default:
+		err = fmt.Errorf("unsupported encode value kind: %s", v.Kind())
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return b, nil
+}
+
+func isNil(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Ptr, reflect.Interface, reflect.Map:
+		return v.IsNil()
+	default:
+		return false
+	}
+}
+
+func (enc *Encoder) encodeKv(b []byte, ctx encoderCtx, options valueOptions, v reflect.Value) ([]byte, error) {
+	var err error
+
+	if !ctx.hasKey {
+		panic("caller of encodeKv should have set the key in the context")
+	}
+
+	if isNil(v) {
+		return b, nil
+	}
+
+	b, err = enc.encodeKey(b, ctx.key)
+	if err != nil {
+		return nil, err
+	}
+
+	b = append(b, " = "...)
+
+	// create a copy of the context because the value of a KV shouldn't
+	// modify the global context.
+	subctx := ctx
+	subctx.insideKv = true
+	subctx.shiftKey()
+	subctx.options = options
+
+	b, err = enc.encode(b, subctx, v)
+	if err != nil {
+		return nil, err
+	}
+
+	return b, nil
+}
+
+const literalQuote = '\''
+
+func (enc *Encoder) encodeString(b []byte, v string, options valueOptions) ([]byte, error) {
+	if needsQuoting(v) {
+		b = enc.encodeQuotedString(options.multiline, b, v)
+	} else {
+		b = enc.encodeLiteralString(b, v)
+	}
+	return b, nil
+}
+
+func needsQuoting(v string) bool {
+	return strings.ContainsAny(v, "'\b\f\n\r\t")
+}
+
+// caller should have checked that the string does not contain new lines or '
+func (enc *Encoder) encodeLiteralString(b []byte, v string) []byte {
+	b = append(b, literalQuote)
+	b = append(b, v...)
+	b = append(b, literalQuote)
+	return b
+}
+
+func (enc *Encoder) encodeQuotedString(multiline bool, b []byte, v string) []byte {
+	const hextable = "0123456789ABCDEF"
+	stringQuote := `"`
+	if multiline {
+		stringQuote = `"""`
+	}
+
+	b = append(b, stringQuote...)
+	if multiline {
+		b = append(b, '\n')
+	}
+
+	for _, r := range []byte(v) {
+		switch r {
+		case '\\':
+			b = append(b, `\\`...)
+		case '"':
+			b = append(b, `\"`...)
+		case '\b':
+			b = append(b, `\b`...)
+		case '\f':
+			b = append(b, `\f`...)
+		case '\n':
+			if multiline {
+				b = append(b, r)
+			} else {
+				b = append(b, `\n`...)
+			}
+		case '\r':
+			b = append(b, `\r`...)
+		case '\t':
+			b = append(b, `\t`...)
+		default:
+			switch {
+			case r >= 0x0 && r <= 0x8, r >= 0xA && r <= 0x1F, r == 0x7F:
+				b = append(b, `\u00`...)
+				b = append(b, hextable[r>>4])
+				b = append(b, hextable[r&0x0f])
+			default:
+				b = append(b, r)
+			}
+		}
+		// U+0000 to U+0008, U+000A to U+001F, U+007F
+	}
+
+	b = append(b, stringQuote...)
+	return b
+}
+
+// called should have checked that the string is in A-Z / a-z / 0-9 / - / _
+func (enc *Encoder) encodeUnquotedKey(b []byte, v string) []byte {
+	return append(b, v...)
+}
+
+func (enc *Encoder) encodeTableHeader(b []byte, key []string) ([]byte, error) {
+	if len(key) == 0 {
+		return b, nil
+	}
+
+	b = append(b, '[')
+
+	var err error
+	b, err = enc.encodeKey(b, key[0])
+	if err != nil {
+		return nil, err
+	}
+
+	for _, k := range key[1:] {
+		b = append(b, '.')
+		b, err = enc.encodeKey(b, k)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	b = append(b, "]\n"...)
+
+	return b, nil
+}
+
+func (enc *Encoder) encodeKey(b []byte, k string) ([]byte, error) {
+	needsQuotation := false
+	cannotUseLiteral := false
+
+	for _, c := range k {
+		if (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '-' || c == '_' {
+			continue
+		}
+		if c == '\n' {
+			return nil, fmt.Errorf("TOML does not support multiline keys")
+		}
+		if c == literalQuote {
+			cannotUseLiteral = true
+		}
+		needsQuotation = true
+	}
+
+	if cannotUseLiteral {
+		b = enc.encodeQuotedString(false, b, k)
+	} else if needsQuotation {
+		b = enc.encodeLiteralString(b, k)
+	} else {
+		b = enc.encodeUnquotedKey(b, k)
+	}
+
+	return b, nil
+}
+
+func (enc *Encoder) encodeMap(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, error) {
+	if v.Type().Key().Kind() != reflect.String {
+		return nil, fmt.Errorf("type '%s' not supported as map key", v.Type().Key().Kind())
+	}
+
+	t := table{}
+
+	iter := v.MapRange()
+	for iter.Next() {
+		k := iter.Key().String()
+		v := iter.Value()
+
+		if isNil(v) {
+			continue
+		}
+
+		table, err := willConvertToTableOrArrayTable(v)
+		if err != nil {
+			return nil, err
+		}
+
+		if table {
+			t.pushTable(k, v, valueOptions{})
+		} else {
+			t.pushKV(k, v, valueOptions{})
+		}
+	}
+
+	sortEntriesByKey(t.kvs)
+	sortEntriesByKey(t.tables)
+
+	return enc.encodeTable(b, ctx, t)
+}
+
+func sortEntriesByKey(e []entry) {
+	sort.Slice(e, func(i, j int) bool {
+		return e[i].Key < e[j].Key
+	})
+}
+
+type entry struct {
+	Key     string
+	Value   reflect.Value
+	Options valueOptions
+}
+
+type table struct {
+	kvs    []entry
+	tables []entry
+}
+
+func (t *table) pushKV(k string, v reflect.Value, options valueOptions) {
+	t.kvs = append(t.kvs, entry{Key: k, Value: v, Options: options})
+}
+
+func (t *table) pushTable(k string, v reflect.Value, options valueOptions) {
+	t.tables = append(t.tables, entry{Key: k, Value: v, Options: options})
+}
+
+func (t *table) hasKVs() bool {
+	return len(t.kvs) > 0
+}
+
+func (enc *Encoder) encodeStruct(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, error) {
+	t := table{}
+
+	// TODO: cache this?
+	typ := v.Type()
+	for i := 0; i < typ.NumField(); i++ {
+		fieldType := typ.Field(i)
+
+		// only consider exported fields
+		if fieldType.PkgPath != "" {
+			continue
+		}
+
+		k, ok := fieldType.Tag.Lookup("toml")
+		if !ok {
+			k = fieldType.Name
+		}
+
+		// special field name to skip field
+		if k == "-" {
+			continue
+		}
+
+		f := v.Field(i)
+
+		if isNil(f) {
+			continue
+		}
+
+		willConvert, err := willConvertToTableOrArrayTable(f)
+		if err != nil {
+			return nil, err
+		}
+
+		options := valueOptions{}
+
+		ml, ok := fieldType.Tag.Lookup("multiline")
+		if ok {
+			options.multiline = ml == "true"
+		}
+
+		if willConvert {
+			t.pushTable(k, f, options)
+		} else {
+			t.pushKV(k, f, options)
+		}
+	}
+
+	return enc.encodeTable(b, ctx, t)
+}
+
+func (enc *Encoder) encodeTable(b []byte, ctx encoderCtx, t table) ([]byte, error) {
+	var err error
+
+	ctx.shiftKey()
+
+	if ctx.insideKv {
+		b = append(b, '{')
+
+		first := true
+		for _, kv := range t.kvs {
+			if first {
+				first = false
+			} else {
+				b = append(b, `, `...)
+			}
+			ctx.setKey(kv.Key)
+			b, err = enc.encodeKv(b, ctx, kv.Options, kv.Value)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		for _, table := range t.tables {
+			if first {
+				first = false
+			} else {
+				b = append(b, `, `...)
+			}
+			ctx.setKey(table.Key)
+			b, err = enc.encode(b, ctx, table.Value)
+			if err != nil {
+				return nil, err
+			}
+			b = append(b, '\n')
+		}
+
+		b = append(b, "}\n"...)
+		return b, nil
+	}
+
+	if !ctx.skipTableHeader {
+		b, err = enc.encodeTableHeader(b, ctx.parentKey)
+		if err != nil {
+			return nil, err
+		}
+	}
+	ctx.skipTableHeader = false
+
+	for _, kv := range t.kvs {
+		ctx.setKey(kv.Key)
+		b, err = enc.encodeKv(b, ctx, kv.Options, kv.Value)
+		if err != nil {
+			return nil, err
+		}
+		b = append(b, '\n')
+	}
+
+	for _, table := range t.tables {
+		ctx.setKey(table.Key)
+		b, err = enc.encode(b, ctx, table.Value)
+		if err != nil {
+			return nil, err
+		}
+		b = append(b, '\n')
+	}
+
+	return b, nil
+}
+
+var errNilInterface = errors.New("nil interface not supported")
+var errNilPointer = errors.New("nil pointer not supported")
+
+func willConvertToTable(v reflect.Value) (bool, error) {
+	switch v.Interface().(type) {
+	case time.Time: // TODO: add TextMarshaler
+		return false, nil
+	}
+
+	t := v.Type()
+	switch t.Kind() {
+	case reflect.Map, reflect.Struct:
+		return true, nil
+	case reflect.Interface:
+		if v.IsNil() {
+			return false, errNilInterface
+		}
+		return willConvertToTable(v.Elem())
+	case reflect.Ptr:
+		if v.IsNil() {
+			return false, nil
+		}
+		return willConvertToTable(v.Elem())
+	default:
+		return false, nil
+	}
+}
+
+func willConvertToTableOrArrayTable(v reflect.Value) (bool, error) {
+	t := v.Type()
+
+	if t.Kind() == reflect.Interface {
+		if v.IsNil() {
+			return false, errNilInterface
+		}
+		return willConvertToTableOrArrayTable(v.Elem())
+	}
+
+	if t.Kind() == reflect.Slice {
+		if v.Len() == 0 {
+			// An empty slice should be a kv = [].
+			return false, nil
+		}
+		for i := 0; i < v.Len(); i++ {
+			t, err := willConvertToTable(v.Index(i))
+			if err != nil {
+				return false, err
+			}
+			if !t {
+				return false, nil
+			}
+		}
+		return true, nil
+	}
+
+	return willConvertToTable(v)
+}
+
+func (enc *Encoder) encodeSlice(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, error) {
+	if v.Len() == 0 {
+		b = append(b, "[]"...)
+		return b, nil
+	}
+
+	allTables, err := willConvertToTableOrArrayTable(v)
+	if err != nil {
+		return nil, err
+	}
+
+	if allTables {
+		return enc.encodeSliceAsArrayTable(b, ctx, v)
+	}
+
+	return enc.encodeSliceAsArray(b, ctx, v)
+}
+
+// caller should have checked that v is a slice that only contains values that
+// encode into tables.
+func (enc *Encoder) encodeSliceAsArrayTable(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, error) {
+	if v.Len() == 0 {
+		return b, nil
+	}
+
+	ctx.shiftKey()
+
+	var err error
+	scratch := make([]byte, 0, 64)
+	scratch = append(scratch, "[["...)
+	for i, k := range ctx.parentKey {
+		if i > 0 {
+			scratch = append(scratch, '.')
+		}
+		scratch, err = enc.encodeKey(scratch, k)
+		if err != nil {
+			return nil, err
+		}
+	}
+	scratch = append(scratch, "]]\n"...)
+	ctx.skipTableHeader = true
+
+	for i := 0; i < v.Len(); i++ {
+		b = append(b, scratch...)
+		b, err = enc.encode(b, ctx, v.Index(i))
+		if err != nil {
+			return nil, err
+		}
+	}
+	return b, nil
+}
+
+func (enc *Encoder) encodeSliceAsArray(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, error) {
+	b = append(b, '[')
+
+	var err error
+	first := true
+	for i := 0; i < v.Len(); i++ {
+		if !first {
+			b = append(b, ", "...)
+		}
+		first = false
+
+		b, err = enc.encode(b, ctx, v.Index(i))
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	b = append(b, ']')
+	return b, nil
+}

marshaler_test.go

@@ -0,0 +1,275 @@
+package toml_test
+
+import (
+	"bytes"
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/pelletier/go-toml/v2"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMarshal(t *testing.T) {
+	examples := []struct {
+		desc     string
+		v        interface{}
+		expected string
+		err      bool
+	}{
+		{
+			desc: "simple map and string",
+			v: map[string]string{
+				"hello": "world",
+			},
+			expected: "hello = 'world'",
+		},
+		{
+			desc: "map with new line in key",
+			v: map[string]string{
+				"hel\nlo": "world",
+			},
+			err: true,
+		},
+		{
+			desc: `map with " in key`,
+			v: map[string]string{
+				`hel"lo`: "world",
+			},
+			expected: `'hel"lo' = 'world'`,
+		},
+		{
+			desc: "map in map and string",
+			v: map[string]map[string]string{
+				"table": {
+					"hello": "world",
+				},
+			},
+			expected: `
+[table]
+hello = 'world'`,
+		},
+		{
+			desc: "map in map in map and string",
+			v: map[string]map[string]map[string]string{
+				"this": {
+					"is": {
+						"a": "test",
+					},
+				},
+			},
+			expected: `
+[this]
+[this.is]
+a = 'test'`,
+		},
+		{
+			// TODO: this test is flaky because output changes depending on
+			//   the map iteration order.
+			desc: "map in map in map and string with values",
+			v: map[string]interface{}{
+				"this": map[string]interface{}{
+					"is": map[string]string{
+						"a": "test",
+					},
+					"also": "that",
+				},
+			},
+			expected: `
+[this]
+also = 'that'
+[this.is]
+a = 'test'`,
+		},
+		{
+			desc: "simple string array",
+			v: map[string][]string{
+				"array": {"one", "two", "three"},
+			},
+			expected: `array = ['one', 'two', 'three']`,
+		},
+		{
+			desc: "nested string arrays",
+			v: map[string][][]string{
+				"array": {{"one", "two"}, {"three"}},
+			},
+			expected: `array = [['one', 'two'], ['three']]`,
+		},
+		{
+			desc: "mixed strings and nested string arrays",
+			v: map[string][]interface{}{
+				"array": {"a string", []string{"one", "two"}, "last"},
+			},
+			expected: `array = ['a string', ['one', 'two'], 'last']`,
+		},
+		{
+			desc: "slice of maps",
+			v: map[string][]map[string]string{
+				"top": {
+					{"map1.1": "v1.1"},
+					{"map2.1": "v2.1"},
+				},
+			},
+			expected: `
+[[top]]
+'map1.1' = 'v1.1'
+[[top]]
+'map2.1' = 'v2.1'
+`,
+		},
+		{
+			desc: "map with two keys",
+			v: map[string]string{
+				"key1": "value1",
+				"key2": "value2",
+			},
+			expected: `
+key1 = 'value1'
+key2 = 'value2'`,
+		},
+		{
+			desc: "simple struct",
+			v: struct {
+				A string
+			}{
+				A: "foo",
+			},
+			expected: `A = 'foo'`,
+		},
+		{
+			desc: "one level of structs within structs",
+			v: struct {
+				A interface{}
+			}{
+				A: struct {
+					K1 string
+					K2 string
+				}{
+					K1: "v1",
+					K2: "v2",
+				},
+			},
+			expected: `
+[A]
+K1 = 'v1'
+K2 = 'v2'
+`,
+		},
+		{
+			desc: "structs in slice with interfaces",
+			v: map[string]interface{}{
+				"root": map[string]interface{}{
+					"nested": []interface{}{
+						map[string]interface{}{"name": "Bob"},
+						map[string]interface{}{"name": "Alice"},
+					},
+				},
+			},
+			expected: `
+[root]
+[[root.nested]]
+name = 'Bob'
+[[root.nested]]
+name = 'Alice'
+`,
+		},
+		{
+			desc: "string escapes",
+			v: map[string]interface{}{
+				"a": `'"\`,
+			},
+			expected: `a = "'\"\\"`,
+		},
+		{
+			desc: "string utf8 low",
+			v: map[string]interface{}{
+				"a": "'Ę",
+			},
+			expected: `a = "'Ę"`,
+		},
+		{
+			desc: "string utf8 low 2",
+			v: map[string]interface{}{
+				"a": "'\u10A85",
+			},
+			expected: "a = \"'\u10A85\"",
+		},
+		{
+			desc: "string utf8 low 2",
+			v: map[string]interface{}{
+				"a": "'\u10A85",
+			},
+			expected: "a = \"'\u10A85\"",
+		},
+		{
+			desc: "emoji",
+			v: map[string]interface{}{
+				"a": "'😀",
+			},
+			expected: "a = \"'😀\"",
+		},
+		{
+			desc: "control char",
+			v: map[string]interface{}{
+				"a": "'\u001A",
+			},
+			expected: `a = "'\u001A"`,
+		},
+		{
+			desc: "multi-line string",
+			v: map[string]interface{}{
+				"a": "hello\nworld",
+			},
+			expected: `a = "hello\nworld"`,
+		},
+		{
+			desc: "multi-line forced",
+			v: struct {
+				A string `multiline:"true"`
+			}{
+				A: "hello\nworld",
+			},
+			expected: `A = """
+hello
+world"""`,
+		},
+	}
+
+	for _, e := range examples {
+		t.Run(e.desc, func(t *testing.T) {
+			b, err := toml.Marshal(e.v)
+			if e.err {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				equalStringsIgnoreNewlines(t, e.expected, string(b))
+			}
+		})
+	}
+}
+
+func equalStringsIgnoreNewlines(t *testing.T, expected string, actual string) {
+	t.Helper()
+	cutset := "\n"
+	assert.Equal(t, strings.Trim(expected, cutset), strings.Trim(actual, cutset))
+}
+
+func TestIssue436(t *testing.T) {
+	data := []byte(`{"a": [ { "b": { "c": "d" } } ]}`)
+
+	var v interface{}
+	err := json.Unmarshal(data, &v)
+	require.NoError(t, err)
+
+	var buf bytes.Buffer
+	err = toml.NewEncoder(&buf).Encode(v)
+	require.NoError(t, err)
+
+	expected := `
+[[a]]
+[a.b]
+c = 'd'
+`
+	equalStringsIgnoreNewlines(t, expected, buf.String())
+}

parser_test.go

@@ -1,199 +1,396 @@
 package toml
 
 import (
-	"fmt"
 	"testing"
-	"time"
+
+	"github.com/pelletier/go-toml/v2/internal/ast"
+	"github.com/stretchr/testify/require"
 )
 
-func assertTree(t *testing.T, tree *TomlTree, err error, ref map[string]interface{}) {
+func TestParser_AST_Numbers(t *testing.T) {
-	if err != nil {
+	examples := []struct {
-		t.Error("Non-nil error:", err.Error())
+		desc  string
-		return
+		input string
-	}
+		kind  ast.Kind
-	for k, v := range ref {
+		err   bool
-		if fmt.Sprintf("%v", tree.Get(k)) != fmt.Sprintf("%v", v) {
+	}{
-			t.Log("was expecting", v, "at", k, "but got", tree.Get(k))
+		{
-			t.Error()
+			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,
+		},
 	}
 
-func TestCreateSubTree(t *testing.T) {
+	for _, e := range examples {
-	tree := make(TomlTree)
+		t.Run(e.desc, func(t *testing.T) {
-	tree.createSubTree("a.b.c")
+			p := parser{}
-	tree.Set("a.b.c", 42)
+			p.Reset([]byte(`A = ` + e.input))
-	if tree.Get("a.b.c") != 42 {
+			p.NextExpression()
-		t.Fail()
+			err := p.Error()
-	}
+			if e.err {
-}
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
 
-func TestSimpleKV(t *testing.T) {
+				expected := astNode{
-	tree, err := Load("a = 42")
+					Kind: ast.KeyValue,
-	assertTree(t, tree, err, map[string]interface{}{
+					Children: []astNode{
-		"a": int64(42),
+						{Kind: e.kind, Data: []byte(e.input)},
-	})
+						{Kind: ast.Key, Data: []byte(`A`)},
-
+					},
-	tree, _ = Load("a = 42\nb = 21")
+				}
-	assertTree(t, tree, err, map[string]interface{}{
+				compareNode(t, expected, p.Expression())
-		"a": int64(42),
+			}
-		"b": int64(21),
 		})
 	}
-
-func TestSimpleNumbers(t *testing.T) {
-	tree, err := Load("a = +42\nb = -21\nc = +4.2\nd = -2.1")
-	assertTree(t, tree, err, map[string]interface{}{
-		"a": int64(42),
-		"b": int64(-21),
-		"c": float64(4.2),
-		"d": float64(-2.1),
-	})
 }
 
-func TestSimpleDate(t *testing.T) {
+type astRoot []astNode
-	tree, err := Load("a = 1979-05-27T07:32:00Z")
+type astNode struct {
-	assertTree(t, tree, err, map[string]interface{}{
+	Kind     ast.Kind
-		"a": time.Date(1979, time.May, 27, 7, 32, 0, 0, time.UTC),
+	Data     []byte
-	})
+	Children []astNode
 }
 
-func TestSimpleString(t *testing.T) {
+func compareAST(t *testing.T, expected astRoot, actual *ast.Root) {
-	tree, err := Load("a = \"hello world\"")
+	it := actual.Iterator()
-	assertTree(t, tree, err, map[string]interface{}{
+	compareIterator(t, expected, it)
-		"a": "hello world",
-	})
 }
 
-func TestStringEscapables(t *testing.T) {
+func compareNode(t *testing.T, e astNode, n ast.Node) {
-	tree, err := Load("a = \"a \\n b\"")
+	require.Equal(t, e.Kind, n.Kind)
-	assertTree(t, tree, err, map[string]interface{}{
+	require.Equal(t, e.Data, n.Data)
-		"a": "a \n b",
+
+	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,
 		})
 
-	tree, err = Load("a = \"a \\t b\"")
+		if i > 0 {
-	assertTree(t, tree, err, map[string]interface{}{
+			builder.Chain(last, ref)
-		"a": "a \t b",
+		}
-	})
+		last = ref
 
-	tree, err = Load("a = \"a \\r b\"")
+		if len(n.Children) > 0 {
-	assertTree(t, tree, err, map[string]interface{}{
+			c := childrenToOrig(builder, n.Children)
-		"a": "a \r b",
+			builder.AttachChild(ref, c)
-	})
+		}
+	}
 
-	tree, err = Load("a = \"a \\\\ b\"")
+	return builder.Tree()
-	assertTree(t, tree, err, map[string]interface{}{
+}
-		"a": "a \\ b",
+
+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())
+			}
 		})
 	}
-
-func TestBools(t *testing.T) {
-	tree, err := Load("a = true\nb = false")
-	assertTree(t, tree, err, map[string]interface{}{
-		"a": true,
-		"b": false,
-	})
-}
-
-func TestNestedKeys(t *testing.T) {
-	tree, err := Load("[a.b.c]\nd = 42")
-	assertTree(t, tree, err, map[string]interface{}{
-		"a.b.c.d": int64(42),
-	})
-}
-
-func TestArrayOne(t *testing.T) {
-	tree, err := Load("a = [1]")
-	assertTree(t, tree, err, map[string]interface{}{
-		"a": []int64{int64(1)},
-	})
-}
-
-func TestArrayZero(t *testing.T) {
-	tree, err := Load("a = []")
-	assertTree(t, tree, err, map[string]interface{}{
-		"a": []interface{}{},
-	})
-}
-
-func TestArraySimple(t *testing.T) {
-	tree, err := Load("a = [42, 21, 10]")
-	assertTree(t, tree, err, map[string]interface{}{
-		"a": []int64{int64(42), int64(21), int64(10)},
-	})
-
-	tree, _ = Load("a = [42, 21, 10,]")
-	assertTree(t, tree, err, map[string]interface{}{
-		"a": []int64{int64(42), int64(21), int64(10)},
-	})
-}
-
-func TestArrayMultiline(t *testing.T) {
-	tree, err := Load("a = [42,\n21, 10,]")
-	assertTree(t, tree, err, map[string]interface{}{
-		"a": []int64{int64(42), int64(21), int64(10)},
-	})
-}
-
-func TestArrayNested(t *testing.T) {
-	tree, err := Load("a = [[42, 21], [10]]")
-	assertTree(t, tree, err, map[string]interface{}{
-		"a": [][]int64{[]int64{int64(42), int64(21)}, []int64{int64(10)}},
-	})
-}
-
-func TestArrayNestedStrings(t *testing.T) {
-	tree, err := Load("data = [ [\"gamma\", \"delta\"], [\"Foo\"] ]")
-	assertTree(t, tree, err, map[string]interface{}{
-		"data": [][]string{[]string{"gamma", "delta"}, []string{"Foo"}},
-	})
-}
-
-func TestMissingValue(t *testing.T) {
-	_, err := Load("a = ")
-	if err.Error() != "expecting a value" {
-		t.Error("Bad error message:", err.Error())
-	}
-}
-
-func TestUnterminatedArray(t *testing.T) {
-	_, err := Load("a = [1,")
-	if err.Error() != "unterminated array" {
-		t.Error("Bad error message:", err.Error())
-	}
-}
-
-func TestNewlinesInArrays(t *testing.T) {
-	tree, err := Load("a = [1,\n2,\n3]")
-	assertTree(t, tree, err, map[string]interface{}{
-		"a": []int64{int64(1), int64(2), int64(3)},
-	})
-}
-
-func TestMissingFile(t *testing.T) {
-	_, err := LoadFile("foo.toml")
-	if err.Error() != "open foo.toml: no such file or directory" {
-		t.Error("Bad error message:", err.Error())
-	}
-}
-
-func TestParseFile(t *testing.T) {
-	tree, err := LoadFile("example.toml")
-
-	assertTree(t, tree, err, map[string]interface{}{
-		"title":                   "TOML Example",
-		"owner.name":              "Tom Preston-Werner",
-		"owner.organization":      "GitHub",
-		"owner.bio":               "GitHub Cofounder & CEO\nLikes tater tots and beer.",
-		"owner.dob":               time.Date(1979, time.May, 27, 7, 32, 0, 0, time.UTC),
-		"database.server":         "192.168.1.1",
-		"database.ports":          []int64{8001, 8001, 8002},
-		"database.connection_max": 5000,
-		"database.enabled":        true,
-		"servers.alpha.ip":        "10.0.0.1",
-		"servers.alpha.dc":        "eqdc10",
-		"servers.beta.ip":         "10.0.0.2",
-		"servers.beta.dc":         "eqdc10",
-		"clients.data":            []interface{}{[]string{"gamma", "delta"}, []int64{1, 2}},
-	})
 }

scanner.go

@@ -0,0 +1,168 @@
+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 """`)
+}

targets.go

@@ -0,0 +1,554 @@
+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

@@ -0,0 +1,184 @@
+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()
+			}
+		})
+	}
+}

toml.abnf

@@ -0,0 +1,242 @@
+;; This document describes TOML's syntax, using the ABNF format (defined in
+;; RFC 5234 -- https://www.ietf.org/rfc/rfc5234.txt).
+;;
+;; All valid TOML documents will match this description, however certain
+;; invalid documents would need to be rejected as per the semantics described
+;; in the supporting text description.
+
+;; It is possible to try this grammar interactively, using instaparse.
+;;     http://instaparse.mojombo.com/
+;;
+;; To do so, in the lower right, click on Options and change `:input-format` to
+;; ':abnf'. Then paste this entire ABNF document into the grammar entry box
+;; (above the options). Then you can type or paste a sample TOML document into
+;; the beige box on the left. Tada!
+
+;; Overall Structure
+
+toml = expression *( newline expression )
+
+expression =  ws [ comment ]
+expression =/ ws keyval ws [ comment ]
+expression =/ ws table ws [ comment ]
+
+;; Whitespace
+
+ws = *wschar
+wschar =  %x20  ; Space
+wschar =/ %x09  ; Horizontal tab
+
+;; Newline
+
+newline =  %x0A     ; LF
+newline =/ %x0D.0A  ; CRLF
+
+;; Comment
+
+comment-start-symbol = %x23 ; #
+non-ascii = %x80-D7FF / %xE000-10FFFF
+non-eol = %x09 / %x20-7F / non-ascii
+
+comment = comment-start-symbol *non-eol
+
+;; Key-Value pairs
+
+keyval = key keyval-sep val
+
+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
+keyval-sep = ws %x3D ws ; =
+
+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
+
+quotation-mark = %x22            ; "
+
+basic-char = basic-unescaped / escaped
+basic-unescaped = wschar / %x21 / %x23-5B / %x5D-7E / non-ascii
+escaped = escape escape-seq-char
+
+escape = %x5C                   ; \
+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
+
+;; Multiline Basic String
+
+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 )
+
+;; Literal String
+
+literal-string = apostrophe *literal-char apostrophe
+
+apostrophe = %x27 ; ' apostrophe
+
+literal-char = %x09 / %x20-26 / %x28-7E / non-ascii
+
+;; Multiline Literal String
+
+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
+
+;; Integer
+
+integer = dec-int / hex-int / oct-int / bin-int
+
+minus = %x2D                       ; -
+plus = %x2B                        ; +
+underscore = %x5F                  ; _
+digit1-9 = %x31-39                 ; 1-9
+digit0-7 = %x30-37                 ; 0-7
+digit0-1 = %x30-31                 ; 0-1
+
+hex-prefix = %x30.78               ; 0x
+oct-prefix = %x30.6F               ; 0o
+bin-prefix = %x30.62               ; 0b
+
+dec-int = [ minus / plus ] unsigned-dec-int
+unsigned-dec-int = DIGIT / digit1-9 1*( DIGIT / underscore DIGIT )
+
+hex-int = hex-prefix HEXDIG *( HEXDIG / underscore HEXDIG )
+oct-int = oct-prefix digit0-7 *( digit0-7 / underscore digit0-7 )
+bin-int = bin-prefix digit0-1 *( digit0-1 / underscore digit0-1 )
+
+;; Float
+
+float = float-int-part ( exp / frac [ exp ] )
+float =/ special-float
+
+float-int-part = dec-int
+frac = decimal-point zero-prefixable-int
+decimal-point = %x2E               ; .
+zero-prefixable-int = DIGIT *( DIGIT / underscore DIGIT )
+
+exp = "e" float-exp-part
+float-exp-part = [ minus / plus ] zero-prefixable-int
+
+special-float = [ minus / plus ] ( inf / nan )
+inf = %x69.6e.66  ; inf
+nan = %x6e.61.6e  ; nan
+
+;; Boolean
+
+boolean = true / false
+
+true    = %x74.72.75.65     ; true
+false   = %x66.61.6C.73.65  ; false
+
+;; Date and Time (as defined in RFC 3339)
+
+date-time      = offset-date-time / local-date-time / local-date / local-time
+
+date-fullyear  = 4DIGIT
+date-month     = 2DIGIT  ; 01-12
+date-mday      = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31 based on month/year
+time-delim     = "T" / %x20 ; T, t, or space
+time-hour      = 2DIGIT  ; 00-23
+time-minute    = 2DIGIT  ; 00-59
+time-second    = 2DIGIT  ; 00-58, 00-59, 00-60 based on leap second rules
+time-secfrac   = "." 1*DIGIT
+time-numoffset = ( "+" / "-" ) time-hour ":" time-minute
+time-offset    = "Z" / time-numoffset
+
+partial-time   = time-hour ":" time-minute ":" time-second [ time-secfrac ]
+full-date      = date-fullyear "-" date-month "-" date-mday
+full-time      = partial-time time-offset
+
+;; Offset Date-Time
+
+offset-date-time = full-date time-delim full-time
+
+;; Local Date-Time
+
+local-date-time = full-date time-delim partial-time
+
+;; Local Date
+
+local-date = full-date
+
+;; Local Time
+
+local-time = partial-time
+
+;; Array
+
+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 )
+
+;; Table
+
+table = std-table / array-table
+
+;; Standard Table
+
+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
+
+;; Inline Table
+
+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 ]
+
+;; Array Table
+
+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
+
+;; Built-in ABNF terms, reproduced here for clarity
+
+ALPHA = %x41-5A / %x61-7A ; A-Z / a-z
+DIGIT = %x30-39 ; 0-9
+HEXDIG = DIGIT / "A" / "B" / "C" / "D" / "E" / "F"

toml.go

@@ -1,114 +0,0 @@
-// TOML markup language parser.
-//
-// This version supports the specification as described in
-// https://github.com/mojombo/toml/tree/e3656ad493400895f4460f1244a25f8f8e31a32a
-package toml
-
-import (
-	"errors"
-	"io/ioutil"
-	"runtime"
-	"strings"
-)
-
-// Definition of a TomlTree.
-// This is the result of the parsing of a TOML file.
-type TomlTree map[string]interface{}
-
-// Keys returns the keys of the toplevel tree.
-// Warning: this is a costly operation.
-func (t *TomlTree) Keys() []string {
-	keys := make([]string, 0)
-	mp := (map[string]interface{})(*t)
-	for k, _ := range mp {
-		keys = append(keys, k)
-	}
-	return keys
-}
-
-// Get the value at key in the TomlTree.
-// Key is a dot-separated path (e.g. a.b.c).
-// Returns nil if the path does not exist in the tree.
-func (t *TomlTree) Get(key string) interface{} {
-	subtree := t
-	keys := strings.Split(key, ".")
-	for _, intermediate_key := range keys[:len(keys)-1] {
-		_, exists := (*subtree)[intermediate_key]
-		if !exists {
-			return nil
-		}
-		subtree = (*subtree)[intermediate_key].(*TomlTree)
-	}
-	return (*subtree)[keys[len(keys)-1]]
-}
-
-// Same as Get but with a default value
-func (t *TomlTree) GetDefault(key string, def interface{}) interface{} {
-    val := t.Get(key)
-    if val == nil {
-        return def
-    }
-    return val;
-}
-
-// Set an element in the tree.
-// Key is a dot-separated path (e.g. a.b.c).
-// Creates all necessary intermediates trees, if needed.
-func (t *TomlTree) Set(key string, value interface{}) {
-	subtree := t
-	keys := strings.Split(key, ".")
-	for _, intermediate_key := range keys[:len(keys)-1] {
-		_, exists := (*subtree)[intermediate_key]
-		if !exists {
-			var new_tree TomlTree = make(TomlTree)
-			(*subtree)[intermediate_key] = &new_tree
-		}
-		subtree = (*subtree)[intermediate_key].(*TomlTree)
-	}
-	(*subtree)[keys[len(keys)-1]] = value
-}
-
-// createSubTree takes a tree and a key and create the necessary intermediate
-// subtrees to create a subtree at that point. In-place.
-//
-// e.g. passing a.b.c will create (assuming tree is empty) tree[a], tree[a][b]
-// and tree[a][b][c]
-func (t *TomlTree) createSubTree(key string) {
-	subtree := t
-	for _, intermediate_key := range strings.Split(key, ".") {
-		_, exists := (*subtree)[intermediate_key]
-		if !exists {
-			var new_tree TomlTree = make(TomlTree)
-			(*subtree)[intermediate_key] = &new_tree
-		}
-		subtree = ((*subtree)[intermediate_key]).(*TomlTree)
-	}
-}
-
-// Create a TomlTree from a string.
-func Load(content string) (tree *TomlTree, err error) {
-	defer func() {
-		if r := recover(); r != nil {
-			if _, ok := r.(runtime.Error); ok {
-				panic(r)
-			}
-			err = errors.New(r.(string))
-		}
-	}()
-	_, flow := lex(content)
-	tree = parse(flow)
-	return
-}
-
-// Create a TomlTree from a file.
-func LoadFile(path string) (tree *TomlTree, err error) {
-	buff, ferr := ioutil.ReadFile(path)
-	if ferr != nil {
-		err = ferr
-	} else {
-		s := string(buff)
-		tree, err = Load(s)
-	}
-
-	return
-}

toml_test.go

@@ -1 +0,0 @@
-package toml

toml_testgen_support_test.go

@@ -0,0 +1,138 @@
+// This is a support file for toml_testgen_test.go
+package toml_test
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/pelletier/go-toml/v2"
+	"github.com/stretchr/testify/require"
+)
+
+func testgenInvalid(t *testing.T, input string) {
+	t.Helper()
+	t.Logf("Input TOML:\n%s", input)
+
+	doc := map[string]interface{}{}
+	err := toml.Unmarshal([]byte(input), &doc)
+
+	if err == nil {
+		t.Log(json.Marshal(doc))
+		t.Fatalf("test did not fail")
+	}
+}
+
+func testgenValid(t *testing.T, input string, jsonRef string) {
+	t.Helper()
+	t.Logf("Input TOML:\n%s", input)
+
+	doc := map[string]interface{}{}
+	err := toml.Unmarshal([]byte(input), &doc)
+	if err != nil {
+		t.Fatalf("failed parsing toml: %s", err)
+	}
+
+	refDoc := testgenBuildRefDoc(jsonRef)
+
+	require.Equal(t, refDoc, doc)
+
+	out, err := toml.Marshal(doc)
+	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
+}

toml_testgen_test.go

@@ -0,0 +1,928 @@
+// Generated by tomltestgen for toml-test ref 39e37e6 on 2019-03-19T23:58:45-07:00
+package toml_test
+
+import (
+	"testing"
+)
+
+func TestInvalidDatetimeMalformedNoLeads(t *testing.T) {
+	input := `no-leads = 1987-7-05T17:45:00Z`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidDatetimeMalformedNoSecs(t *testing.T) {
+	input := `no-secs = 1987-07-05T17:45Z`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidDatetimeMalformedNoT(t *testing.T) {
+	input := `no-t = 1987-07-0517:45:00Z`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidDatetimeMalformedWithMilli(t *testing.T) {
+	input := `with-milli = 1987-07-5T17:45:00.12Z`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidDuplicateKeyTable(t *testing.T) {
+	input := `[fruit]
+type = "apple"
+
+[fruit.type]
+apple = "yes"`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidDuplicateKeys(t *testing.T) {
+	input := `dupe = false
+dupe = true`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidDuplicateTables(t *testing.T) {
+	input := `[a]
+[a]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidEmptyImplicitTable(t *testing.T) {
+	input := `[naughty..naughty]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidEmptyTable(t *testing.T) {
+	input := `[]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidFloatNoLeadingZero(t *testing.T) {
+	input := `answer = .12345
+neganswer = -.12345`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidFloatNoTrailingDigits(t *testing.T) {
+	input := `answer = 1.
+neganswer = -1.`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidKeyEmpty(t *testing.T) {
+	input := ` = 1`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidKeyHash(t *testing.T) {
+	input := `a# = 1`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidKeyNewline(t *testing.T) {
+	input := `a
+= 1`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidKeyOpenBracket(t *testing.T) {
+	input := `[abc = 1`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidKeySingleOpenBracket(t *testing.T) {
+	input := `[`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidKeySpace(t *testing.T) {
+	input := `a b = 1`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidKeyStartBracket(t *testing.T) {
+	input := `[a]
+[xyz = 5
+[b]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidKeyTwoEquals(t *testing.T) {
+	input := `key= = 1`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidStringBadByteEscape(t *testing.T) {
+	input := `naughty = "\xAg"`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidStringBadEscape(t *testing.T) {
+	input := `invalid-escape = "This string has a bad \a escape character."`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidStringByteEscapes(t *testing.T) {
+	input := `answer = "\x33"`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidStringNoClose(t *testing.T) {
+	input := `no-ending-quote = "One time, at band camp`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTableArrayImplicit(t *testing.T) {
+	input := "# This test is a bit tricky. It should fail because the first use of\n" +
+		"# `[[albums.songs]]` without first declaring `albums` implies that `albums`\n" +
+		"# must be a table. The alternative would be quite weird. Namely, it wouldn't\n" +
+		"# comply with the TOML spec: \"Each double-bracketed sub-table will belong to \n" +
+		"# the most *recently* defined table element *above* it.\"\n" +
+		"#\n" +
+		"# This is in contrast to the *valid* test, table-array-implicit where\n" +
+		"# `[[albums.songs]]` works by itself, so long as `[[albums]]` isn't declared\n" +
+		"# later. (Although, `[albums]` could be.)\n" +
+		"[[albums.songs]]\n" +
+		"name = \"Glory Days\"\n" +
+		"\n" +
+		"[[albums]]\n" +
+		"name = \"Born in the USA\"\n"
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTableArrayMalformedBracket(t *testing.T) {
+	input := `[[albums]
+name = "Born to Run"`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTableArrayMalformedEmpty(t *testing.T) {
+	input := `[[]]
+name = "Born to Run"`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTableEmpty(t *testing.T) {
+	input := `[]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTableNestedBracketsClose(t *testing.T) {
+	input := `[a]b]
+zyx = 42`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTableNestedBracketsOpen(t *testing.T) {
+	input := `[a[b]
+zyx = 42`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTableWhitespace(t *testing.T) {
+	input := `[invalid key]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTableWithPound(t *testing.T) {
+	input := `[key#group]
+answer = 42`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTextAfterArrayEntries(t *testing.T) {
+	input := `array = [
+  "Is there life after an array separator?", No
+  "Entry"
+]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTextAfterInteger(t *testing.T) {
+	input := `answer = 42 the ultimate answer?`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTextAfterString(t *testing.T) {
+	input := `string = "Is there life after strings?" No.`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTextAfterTable(t *testing.T) {
+	input := `[error] this shouldn't be here`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTextBeforeArraySeparator(t *testing.T) {
+	input := `array = [
+  "Is there life before an array separator?" No,
+  "Entry"
+]`
+	testgenInvalid(t, input)
+}
+
+func TestInvalidTextInArray(t *testing.T) {
+	input := `array = [
+  "Entry 1",
+  I don't belong,
+  "Entry 2",
+]`
+	testgenInvalid(t, input)
+}
+
+func TestValidArrayEmpty(t *testing.T) {
+	input := `thevoid = [[[[[]]]]]`
+	jsonRef := `{
+    "thevoid": { "type": "array", "value": [
+        {"type": "array", "value": [
+            {"type": "array", "value": [
+                {"type": "array", "value": [
+                    {"type": "array", "value": []}
+                ]}
+            ]}
+        ]}
+    ]}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidArrayNospaces(t *testing.T) {
+	input := `ints = [1,2,3]`
+	jsonRef := `{
+    "ints": {
+        "type": "array",
+        "value": [
+            {"type": "integer", "value": "1"},
+            {"type": "integer", "value": "2"},
+            {"type": "integer", "value": "3"}
+        ]
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidArraysHetergeneous(t *testing.T) {
+	input := `mixed = [[1, 2], ["a", "b"], [1.1, 2.1]]`
+	jsonRef := `{
+    "mixed": {
+        "type": "array",
+        "value": [
+            {"type": "array", "value": [
+                {"type": "integer", "value": "1"},
+                {"type": "integer", "value": "2"}
+            ]},
+            {"type": "array", "value": [
+                {"type": "string", "value": "a"},
+                {"type": "string", "value": "b"}
+            ]},
+            {"type": "array", "value": [
+                {"type": "float", "value": "1.1"},
+                {"type": "float", "value": "2.1"}
+            ]}
+        ]
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidArraysNested(t *testing.T) {
+	input := `nest = [["a"], ["b"]]`
+	jsonRef := `{
+    "nest": {
+        "type": "array",
+        "value": [
+            {"type": "array", "value": [
+                {"type": "string", "value": "a"}
+            ]},
+            {"type": "array", "value": [
+                {"type": "string", "value": "b"}
+            ]}
+        ]
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidArrays(t *testing.T) {
+	input := `ints = [1, 2, 3]
+floats = [1.1, 2.1, 3.1]
+strings = ["a", "b", "c"]
+dates = [
+  1987-07-05T17:45:00Z,
+  1979-05-27T07:32:00Z,
+  2006-06-01T11:00:00Z,
+]`
+	jsonRef := `{
+    "ints": {
+        "type": "array",
+        "value": [
+            {"type": "integer", "value": "1"},
+            {"type": "integer", "value": "2"},
+            {"type": "integer", "value": "3"}
+        ]
+    },
+    "floats": {
+        "type": "array",
+        "value": [
+            {"type": "float", "value": "1.1"},
+            {"type": "float", "value": "2.1"},
+            {"type": "float", "value": "3.1"}
+        ]
+    },
+    "strings": {
+        "type": "array",
+        "value": [
+            {"type": "string", "value": "a"},
+            {"type": "string", "value": "b"},
+            {"type": "string", "value": "c"}
+        ]
+    },
+    "dates": {
+        "type": "array",
+        "value": [
+            {"type": "datetime", "value": "1987-07-05T17:45:00Z"},
+            {"type": "datetime", "value": "1979-05-27T07:32:00Z"},
+            {"type": "datetime", "value": "2006-06-01T11:00:00Z"}
+        ]
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidBool(t *testing.T) {
+	input := `t = true
+f = false`
+	jsonRef := `{
+    "f": {"type": "bool", "value": "false"},
+    "t": {"type": "bool", "value": "true"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidCommentsEverywhere(t *testing.T) {
+	input := `# Top comment.
+  # Top comment.
+# Top comment.
+
+# [no-extraneous-groups-please]
+
+[group] # Comment
+answer = 42 # Comment
+# no-extraneous-keys-please = 999
+# Inbetween comment.
+more = [ # Comment
+  # What about multiple # comments?
+  # Can you handle it?
+  #
+          # Evil.
+# Evil.
+  42, 42, # Comments within arrays are fun.
+  # What about multiple # comments?
+  # Can you handle it?
+  #
+          # Evil.
+# Evil.
+# ] Did I fool you?
+] # Hopefully not.`
+	jsonRef := `{
+    "group": {
+        "answer": {"type": "integer", "value": "42"},
+        "more": {
+            "type": "array",
+            "value": [
+                {"type": "integer", "value": "42"},
+                {"type": "integer", "value": "42"}
+            ]
+        }
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidDatetime(t *testing.T) {
+	input := `bestdayever = 1987-07-05T17:45:00Z`
+	jsonRef := `{
+    "bestdayever": {"type": "datetime", "value": "1987-07-05T17:45:00Z"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidEmpty(t *testing.T) {
+	input := ``
+	jsonRef := `{}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidExample(t *testing.T) {
+	input := `best-day-ever = 1987-07-05T17:45:00Z
+
+[numtheory]
+boring = false
+perfection = [6, 28, 496]`
+	jsonRef := `{
+  "best-day-ever": {"type": "datetime", "value": "1987-07-05T17:45:00Z"},
+  "numtheory": {
+    "boring": {"type": "bool", "value": "false"},
+    "perfection": {
+      "type": "array",
+      "value": [
+        {"type": "integer", "value": "6"},
+        {"type": "integer", "value": "28"},
+        {"type": "integer", "value": "496"}
+      ]
+    }
+  }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidFloat(t *testing.T) {
+	input := `pi = 3.14
+negpi = -3.14`
+	jsonRef := `{
+    "pi": {"type": "float", "value": "3.14"},
+    "negpi": {"type": "float", "value": "-3.14"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidImplicitAndExplicitAfter(t *testing.T) {
+	input := `[a.b.c]
+answer = 42
+
+[a]
+better = 43`
+	jsonRef := `{
+    "a": {
+        "better": {"type": "integer", "value": "43"},
+        "b": {
+            "c": {
+                "answer": {"type": "integer", "value": "42"}
+            }
+        }
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidImplicitAndExplicitBefore(t *testing.T) {
+	input := `[a]
+better = 43
+
+[a.b.c]
+answer = 42`
+	jsonRef := `{
+    "a": {
+        "better": {"type": "integer", "value": "43"},
+        "b": {
+            "c": {
+                "answer": {"type": "integer", "value": "42"}
+            }
+        }
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidImplicitGroups(t *testing.T) {
+	input := `[a.b.c]
+answer = 42`
+	jsonRef := `{
+    "a": {
+        "b": {
+            "c": {
+                "answer": {"type": "integer", "value": "42"}
+            }
+        }
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidInteger(t *testing.T) {
+	input := `answer = 42
+neganswer = -42`
+	jsonRef := `{
+    "answer": {"type": "integer", "value": "42"},
+    "neganswer": {"type": "integer", "value": "-42"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidKeyEqualsNospace(t *testing.T) {
+	input := `answer=42`
+	jsonRef := `{
+    "answer": {"type": "integer", "value": "42"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidKeySpace(t *testing.T) {
+	input := `"a b" = 1`
+	jsonRef := `{
+    "a b": {"type": "integer", "value": "1"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidKeySpecialChars(t *testing.T) {
+	input := "\"~!@$^&*()_+-`1234567890[]|/?><.,;:'\" = 1\n"
+	jsonRef := "{\n" +
+		"    \"~!@$^&*()_+-`1234567890[]|/?><.,;:'\": {\n" +
+		"        \"type\": \"integer\", \"value\": \"1\"\n" +
+		"    }\n" +
+		"}\n"
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidLongFloat(t *testing.T) {
+	input := `longpi = 3.141592653589793
+neglongpi = -3.141592653589793`
+	jsonRef := `{
+    "longpi": {"type": "float", "value": "3.141592653589793"},
+    "neglongpi": {"type": "float", "value": "-3.141592653589793"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidLongInteger(t *testing.T) {
+	input := `answer = 9223372036854775807
+neganswer = -9223372036854775808`
+	jsonRef := `{
+    "answer": {"type": "integer", "value": "9223372036854775807"},
+    "neganswer": {"type": "integer", "value": "-9223372036854775808"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidMultilineString(t *testing.T) {
+	input := `multiline_empty_one = """"""
+multiline_empty_two = """
+"""
+multiline_empty_three = """\
+    """
+multiline_empty_four = """\
+   \
+   \
+   """
+
+equivalent_one = "The quick brown fox jumps over the lazy dog."
+equivalent_two = """
+The quick brown \
+
+
+  fox jumps over \
+    the lazy dog."""
+
+equivalent_three = """\
+       The quick brown \
+       fox jumps over \
+       the lazy dog.\
+       """`
+	jsonRef := `{
+    "multiline_empty_one": {
+        "type": "string",
+        "value": ""
+    },
+    "multiline_empty_two": {
+        "type": "string",
+        "value": ""
+    },
+    "multiline_empty_three": {
+        "type": "string",
+        "value": ""
+    },
+    "multiline_empty_four": {
+        "type": "string",
+        "value": ""
+    },
+    "equivalent_one": {
+        "type": "string",
+        "value": "The quick brown fox jumps over the lazy dog."
+    },
+    "equivalent_two": {
+        "type": "string",
+        "value": "The quick brown fox jumps over the lazy dog."
+    },
+    "equivalent_three": {
+        "type": "string",
+        "value": "The quick brown fox jumps over the lazy dog."
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidRawMultilineString(t *testing.T) {
+	input := `oneline = '''This string has a ' quote character.'''
+firstnl = '''
+This string has a ' quote character.'''
+multiline = '''
+This string
+has ' a quote character
+and more than
+one newline
+in it.'''`
+	jsonRef := `{
+    "oneline": {
+        "type": "string",
+        "value": "This string has a ' quote character."
+    },
+    "firstnl": {
+        "type": "string",
+        "value": "This string has a ' quote character."
+    },
+    "multiline": {
+        "type": "string",
+        "value": "This string\nhas ' a quote character\nand more than\none newline\nin it."
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidRawString(t *testing.T) {
+	input := `backspace = 'This string has a \b backspace character.'
+tab = 'This string has a \t tab character.'
+newline = 'This string has a \n new line character.'
+formfeed = 'This string has a \f form feed character.'
+carriage = 'This string has a \r carriage return character.'
+slash = 'This string has a \/ slash character.'
+backslash = 'This string has a \\ backslash character.'`
+	jsonRef := `{
+    "backspace": {
+        "type": "string",
+        "value": "This string has a \\b backspace character."
+    },
+    "tab": {
+        "type": "string",
+        "value": "This string has a \\t tab character."
+    },
+    "newline": {
+        "type": "string",
+        "value": "This string has a \\n new line character."
+    },
+    "formfeed": {
+        "type": "string",
+        "value": "This string has a \\f form feed character."
+    },
+    "carriage": {
+        "type": "string",
+        "value": "This string has a \\r carriage return character."
+    },
+    "slash": {
+        "type": "string",
+        "value": "This string has a \\/ slash character."
+    },
+    "backslash": {
+        "type": "string",
+        "value": "This string has a \\\\ backslash character."
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidStringEmpty(t *testing.T) {
+	input := `answer = ""`
+	jsonRef := `{
+    "answer": {
+        "type": "string",
+        "value": ""
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidStringEscapes(t *testing.T) {
+	input := `backspace = "This string has a \b backspace character."
+tab = "This string has a \t tab character."
+newline = "This string has a \n new line character."
+formfeed = "This string has a \f form feed character."
+carriage = "This string has a \r carriage return character."
+quote = "This string has a \" quote character."
+backslash = "This string has a \\ backslash character."
+notunicode1 = "This string does not have a unicode \\u escape."
+notunicode2 = "This string does not have a unicode \u005Cu escape."
+notunicode3 = "This string does not have a unicode \\u0075 escape."
+notunicode4 = "This string does not have a unicode \\\u0075 escape."`
+	jsonRef := `{
+    "backspace": {
+        "type": "string",
+        "value": "This string has a \u0008 backspace character."
+    },
+    "tab": {
+        "type": "string",
+        "value": "This string has a \u0009 tab character."
+    },
+    "newline": {
+        "type": "string",
+        "value": "This string has a \u000A new line character."
+    },
+    "formfeed": {
+        "type": "string",
+        "value": "This string has a \u000C form feed character."
+    },
+    "carriage": {
+        "type": "string",
+        "value": "This string has a \u000D carriage return character."
+    },
+    "quote": {
+        "type": "string",
+        "value": "This string has a \u0022 quote character."
+    },
+    "backslash": {
+        "type": "string",
+        "value": "This string has a \u005C backslash character."
+    },
+    "notunicode1": {
+        "type": "string",
+        "value": "This string does not have a unicode \\u escape."
+    },
+    "notunicode2": {
+        "type": "string",
+        "value": "This string does not have a unicode \u005Cu escape."
+    },
+    "notunicode3": {
+        "type": "string",
+        "value": "This string does not have a unicode \\u0075 escape."
+    },
+    "notunicode4": {
+        "type": "string",
+        "value": "This string does not have a unicode \\\u0075 escape."
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidStringSimple(t *testing.T) {
+	input := `answer = "You are not drinking enough whisky."`
+	jsonRef := `{
+    "answer": {
+        "type": "string",
+        "value": "You are not drinking enough whisky."
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidStringWithPound(t *testing.T) {
+	input := `pound = "We see no # comments here."
+poundcomment = "But there are # some comments here." # Did I # mess you up?`
+	jsonRef := `{
+    "pound": {"type": "string", "value": "We see no # comments here."},
+    "poundcomment": {
+        "type": "string",
+        "value": "But there are # some comments here."
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidTableArrayImplicit(t *testing.T) {
+	input := `[[albums.songs]]
+name = "Glory Days"`
+	jsonRef := `{
+    "albums": {
+       "songs": [
+           {"name": {"type": "string", "value": "Glory Days"}}
+       ]
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidTableArrayMany(t *testing.T) {
+	input := `[[people]]
+first_name = "Bruce"
+last_name = "Springsteen"
+
+[[people]]
+first_name = "Eric"
+last_name = "Clapton"
+
+[[people]]
+first_name = "Bob"
+last_name = "Seger"`
+	jsonRef := `{
+    "people": [
+        {
+            "first_name": {"type": "string", "value": "Bruce"},
+            "last_name": {"type": "string", "value": "Springsteen"}
+        },
+        {
+            "first_name": {"type": "string", "value": "Eric"},
+            "last_name": {"type": "string", "value": "Clapton"}
+        },
+        {
+            "first_name": {"type": "string", "value": "Bob"},
+            "last_name": {"type": "string", "value": "Seger"}
+        }
+    ]
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidTableArrayNest(t *testing.T) {
+	input := `[[albums]]
+name = "Born to Run"
+
+  [[albums.songs]]
+  name = "Jungleland"
+
+  [[albums.songs]]
+  name = "Meeting Across the River"
+
+[[albums]]
+name = "Born in the USA"
+  
+  [[albums.songs]]
+  name = "Glory Days"
+
+  [[albums.songs]]
+  name = "Dancing in the Dark"`
+	jsonRef := `{
+    "albums": [
+        {
+            "name": {"type": "string", "value": "Born to Run"},
+            "songs": [
+                {"name": {"type": "string", "value": "Jungleland"}},
+                {"name": {"type": "string", "value": "Meeting Across the River"}}
+            ]
+        },
+        {
+            "name": {"type": "string", "value": "Born in the USA"},
+            "songs": [
+                {"name": {"type": "string", "value": "Glory Days"}},
+                {"name": {"type": "string", "value": "Dancing in the Dark"}}
+            ]
+        }
+    ]
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidTableArrayOne(t *testing.T) {
+	input := `[[people]]
+first_name = "Bruce"
+last_name = "Springsteen"`
+	jsonRef := `{
+    "people": [
+        {
+            "first_name": {"type": "string", "value": "Bruce"},
+            "last_name": {"type": "string", "value": "Springsteen"}
+        }
+    ]
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidTableEmpty(t *testing.T) {
+	input := `[a]`
+	jsonRef := `{
+    "a": {}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidTableSubEmpty(t *testing.T) {
+	input := `[a]
+[a.b]`
+	jsonRef := `{
+    "a": { "b": {} }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidTableWhitespace(t *testing.T) {
+	input := `["valid key"]`
+	jsonRef := `{
+    "valid key": {}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidTableWithPound(t *testing.T) {
+	input := `["key#group"]
+answer = 42`
+	jsonRef := `{
+    "key#group": {
+        "answer": {"type": "integer", "value": "42"}
+    }
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidUnicodeEscape(t *testing.T) {
+	input := `answer4 = "\u03B4"
+answer8 = "\U000003B4"`
+	jsonRef := `{
+    "answer4": {"type": "string", "value": "\u03B4"},
+    "answer8": {"type": "string", "value": "\u03B4"}
+}`
+	testgenValid(t, input, jsonRef)
+}
+
+func TestValidUnicodeLiteral(t *testing.T) {
+	input := `answer = "δ"`
+	jsonRef := `{
+    "answer": {"type": "string", "value": "δ"}
+}`
+	testgenValid(t, input, jsonRef)
+}

unmarshaler.go

@@ -0,0 +1,427 @@
+package toml
+
+import (
+	"encoding"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"reflect"
+	"time"
+
+	"github.com/pelletier/go-toml/v2/internal/ast"
+	"github.com/pelletier/go-toml/v2/internal/tracker"
+)
+
+func Unmarshal(data []byte, v interface{}) error {
+	p := parser{}
+	p.Reset(data)
+	d := decoder{}
+	return d.FromParser(&p, v)
+}
+
+// Decoder reads and decode a TOML document from an input stream.
+type Decoder struct {
+	r io.Reader
+}
+
+// NewDecoder creates a new Decoder that will read from r.
+func NewDecoder(r io.Reader) *Decoder {
+	return &Decoder{r: r}
+}
+
+// Decode the whole content of r into v.
+//
+// When a TOML local date is decoded into a time.Time, its value is represented
+// in time.Local timezone.
+//
+// Empty tables decoded in an interface{} create an empty initialized
+// map[string]interface{}.
+func (d *Decoder) Decode(v interface{}) error {
+	b, err := ioutil.ReadAll(d.r)
+	if err != nil {
+		return err
+	}
+	p := parser{}
+	p.Reset(b)
+	dec := decoder{}
+	return dec.FromParser(&p, v)
+}
+
+type decoder struct {
+	// Tracks position in Go arrays.
+	arrayIndexes map[reflect.Value]int
+
+	// Tracks keys that have been seen, with which type.
+	seen tracker.Seen
+}
+
+func (d *decoder) arrayIndex(append bool, v reflect.Value) int {
+	if d.arrayIndexes == nil {
+		d.arrayIndexes = make(map[reflect.Value]int, 1)
+	}
+
+	idx, ok := d.arrayIndexes[v]
+
+	if !ok {
+		d.arrayIndexes[v] = 0
+	} else if append {
+		idx++
+		d.arrayIndexes[v] = idx
+	}
+	return idx
+}
+
+func (d *decoder) FromParser(p *parser, v interface{}) error {
+	err := d.fromParser(p, v)
+	if err != nil {
+		de, ok := err.(*decodeError)
+		if ok {
+			err = wrapDecodeError(p.data, de)
+		}
+	}
+	return err
+}
+
+func (d *decoder) fromParser(p *parser, v interface{}) error {
+	r := reflect.ValueOf(v)
+	if r.Kind() != reflect.Ptr {
+		return fmt.Errorf("need to target a pointer, not %s", r.Kind())
+	}
+	if r.IsNil() {
+		return fmt.Errorf("target pointer must be non-nil")
+	}
+
+	var skipUntilTable bool
+	var root target = valueTarget(r.Elem())
+	current := root
+
+	for p.NextExpression() {
+		node := p.Expression()
+
+		if node.Kind == ast.KeyValue && skipUntilTable {
+			continue
+		}
+
+		err := d.seen.CheckExpression(node)
+		if err != nil {
+			return err
+		}
+
+		var found bool
+		switch node.Kind {
+		case ast.KeyValue:
+			err = d.unmarshalKeyValue(current, node)
+			found = true
+		case ast.Table:
+			current, found, err = d.scopeWithKey(root, node.Key())
+			if err == nil && found {
+				// In case this table points to an interface,
+				// make sure it at least holds something that
+				// looks like a table. Otherwise the information
+				// of a table is lost, and marshal cannot do the
+				// round trip.
+				ensureMapIfInterface(current)
+			}
+		case ast.ArrayTable:
+			current, found, err = d.scopeWithArrayTable(root, node.Key())
+		default:
+			panic(fmt.Errorf("this should not be a top level node type: %s", node.Kind))
+		}
+
+		if err != nil {
+			return err
+		}
+
+		if !found {
+			skipUntilTable = true
+		}
+	}
+
+	return p.Error()
+}
+
+// scopeWithKey performs target scoping when unmarshaling an ast.KeyValue node.
+//
+// The goal is to hop from target to target recursively using the names in key.
+// Parts of the key should be used to resolve field names for structs, and as
+// keys when targeting maps.
+//
+// When encountering slices, it should always use its last element, and error
+// if the slice does not have any.
+func (d *decoder) scopeWithKey(x target, key ast.Iterator) (target, bool, error) {
+	var err error
+	found := true
+
+	for key.Next() {
+		n := key.Node()
+		x, found, err = d.scopeTableTarget(false, x, string(n.Data))
+		if err != nil || !found {
+			return nil, found, err
+		}
+	}
+	return x, true, nil
+}
+
+// scopeWithArrayTable performs target scoping when unmarshaling an
+// ast.ArrayTable node.
+//
+// It is the same as scopeWithKey, but when scoping the last part of the key
+// it creates a new element in the array instead of using the last one.
+func (d *decoder) scopeWithArrayTable(x target, key ast.Iterator) (target, bool, error) {
+	var err error
+	found := true
+	for key.Next() {
+		n := key.Node()
+		if !n.Next().Valid() { // want to stop at one before last
+			break
+		}
+		x, found, err = d.scopeTableTarget(false, x, string(n.Data))
+		if err != nil || !found {
+			return nil, found, err
+		}
+	}
+	n := key.Node()
+	x, found, err = d.scopeTableTarget(false, x, string(n.Data))
+	if err != nil || !found {
+		return x, found, err
+	}
+
+	v := x.get()
+
+	if v.Kind() == reflect.Ptr {
+		x, err = scopePtr(x)
+		if err != nil {
+			return x, false, err
+		}
+		v = x.get()
+	}
+
+	if v.Kind() == reflect.Interface {
+		x, err = scopeInterface(true, x)
+		if err != nil {
+			return x, found, err
+		}
+		v = x.get()
+	}
+
+	switch v.Kind() {
+	case reflect.Slice:
+		x, err = scopeSlice(true, x)
+	case reflect.Array:
+		x, err = d.scopeArray(true, x)
+	}
+
+	return x, found, err
+}
+
+func (d *decoder) unmarshalKeyValue(x target, node ast.Node) error {
+	assertNode(ast.KeyValue, node)
+
+	x, found, err := d.scopeWithKey(x, node.Key())
+	if err != nil {
+		return err
+	}
+
+	// A struct in the path was not found. Skip this value.
+	if !found {
+		return nil
+	}
+
+	return d.unmarshalValue(x, node.Value())
+}
+
+var textUnmarshalerType = reflect.TypeOf(new(encoding.TextUnmarshaler)).Elem()
+
+func tryTextUnmarshaler(x target, node ast.Node) (bool, error) {
+	v := x.get()
+
+	if v.Kind() != reflect.Struct {
+		return false, nil
+	}
+
+	// Special case for time, becase we allow to unmarshal to it from
+	// different kind of AST nodes.
+	if v.Type() == timeType {
+		return false, nil
+	}
+
+	if v.Type().Implements(textUnmarshalerType) {
+		return true, v.Interface().(encoding.TextUnmarshaler).UnmarshalText(node.Data)
+	}
+	if v.CanAddr() && v.Addr().Type().Implements(textUnmarshalerType) {
+		return true, v.Addr().Interface().(encoding.TextUnmarshaler).UnmarshalText(node.Data)
+	}
+	return false, nil
+}
+
+func (d *decoder) unmarshalValue(x target, node ast.Node) error {
+	v := x.get()
+	if v.Kind() == reflect.Ptr {
+		if !v.Elem().IsValid() {
+			err := x.set(reflect.New(v.Type().Elem()))
+			if err != nil {
+				return err
+			}
+			v = x.get()
+		}
+		return d.unmarshalValue(valueTarget(v.Elem()), node)
+	}
+
+	ok, err := tryTextUnmarshaler(x, node)
+	if ok {
+		return err
+	}
+
+	switch node.Kind {
+	case ast.String:
+		return unmarshalString(x, node)
+	case ast.Bool:
+		return unmarshalBool(x, node)
+	case ast.Integer:
+		return unmarshalInteger(x, node)
+	case ast.Float:
+		return unmarshalFloat(x, node)
+	case ast.Array:
+		return d.unmarshalArray(x, node)
+	case ast.InlineTable:
+		return d.unmarshalInlineTable(x, node)
+	case ast.LocalDateTime:
+		return unmarshalLocalDateTime(x, node)
+	case ast.DateTime:
+		return unmarshalDateTime(x, node)
+	case ast.LocalDate:
+		return unmarshalLocalDate(x, node)
+	default:
+		panic(fmt.Errorf("unhandled unmarshalValue kind %s", node.Kind))
+	}
+}
+
+func unmarshalLocalDate(x target, node ast.Node) error {
+	assertNode(ast.LocalDate, node)
+	v, err := parseLocalDate(node.Data)
+	if err != nil {
+		return err
+	}
+	return setDate(x, v)
+}
+
+func unmarshalLocalDateTime(x target, node ast.Node) error {
+	assertNode(ast.LocalDateTime, node)
+	v, rest, err := parseLocalDateTime(node.Data)
+	if err != nil {
+		return err
+	}
+	if len(rest) > 0 {
+		return newDecodeError(rest, "extra characters at the end of a local date time")
+	}
+	return setLocalDateTime(x, v)
+}
+
+func unmarshalDateTime(x target, node ast.Node) error {
+	assertNode(ast.DateTime, node)
+	v, err := parseDateTime(node.Data)
+	if err != nil {
+		return err
+	}
+	return setDateTime(x, v)
+}
+
+func setLocalDateTime(x target, v LocalDateTime) error {
+	return x.set(reflect.ValueOf(v))
+}
+
+func setDateTime(x target, v time.Time) error {
+	return x.set(reflect.ValueOf(v))
+}
+
+var timeType = reflect.TypeOf(time.Time{})
+
+func setDate(x target, v LocalDate) error {
+	if x.get().Type() == timeType {
+		cast := v.In(time.Local)
+		return setDateTime(x, cast)
+	}
+
+	return x.set(reflect.ValueOf(v))
+}
+
+func unmarshalString(x target, node ast.Node) error {
+	assertNode(ast.String, node)
+	return setString(x, string(node.Data))
+}
+
+func unmarshalBool(x target, node ast.Node) error {
+	assertNode(ast.Bool, node)
+	v := node.Data[0] == 't'
+	return setBool(x, v)
+}
+
+func unmarshalInteger(x target, node ast.Node) error {
+	assertNode(ast.Integer, node)
+	v, err := parseInteger(node.Data)
+	if err != nil {
+		return err
+	}
+	return setInt64(x, v)
+}
+
+func unmarshalFloat(x target, node ast.Node) error {
+	assertNode(ast.Float, node)
+	v, err := parseFloat(node.Data)
+	if err != nil {
+		return err
+	}
+	return setFloat64(x, v)
+}
+
+func (d *decoder) unmarshalInlineTable(x target, node ast.Node) error {
+	assertNode(ast.InlineTable, node)
+
+	ensureMapIfInterface(x)
+
+	it := node.Children()
+	for it.Next() {
+		n := it.Node()
+		err := d.unmarshalKeyValue(x, n)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (d *decoder) unmarshalArray(x target, node ast.Node) error {
+	assertNode(ast.Array, node)
+
+	err := ensureValueIndexable(x)
+	if err != nil {
+		return err
+	}
+
+	it := node.Children()
+	idx := 0
+	for it.Next() {
+		n := it.Node()
+		v, err := elementAt(x, idx)
+		if err != nil {
+			return err
+		}
+		if v == nil {
+			// when we go out of bound for an array just stop processing it to
+			// mimic encoding/json
+			break
+		}
+		err = d.unmarshalValue(v, n)
+		if err != nil {
+			return err
+		}
+		idx++
+	}
+	return nil
+}
+
+func assertNode(expected ast.Kind, node ast.Node) {
+	if node.Kind != expected {
+		panic(fmt.Errorf("expected node of kind %s, not %s", expected, node.Kind))
+	}
+}

unmarshaler_test.go

@@ -0,0 +1,926 @@
+package toml_test
+
+import (
+	"math"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/pelletier/go-toml/v2"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestUnmarshal_Integers(t *testing.T) {
+	examples := []struct {
+		desc     string
+		input    string
+		expected int64
+		err      bool
+	}{
+		{
+			desc:     "integer just digits",
+			input:    `1234`,
+			expected: 1234,
+		},
+		{
+			desc:     "integer zero",
+			input:    `0`,
+			expected: 0,
+		},
+		{
+			desc:     "integer sign",
+			input:    `+99`,
+			expected: 99,
+		},
+		{
+			desc:     "integer hex uppercase",
+			input:    `0xDEADBEEF`,
+			expected: 0xDEADBEEF,
+		},
+		{
+			desc:     "integer hex lowercase",
+			input:    `0xdead_beef`,
+			expected: 0xDEADBEEF,
+		},
+		{
+			desc:     "integer octal",
+			input:    `0o01234567`,
+			expected: 0o01234567,
+		},
+		{
+			desc:     "integer binary",
+			input:    `0b11010110`,
+			expected: 0b11010110,
+		},
+	}
+
+	type doc struct {
+		A int64
+	}
+
+	for _, e := range examples {
+		t.Run(e.desc, func(t *testing.T) {
+			doc := doc{}
+			err := toml.Unmarshal([]byte(`A = `+e.input), &doc)
+			require.NoError(t, err)
+			assert.Equal(t, e.expected, doc.A)
+		})
+	}
+}
+
+func TestUnmarshal_Floats(t *testing.T) {
+	examples := []struct {
+		desc     string
+		input    string
+		expected float64
+		testFn   func(t *testing.T, v float64)
+		err      bool
+	}{
+
+		{
+			desc:     "float pi",
+			input:    `3.1415`,
+			expected: 3.1415,
+		},
+		{
+			desc:     "float negative",
+			input:    `-0.01`,
+			expected: -0.01,
+		},
+		{
+			desc:     "float signed exponent",
+			input:    `5e+22`,
+			expected: 5e+22,
+		},
+		{
+			desc:     "float exponent lowercase",
+			input:    `1e06`,
+			expected: 1e06,
+		},
+		{
+			desc:     "float exponent uppercase",
+			input:    `-2E-2`,
+			expected: -2e-2,
+		},
+		{
+			desc:     "float fractional with exponent",
+			input:    `6.626e-34`,
+			expected: 6.626e-34,
+		},
+		{
+			desc:     "float underscores",
+			input:    `224_617.445_991_228`,
+			expected: 224_617.445_991_228,
+		},
+		{
+			desc:     "inf",
+			input:    `inf`,
+			expected: math.Inf(+1),
+		},
+		{
+			desc:     "inf negative",
+			input:    `-inf`,
+			expected: math.Inf(-1),
+		},
+		{
+			desc:     "inf positive",
+			input:    `+inf`,
+			expected: math.Inf(+1),
+		},
+		{
+			desc:  "nan",
+			input: `nan`,
+			testFn: func(t *testing.T, v float64) {
+				assert.True(t, math.IsNaN(v))
+			},
+		},
+		{
+			desc:  "nan negative",
+			input: `-nan`,
+			testFn: func(t *testing.T, v float64) {
+				assert.True(t, math.IsNaN(v))
+			},
+		},
+		{
+			desc:  "nan positive",
+			input: `+nan`,
+			testFn: func(t *testing.T, v float64) {
+				assert.True(t, math.IsNaN(v))
+			},
+		},
+	}
+
+	type doc struct {
+		A float64
+	}
+
+	for _, e := range examples {
+		t.Run(e.desc, func(t *testing.T) {
+			doc := doc{}
+			err := toml.Unmarshal([]byte(`A = `+e.input), &doc)
+			require.NoError(t, err)
+			if e.testFn != nil {
+				e.testFn(t, doc.A)
+			} else {
+				assert.Equal(t, e.expected, doc.A)
+			}
+		})
+	}
+}
+
+func TestUnmarshal(t *testing.T) {
+	type test struct {
+		target   interface{}
+		expected interface{}
+		err      bool
+	}
+	examples := []struct {
+		skip  bool
+		desc  string
+		input string
+		gen   func() test
+	}{
+		{
+			desc:  "kv string",
+			input: `A = "foo"`,
+			gen: func() test {
+				type doc struct {
+					A string
+				}
+				return test{
+					target:   &doc{},
+					expected: &doc{A: "foo"},
+				}
+			},
+		},
+		{
+			desc: "issue 475 - space between dots in key",
+			input: `fruit. color = "yellow"
+					fruit . flavor = "banana"`,
+			gen: func() test {
+				m := map[string]interface{}{}
+				return test{
+					target: &m,
+					expected: &map[string]interface{}{
+						"fruit": map[string]interface{}{
+							"color":  "yellow",
+							"flavor": "banana",
+						},
+					},
+				}
+			},
+		},
+		{
+			desc: "issue 427 - quotation marks in key",
+			input: `'"a"' = 1
+					"\"b\"" = 2`,
+			gen: func() test {
+				m := map[string]interface{}{}
+				return test{
+					target: &m,
+					expected: &map[string]interface{}{
+						`"a"`: int64(1),
+						`"b"`: int64(2),
+					},
+				}
+			},
+		},
+		{
+			desc: "multiline basic string",
+			input: `A = """\
+					Test"""`,
+			gen: func() test {
+				type doc struct {
+					A string
+				}
+				return test{
+					target:   &doc{},
+					expected: &doc{A: "Test"},
+				}
+			},
+		},
+		{
+			desc:  "kv bool true",
+			input: `A = true`,
+			gen: func() test {
+				type doc struct {
+					A bool
+				}
+				return test{
+					target:   &doc{},
+					expected: &doc{A: true},
+				}
+			},
+		},
+		{
+			desc:  "kv bool false",
+			input: `A = false`,
+			gen: func() test {
+				type doc struct {
+					A bool
+				}
+				return test{
+					target:   &doc{A: true},
+					expected: &doc{A: false},
+				}
+			},
+		},
+		{
+			desc:  "string array",
+			input: `A = ["foo", "bar"]`,
+			gen: func() test {
+				type doc struct {
+					A []string
+				}
+				return test{
+					target:   &doc{},
+					expected: &doc{A: []string{"foo", "bar"}},
+				}
+			},
+		},
+		{
+			desc: "standard table",
+			input: `[A]
+B = "data"`,
+			gen: func() test {
+				type A struct {
+					B string
+				}
+				type doc struct {
+					A A
+				}
+				return test{
+					target:   &doc{},
+					expected: &doc{A: A{B: "data"}},
+				}
+			},
+		},
+		{
+			desc:  "standard empty table",
+			input: `[A]`,
+			gen: func() test {
+				var v map[string]interface{}
+				return test{
+					target:   &v,
+					expected: &map[string]interface{}{`A`: map[string]interface{}{}},
+				}
+			},
+		},
+		{
+			desc:  "inline table",
+			input: `Name = {First = "hello", Last = "world"}`,
+			gen: func() test {
+				type name struct {
+					First string
+					Last  string
+				}
+				type doc struct {
+					Name name
+				}
+				return test{
+					target: &doc{},
+					expected: &doc{Name: name{
+						First: "hello",
+						Last:  "world",
+					}},
+				}
+			},
+		},
+		{
+			desc:  "inline empty table",
+			input: `A = {}`,
+			gen: func() test {
+				var v map[string]interface{}
+				return test{
+					target:   &v,
+					expected: &map[string]interface{}{`A`: map[string]interface{}{}},
+				}
+			},
+		},
+		{
+			desc:  "inline table inside array",
+			input: `Names = [{First = "hello", Last = "world"}, {First = "ab", Last = "cd"}]`,
+			gen: func() test {
+				type name struct {
+					First string
+					Last  string
+				}
+				type doc struct {
+					Names []name
+				}
+				return test{
+					target: &doc{},
+					expected: &doc{
+						Names: []name{
+							{
+								First: "hello",
+								Last:  "world",
+							},
+							{
+								First: "ab",
+								Last:  "cd",
+							},
+						},
+					},
+				}
+			},
+		},
+		{
+			desc:  "into map[string]interface{}",
+			input: `A = "foo"`,
+			gen: func() test {
+				doc := map[string]interface{}{}
+				return test{
+					target: &doc,
+					expected: &map[string]interface{}{
+						"A": "foo",
+					},
+				}
+			},
+		},
+		{
+			desc: "multi keys of different types into map[string]interface{}",
+			input: `A = "foo"
+					B = 42`,
+			gen: func() test {
+				doc := map[string]interface{}{}
+				return test{
+					target: &doc,
+					expected: &map[string]interface{}{
+						"A": "foo",
+						"B": int64(42),
+					},
+				}
+			},
+		},
+		{
+			desc:  "slice in a map[string]interface{}",
+			input: `A = ["foo", "bar"]`,
+			gen: func() test {
+				doc := map[string]interface{}{}
+				return test{
+					target: &doc,
+					expected: &map[string]interface{}{
+						"A": []interface{}{"foo", "bar"},
+					},
+				}
+			},
+		},
+		{
+			desc:  "string into map[string]string",
+			input: `A = "foo"`,
+			gen: func() test {
+				doc := map[string]string{}
+				return test{
+					target: &doc,
+					expected: &map[string]string{
+						"A": "foo",
+					},
+				}
+			},
+		},
+		{
+			desc:  "float64 into map[string]string",
+			input: `A = 42.0`,
+			gen: func() test {
+				doc := map[string]string{}
+				return test{
+					target: &doc,
+					err:    true,
+				}
+			},
+		},
+		{
+			desc: "one-level one-element array table",
+			input: `[[First]]
+					Second = "hello"`,
+			gen: func() test {
+				type First struct {
+					Second string
+				}
+				type Doc struct {
+					First []First
+				}
+				return test{
+					target: &Doc{},
+					expected: &Doc{
+						First: []First{
+							{
+								Second: "hello",
+							},
+						},
+					},
+				}
+			},
+		},
+		{
+			desc: "one-level multi-element array table",
+			input: `[[Products]]
+					Name = "Hammer"
+					Sku = 738594937
+					
+					[[Products]]  # empty table within the array
+					
+					[[Products]]
+					Name = "Nail"
+					Sku = 284758393
+					
+					Color = "gray"`,
+			gen: func() test {
+				type Product struct {
+					Name  string
+					Sku   int64
+					Color string
+				}
+				type Doc struct {
+					Products []Product
+				}
+				return test{
+					target: &Doc{},
+					expected: &Doc{
+						Products: []Product{
+							{Name: "Hammer", Sku: 738594937},
+							{},
+							{Name: "Nail", Sku: 284758393, Color: "gray"},
+						},
+					},
+				}
+			},
+		},
+		{
+			desc: "one-level multi-element array table to map",
+			input: `[[Products]]
+					Name = "Hammer"
+					Sku = 738594937
+					
+					[[Products]]  # empty table within the array
+					
+					[[Products]]
+					Name = "Nail"
+					Sku = 284758393
+					
+					Color = "gray"`,
+			gen: func() test {
+				return test{
+					target: &map[string]interface{}{},
+					expected: &map[string]interface{}{
+						"Products": []interface{}{
+							map[string]interface{}{
+								"Name": "Hammer",
+								"Sku":  int64(738594937),
+							},
+							nil,
+							map[string]interface{}{
+								"Name":  "Nail",
+								"Sku":   int64(284758393),
+								"Color": "gray",
+							},
+						},
+					},
+				}
+			},
+		},
+		{
+			desc: "sub-table in array table",
+			input: `[[Fruits]]
+					Name = "apple"
+
+					[Fruits.Physical]  # subtable
+					Color = "red"
+					Shape = "round"`,
+			gen: func() test {
+				return test{
+					target: &map[string]interface{}{},
+					expected: &map[string]interface{}{
+						"Fruits": []interface{}{
+							map[string]interface{}{
+								"Name": "apple",
+								"Physical": map[string]interface{}{
+									"Color": "red",
+									"Shape": "round",
+								},
+							},
+						},
+					},
+				}
+			},
+		},
+		{
+			desc: "multiple sub-table in array tables",
+			input: `[[Fruits]]
+					Name = "apple"
+
+					[[Fruits.Varieties]]  # nested array of tables
+					Name = "red delicious"
+
+					[[Fruits.Varieties]]
+					Name = "granny smith"
+
+					[[Fruits]]
+					Name = "banana"
+
+					[[Fruits.Varieties]]
+					Name = "plantain"`,
+			gen: func() test {
+				return test{
+					target: &map[string]interface{}{},
+					expected: &map[string]interface{}{
+						"Fruits": []interface{}{
+							map[string]interface{}{
+								"Name": "apple",
+								"Varieties": []interface{}{
+									map[string]interface{}{
+										"Name": "red delicious",
+									},
+									map[string]interface{}{
+										"Name": "granny smith",
+									},
+								},
+							},
+							map[string]interface{}{
+								"Name": "banana",
+								"Varieties": []interface{}{
+									map[string]interface{}{
+										"Name": "plantain",
+									},
+								},
+							},
+						},
+					},
+				}
+			},
+		},
+		{
+			desc: "multiple sub-table in array tables into structs",
+			input: `[[Fruits]]
+					Name = "apple"
+
+					[[Fruits.Varieties]]  # nested array of tables
+					Name = "red delicious"
+
+					[[Fruits.Varieties]]
+					Name = "granny smith"
+
+					[[Fruits]]
+					Name = "banana"
+
+					[[Fruits.Varieties]]
+					Name = "plantain"`,
+			gen: func() test {
+				type Variety struct {
+					Name string
+				}
+				type Fruit struct {
+					Name      string
+					Varieties []Variety
+				}
+				type doc struct {
+					Fruits []Fruit
+				}
+
+				return test{
+					target: &doc{},
+					expected: &doc{
+						Fruits: []Fruit{
+							{
+								Name: "apple",
+								Varieties: []Variety{
+									{Name: "red delicious"},
+									{Name: "granny smith"},
+								},
+							},
+							{
+								Name: "banana",
+								Varieties: []Variety{
+									{Name: "plantain"},
+								},
+							},
+						},
+					},
+				}
+			},
+		},
+		{
+			desc:  "slice pointer in slice pointer",
+			input: `A = ["Hello"]`,
+			gen: func() test {
+				type doc struct {
+					A *[]*string
+				}
+				hello := "Hello"
+				return test{
+					target: &doc{},
+					expected: &doc{
+						A: &[]*string{&hello},
+					},
+				}
+			},
+		},
+		{
+			desc: "interface holding a struct",
+			input: `[A]
+					B = "After"`,
+			gen: func() test {
+				type inner struct {
+					B interface{}
+				}
+				type doc struct {
+					A interface{}
+				}
+				return test{
+					target: &doc{
+						A: inner{
+							B: "Before",
+						},
+					},
+					expected: &doc{
+						A: map[string]interface{}{
+							"B": "After",
+						},
+					},
+				}
+			},
+		},
+		{
+			desc: "array of structs with table arrays",
+			input: `[[A]]
+			B = "one"
+			[[A]]
+			B = "two"`,
+			gen: func() test {
+				type inner struct {
+					B string
+				}
+				type doc struct {
+					A [4]inner
+				}
+				return test{
+					target: &doc{},
+					expected: &doc{
+						A: [4]inner{
+							{B: "one"},
+							{B: "two"},
+						},
+					},
+				}
+			},
+		},
+	}
+
+	for _, e := range examples {
+		t.Run(e.desc, func(t *testing.T) {
+			if e.skip {
+				t.Skip()
+			}
+			test := e.gen()
+			if test.err && test.expected != nil {
+				panic("invalid test: cannot expect both an error and a value")
+			}
+			err := toml.Unmarshal([]byte(e.input), test.target)
+			if test.err {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, test.expected, test.target)
+			}
+		})
+	}
+}
+
+type Integer484 struct {
+	Value int
+}
+
+func (i Integer484) MarshalText() ([]byte, error) {
+	return []byte(strconv.Itoa(i.Value)), nil
+}
+
+func (i *Integer484) UnmarshalText(data []byte) error {
+	conv, err := strconv.Atoi(string(data))
+	if err != nil {
+		return err
+	}
+	i.Value = conv
+	return nil
+}
+
+type Config484 struct {
+	Integers []Integer484 `toml:"integers"`
+}
+
+func TestIssue484(t *testing.T) {
+	raw := []byte(`integers = ["1","2","3","100"]`)
+	var cfg Config484
+	err := toml.Unmarshal(raw, &cfg)
+	require.NoError(t, err)
+	assert.Equal(t, Config484{
+		Integers: []Integer484{{1}, {2}, {3}, {100}},
+	}, cfg)
+}
+
+type Map458 map[string]interface{}
+type Slice458 []interface{}
+
+func (m Map458) A(s string) Slice458 {
+	return m[s].([]interface{})
+}
+
+func TestIssue458(t *testing.T) {
+	s := []byte(`[[package]]
+dependencies = ["regex"]
+name = "decode"
+version = "0.1.0"`)
+	m := Map458{}
+	err := toml.Unmarshal(s, &m)
+	require.NoError(t, err)
+	a := m.A("package")
+	expected := Slice458{
+		map[string]interface{}{
+			"dependencies": []interface{}{"regex"},
+			"name":         "decode",
+			"version":      "0.1.0"},
+	}
+	assert.Equal(t, expected, a)
+}
+
+func TestIssue252(t *testing.T) {
+	type config struct {
+		Val1 string `toml:"val1"`
+		Val2 string `toml:"val2"`
+	}
+
+	var configFile = []byte(
+		`
+val1 = "test1"
+`)
+
+	cfg := &config{
+		Val2: "test2",
+	}
+
+	err := toml.Unmarshal(configFile, cfg)
+	require.NoError(t, err)
+	require.Equal(t, "test2", cfg.Val2)
+}
+
+func TestIssue494(t *testing.T) {
+	data := `
+foo = 2021-04-08
+bar = 2021-04-08
+`
+	type s struct {
+		Foo time.Time `toml:"foo"`
+		Bar time.Time `toml:"bar"`
+	}
+	ss := new(s)
+	err := toml.Unmarshal([]byte(data), ss)
+	require.NoError(t, err)
+}
+
+func TestUnmarshalDecodeErrors(t *testing.T) {
+	examples := []struct {
+		desc string
+		data string
+		msg  string
+	}{
+		{
+			desc: "int with wrong base",
+			data: `a = 0f2`,
+		},
+		{
+			desc: "literal string with new lines",
+			data: `a = 'hello
+world'`,
+			msg: `literal strings cannot have new lines`,
+		},
+		{
+			desc: "unterminated literal string",
+			data: `a = 'hello`,
+			msg:  `unterminated literal string`,
+		},
+		{
+			desc: "unterminated multiline literal string",
+			data: `a = '''hello`,
+			msg:  `multiline literal string not terminated by '''`,
+		},
+		{
+			desc: "basic string with new lines",
+			data: `a = "hello
+"`,
+			msg: `basic strings cannot have new lines`,
+		},
+		{
+			desc: "basic string with unfinished escape",
+			data: `a = "hello \`,
+			msg:  `need a character after \`,
+		},
+		{
+			desc: "basic unfinished multiline string",
+			data: `a = """hello`,
+			msg:  `multiline basic string not terminated by """`,
+		},
+		{
+			desc: "basic unfinished escape in multiline string",
+			data: `a = """hello \`,
+			msg:  `need a character after \`,
+		},
+		{
+			desc: "malformed local date",
+			data: `a = 2021-033-0`,
+			msg:  `dates are expected to have the format YYYY-MM-DD`,
+		},
+		{
+			desc: "malformed tz",
+			data: `a = 2021-03-30 21:31:00+1`,
+			msg:  `invalid date-time timezone`,
+		},
+		{
+			desc: "malformed tz first char",
+			data: `a = 2021-03-30 21:31:00:1`,
+			msg:  `extra characters at the end of a local date time`,
+		},
+		{
+			desc: "bad char between hours and minutes",
+			data: `a = 2021-03-30 213:1:00`,
+			msg:  `expecting colon between hours and minutes`,
+		},
+		{
+			desc: "bad char between minutes and seconds",
+			data: `a = 2021-03-30 21:312:0`,
+			msg:  `expecting colon between minutes and seconds`,
+		},
+	}
+
+	for _, e := range examples {
+		t.Run(e.desc, func(t *testing.T) {
+			m := map[string]interface{}{}
+			err := toml.Unmarshal([]byte(e.data), &m)
+			require.Error(t, err)
+			de, ok := err.(*toml.DecodeError)
+			if !ok {
+				t.Fatalf("err should have been a *toml.DecodeError, but got %s (%T)", err, err)
+			}
+			if e.msg != "" {
+				t.Log("\n" + de.String())
+				require.Equal(t, e.msg, de.Error())
+			}
+		})
+	}
+}
+
+func TestIssue287(t *testing.T) {
+	b := `y=[[{}]]`
+	v := map[string]interface{}{}
+	err := toml.Unmarshal([]byte(b), &v)
+	require.NoError(t, err)
+
+	expected := map[string]interface{}{
+		"y": []interface{}{
+			[]interface{}{
+				map[string]interface{}{},
+			},
+		},
+	}
+	require.Equal(t, expected, v)
+}