Keep separate fn for []interface{} unmarshal

```
name                               old time/op    new time/op    delta
UnmarshalDataset/config-2            24.9ms ± 0%    24.6ms ± 0%  -1.09%  (p=0.029 n=4+4)
UnmarshalDataset/canada-2            61.7ms ± 1%    62.1ms ± 3%    ~     (p=1.000 n=5+5)
UnmarshalDataset/citm_catalog-2      24.7ms ± 1%    24.2ms ± 0%  -2.30%  (p=0.008 n=5+5)
UnmarshalDataset/twitter-2           10.9ms ± 2%    10.7ms ± 1%  -1.46%  (p=0.008 n=5+5)
UnmarshalDataset/code-2               108ms ± 0%     106ms ± 0%  -1.91%  (p=0.008 n=5+5)
UnmarshalDataset/example-2            176µs ± 0%     173µs ± 0%  -1.83%  (p=0.008 n=5+5)
Unmarshal/SimpleDocument/struct-2     586ns ± 1%     587ns ± 0%    ~     (p=0.690 n=5+5)
Unmarshal/SimpleDocument/map-2        876ns ± 0%     872ns ± 0%    ~     (p=0.095 n=5+5)
Unmarshal/ReferenceFile/struct-2     49.5µs ± 0%    49.5µs ± 0%    ~     (p=0.222 n=5+5)
Unmarshal/ReferenceFile/map-2        79.6µs ± 0%    79.1µs ± 0%  -0.62%  (p=0.008 n=5+5)
Unmarshal/HugoFrontMatter-2          13.7µs ± 0%    13.5µs ± 0%  -0.91%  (p=0.008 n=5+5)

name                               old speed      new speed      delta
UnmarshalDataset/config-2          42.2MB/s ± 0%  42.7MB/s ± 0%  +1.10%  (p=0.029 n=4+4)
UnmarshalDataset/canada-2          35.7MB/s ± 1%  35.5MB/s ± 3%    ~     (p=1.000 n=5+5)
UnmarshalDataset/citm_catalog-2    22.6MB/s ± 1%  23.1MB/s ± 0%  +2.36%  (p=0.008 n=5+5)
UnmarshalDataset/twitter-2         40.6MB/s ± 2%  41.2MB/s ± 1%  +1.47%  (p=0.008 n=5+5)
UnmarshalDataset/code-2            24.9MB/s ± 0%  25.4MB/s ± 0%  +1.95%  (p=0.008 n=5+5)
UnmarshalDataset/example-2         46.0MB/s ± 0%  46.9MB/s ± 0%  +1.86%  (p=0.008 n=5+5)
Unmarshal/SimpleDocument/struct-2  18.8MB/s ± 1%  18.7MB/s ± 0%    ~     (p=0.651 n=5+5)
Unmarshal/SimpleDocument/map-2     12.6MB/s ± 0%  12.6MB/s ± 0%    ~     (p=0.087 n=5+5)
Unmarshal/ReferenceFile/struct-2    106MB/s ± 0%   106MB/s ± 0%    ~     (p=0.222 n=5+5)
Unmarshal/ReferenceFile/map-2      65.8MB/s ± 0%  66.2MB/s ± 0%  +0.63%  (p=0.008 n=5+5)
Unmarshal/HugoFrontMatter-2        40.0MB/s ± 0%  40.3MB/s ± 0%  +0.92%  (p=0.008 n=5+5)

name                               old alloc/op   new alloc/op   delta
UnmarshalDataset/config-2            5.85MB ± 0%    5.85MB ± 0%    ~     (p=1.000 n=5+5)
UnmarshalDataset/canada-2            75.2MB ± 0%    75.2MB ± 0%    ~     (p=1.000 n=5+5)
UnmarshalDataset/citm_catalog-2      35.0MB ± 0%    35.0MB ± 0%    ~     (p=0.841 n=5+5)
UnmarshalDataset/twitter-2           13.5MB ± 0%    13.5MB ± 0%    ~     (p=0.548 n=5+5)
UnmarshalDataset/code-2              22.0MB ± 0%    22.0MB ± 0%    ~     (p=0.738 n=5+5)
UnmarshalDataset/example-2            203kB ± 0%     203kB ± 0%    ~     (p=0.714 n=5+5)
Unmarshal/SimpleDocument/struct-2      709B ± 0%      709B ± 0%    ~     (all equal)
Unmarshal/SimpleDocument/map-2       1.08kB ± 0%    1.08kB ± 0%    ~     (all equal)
Unmarshal/ReferenceFile/struct-2     19.7kB ± 0%    19.7kB ± 0%    ~     (all equal)
Unmarshal/ReferenceFile/map-2        37.0kB ± 0%    37.0kB ± 0%    ~     (p=0.333 n=4+5)
Unmarshal/HugoFrontMatter-2          7.22kB ± 0%    7.22kB ± 0%    ~     (all equal)

name                               old allocs/op  new allocs/op  delta
UnmarshalDataset/config-2              230k ± 0%      230k ± 0%    ~     (p=0.556 n=4+5)
UnmarshalDataset/canada-2              391k ± 0%      391k ± 0%    ~     (all equal)
UnmarshalDataset/citm_catalog-2        158k ± 0%      158k ± 0%    ~     (p=1.000 n=4+5)
UnmarshalDataset/twitter-2            54.7k ± 0%     54.7k ± 0%    ~     (p=1.000 n=4+5)
UnmarshalDataset/code-2               1.05M ± 0%     1.05M ± 0%    ~     (all equal)
UnmarshalDataset/example-2            1.28k ± 0%     1.28k ± 0%    ~     (all equal)
Unmarshal/SimpleDocument/struct-2      8.00 ± 0%      8.00 ± 0%    ~     (all equal)
Unmarshal/SimpleDocument/map-2         13.0 ± 0%      13.0 ± 0%    ~     (all equal)
Unmarshal/ReferenceFile/struct-2        123 ± 0%       123 ± 0%    ~     (all equal)
Unmarshal/ReferenceFile/map-2           590 ± 0%       590 ± 0%    ~     (all equal)
Unmarshal/HugoFrontMatter-2             130 ± 0%       130 ± 0%    ~     (all equal)
```

.gitattributes

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

.github/dependabot.yml

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

.github/release.yml

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

.github/workflows/coverage.yml

@@ -1,15 +1,12 @@
 name: coverage
 on:
-  push:
-    branches:
-      - v2
   pull_request:
     branches:
       - v2
 
 jobs:
   report:
-    runs-on: 'ubuntu-latest'
+    runs-on: "ubuntu-latest"
     name: report
     steps:
       - uses: actions/checkout@master

.github/workflows/workflow.yml

@@ -12,7 +12,7 @@ jobs:
     strategy:
       matrix:
         os: [ 'ubuntu-latest', 'windows-latest', 'macos-latest']
-        go: [ '1.15', '1.16' ]
+        go: [ '1.16', '1.17' ]
     runs-on: ${{ matrix.os }}
     name: ${{ matrix.go }}/${{ matrix.os }}
     steps:

.golangci.toml

@@ -60,7 +60,7 @@ enable = [
     # "nlreturn",
     "noctx",
     "nolintlint",
-    "paralleltest",
+    #"paralleltest",
     "prealloc",
     "predeclared",
     "revive",

README.md

@@ -4,7 +4,6 @@ Go library for the [TOML](https://toml.io/en/) format.
 
 This library supports [TOML v1.0.0](https://toml.io/en/v1.0.0).
 
-
 ## Development status
 
 This is the upcoming major version of go-toml. It is currently in active
@@ -14,8 +13,11 @@ with v1, and fixes a lot known bugs and performance issues along the way.
 If you do not need the advanced document editing features of v1, you are
 encouraged to try out this version.
 
-👉 [Roadmap for v2](https://github.com/pelletier/go-toml/discussions/506).
+[👉 Roadmap for v2](https://github.com/pelletier/go-toml/discussions/506)
 
+[🐞 Bug Reports](https://github.com/pelletier/go-toml/issues)
+
+[💬 Anything else](https://github.com/pelletier/go-toml/discussions)
 
 ## Documentation
 
@@ -23,13 +25,14 @@ Full API, examples, and implementation notes are available in the Go documentati
 
 [![Go Reference](https://pkg.go.dev/badge/github.com/pelletier/go-toml/v2.svg)](https://pkg.go.dev/github.com/pelletier/go-toml/v2)
 
-
 ## Import
 
 ```go
 import "github.com/pelletier/go-toml/v2"
 ```
 
+See [Modules](#Modules).
+
 ## Features
 
 ### Stdlib behavior
@@ -40,7 +43,7 @@ standard library's `encoding/json`.
 ### Performance
 
 While go-toml favors usability, it is written with performance in mind. Most
-operations should not be shockingly slow.
+operations should not be shockingly slow. See [benchmarks](#benchmarks).
 
 ### Strict mode
 
@@ -146,6 +149,63 @@ fmt.Println(string(b))
 
 [marshal]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#Marshal
 
+## Benchmarks
+
+Execution time speedup compared to other Go TOML libraries:
+
+<table>
+    <thead>
+        <tr><th>Benchmark</th><th>go-toml v1</th><th>BurntSushi/toml</th></tr>
+    </thead>
+    <tbody>
+        <tr><td>Marshal/HugoFrontMatter-2</td><td>1.9x</td><td>1.9x</td></tr>
+        <tr><td>Marshal/ReferenceFile/map-2</td><td>1.7x</td><td>1.9x</td></tr>
+        <tr><td>Marshal/ReferenceFile/struct-2</td><td>2.4x</td><td>2.6x</td></tr>
+        <tr><td>Unmarshal/HugoFrontMatter-2</td><td>2.9x</td><td>2.5x</td></tr>
+        <tr><td>Unmarshal/ReferenceFile/map-2</td><td>2.7x</td><td>2.6x</td></tr>
+        <tr><td>Unmarshal/ReferenceFile/struct-2</td><td>4.8x</td><td>5.1x</td></tr>
+     </tbody>
+</table>
+<details><summary>See more</summary>
+<p>The table above has the results of the most common use-cases. The table below
+contains the results of all benchmarks, including unrealistic ones. It is
+provided for completeness.</p>
+
+<table>
+    <thead>
+        <tr><th>Benchmark</th><th>go-toml v1</th><th>BurntSushi/toml</th></tr>
+    </thead>
+    <tbody>
+        <tr><td>Marshal/SimpleDocument/map-2</td><td>1.7x</td><td>2.1x</td></tr>
+        <tr><td>Marshal/SimpleDocument/struct-2</td><td>2.5x</td><td>2.8x</td></tr>
+        <tr><td>Unmarshal/SimpleDocument/map-2</td><td>4.1x</td><td>3.1x</td></tr>
+        <tr><td>Unmarshal/SimpleDocument/struct-2</td><td>6.4x</td><td>4.3x</td></tr>
+        <tr><td>UnmarshalDataset/example-2</td><td>3.4x</td><td>3.2x</td></tr>
+        <tr><td>UnmarshalDataset/code-2</td><td>2.2x</td><td>2.5x</td></tr>
+        <tr><td>UnmarshalDataset/twitter-2</td><td>2.8x</td><td>2.7x</td></tr>
+        <tr><td>UnmarshalDataset/citm_catalog-2</td><td>2.2x</td><td>2.0x</td></tr>
+        <tr><td>UnmarshalDataset/canada-2</td><td>1.8x</td><td>1.4x</td></tr>
+        <tr><td>UnmarshalDataset/config-2</td><td>4.4x</td><td>2.9x</td></tr>
+        <tr><td>[Geo mean]</td><td>2.8x</td><td>2.6x</td></tr>
+     </tbody>
+</table>
+<p>This table can be generated with <code>./ci.sh benchmark -a -html</code>.</p>
+</details>
+
+## Modules
+
+go-toml uses Go's standard modules system.
+
+Installation instructions:
+
+- Go ≥ 1.16: Nothing to do. Use the import in your code. The `go` command deals
+  with it automatically.
+- Go ≥ 1.13: `GO111MODULE=on go get github.com/pelletier/go-toml/v2`.
+
+In case of trouble: [Go Modules FAQ][mod-faq].
+
+[mod-faq]: https://github.com/golang/go/wiki/Modules#why-does-installing-a-tool-via-go-get-fail-with-error-cannot-find-main-module
+
 ## Migrating from v1
 
 This section describes the differences between v1 and v2, with some pointers on
@@ -187,7 +247,7 @@ d := doc{
 }
 
 data := `
-[A]                                                                                                                           
+[A]
 B = "After"
 `
 
@@ -248,6 +308,22 @@ This method was not widely used, poorly defined, and added a lot of complexity.
 A similar effect can be achieved by implementing the `encoding.TextUnmarshaler`
 interface and use strings.
 
+#### Support for `default` struct tag has been dropped
+
+This feature adds complexity and a poorly defined API for an effect that can be
+accomplished outside of the library.
+
+It does not seem like other format parsers in Go support that feature (the
+project referenced in the original ticket #202 has not been updated since 2017).
+Given that go-toml v2 should not touch values not in the document, the same
+effect can be achieved by pre-filling the struct with defaults (libraries like
+[go-defaults][go-defaults] can help). Also, string representation is not well
+defined for all types: it creates issues like #278.
+
+The recommended replacement is pre-filling the struct before unmarshaling.
+
+[go-defaults]: https://github.com/mcuadros/go-defaults
+
 ### Encoding / Marshal
 
 #### Default struct fields order
@@ -290,7 +366,6 @@ manually sort the fields alphabetically in the struct definition.
 V1 automatically indents content of tables by default. V2 does not. However the
 same behavior can be obtained using [`Encoder.SetIndentTables`][sit]. For example:
 
-
 ```go
 data := map[string]interface{}{
 	"table": map[string]string{
@@ -312,15 +387,15 @@ fmt.Println("v2 Encoder:\n" + string(buf.Bytes()))
 
 // Output:
 // v1:
-// 
+//
 // [table]
 //   key = "value"
-// 
+//
 // v2:
 // [table]
 // key = 'value'
-// 
-// 
+//
+//
 // v2 Encoder:
 // [table]
 //   key = 'value'

SECURITY.md

@@ -0,0 +1,19 @@
+# Security Policy
+
+## Supported Versions
+
+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
+| Version    | Supported          |
+| ---------- | ------------------ |
+| Latest 2.x | :white_check_mark: |
+| All 1.x    | :x:                |
+| All 0.x    | :x:                |
+
+## Reporting a Vulnerability
+
+Email a vulnerability report to `security@pelletier.codes`. Make sure to include
+as many details as possible to reproduce the vulnerability. This is a
+side-project: I will try to get back to you as quickly as possible, time
+permitting in my personal life. Providing a working patch helps very much!

benchmark/bench_datasets_test.go

@@ -31,13 +31,14 @@ var bench_inputs = []struct {
 
 func TestUnmarshalDatasetCode(t *testing.T) {
 	for _, tc := range bench_inputs {
-		buf := fixture(t, tc.name)
 		t.Run(tc.name, func(t *testing.T) {
+			buf := fixture(t, tc.name)
+
 			var v interface{}
-			check(t, toml.Unmarshal(buf, &v))
+			require.NoError(t, toml.Unmarshal(buf, &v))
 
 			b, err := json.Marshal(v)
-			check(t, err)
+			require.NoError(t, err)
 			require.Equal(t, len(b), tc.jsonLen)
 		})
 	}
@@ -45,14 +46,14 @@ func TestUnmarshalDatasetCode(t *testing.T) {
 
 func BenchmarkUnmarshalDataset(b *testing.B) {
 	for _, tc := range bench_inputs {
-		buf := fixture(b, tc.name)
 		b.Run(tc.name, func(b *testing.B) {
+			buf := fixture(b, tc.name)
 			b.SetBytes(int64(len(buf)))
 			b.ReportAllocs()
 			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
 				var v interface{}
-				check(b, toml.Unmarshal(buf, &v))
+				require.NoError(b, toml.Unmarshal(buf, &v))
 			}
 		})
 	}
@@ -60,22 +61,20 @@ func BenchmarkUnmarshalDataset(b *testing.B) {
 
 // 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)
+	tb.Helper()
+
+	file := path + ".toml.gz"
+	f, err := os.Open(filepath.Join("testdata", file))
+	if os.IsNotExist(err) {
+		tb.Skip("benchmark fixture not found:", file)
+	}
+	require.NoError(tb, err)
 	defer f.Close()
 
 	gz, err := gzip.NewReader(f)
-	check(tb, err)
+	require.NoError(tb, err)
 
 	buf, err := ioutil.ReadAll(gz)
-	check(tb, err)
-
+	require.NoError(tb, err)
 	return buf
 }
-
-func check(tb testing.TB, err error) {
-	if err != nil {
-		tb.Helper()
-		tb.Fatal(err)
-	}
-}

benchmark/benchmark.toml

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

benchmark/benchmark_test.go

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

benchmark_test.go

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

ci.sh

@@ -39,6 +39,12 @@ benchmark [OPTIONS...] [BRANCH]
         -d      Compare benchmarks of HEAD with BRANCH using benchstats. In
                 this form the BRANCH argument is required.
 
+        -a      Compare benchmarks of HEAD against go-toml v1 and
+                BurntSushi/toml.
+
+        -html   When used with -a, emits the output as HTML, ready to be
+                embedded in the README.
+
 coverage [OPTIONS...] [BRANCH]
 
     Generates code coverage.
@@ -118,6 +124,7 @@ coverage() {
 bench() {
     branch="${1}"
     out="${2}"
+    replace="${3}"
     dir="$(mktemp -d)"
 
     stderr "Executing benchmark for ${branch} at ${dir}"
@@ -129,7 +136,14 @@ bench() {
     fi
 
     pushd "$dir"
-    go test -bench=. -count=10 ./... | tee "${out}"
+
+    if [ "${replace}" != "" ]; then
+        find ./benchmark/ -iname '*.go' -exec sed -i -E "s|github.com/pelletier/go-toml/v2|${replace}|g" {} \;
+        go get "${replace}"
+    fi
+
+    export GOMAXPROCS=2
+    nice -n -19 taskset --cpu-list 0,1 go test '-bench=^Benchmark(Un)?[mM]arshal' -count=5 -run=Nothing ./... | tee "${out}"
     popd
 
     if [ "${branch}" != "HEAD" ]; then
@@ -137,19 +151,114 @@ bench() {
     fi
 }
 
+fmktemp() {
+    if mktemp --version|grep GNU >/dev/null; then
+        mktemp --suffix=-$1;
+    else
+        mktemp -t $1;
+    fi
+}
+
+benchstathtml() {
+python3 - $1 <<'EOF'
+import sys
+
+lines = []
+stop = False
+
+with open(sys.argv[1]) as f:
+    for line in f.readlines():
+        line = line.strip()
+        if line == "":
+            stop = True
+        if not stop:
+            lines.append(line.split(','))
+
+results = []
+for line in reversed(lines[1:]):
+    v2 = float(line[1])
+    results.append([
+        line[0].replace("-32", ""),
+        "%.1fx" % (float(line[3])/v2),  # v1
+        "%.1fx" % (float(line[5])/v2),  # bs
+    ])
+# move geomean to the end
+results.append(results[0])
+del results[0]
+
+
+def printtable(data):
+    print("""
+<table>
+    <thead>
+        <tr><th>Benchmark</th><th>go-toml v1</th><th>BurntSushi/toml</th></tr>
+    </thead>
+    <tbody>""")
+
+    for r in data:
+        print("        <tr><td>{}</td><td>{}</td><td>{}</td></tr>".format(*r))
+
+    print("""     </tbody>
+</table>""")
+
+
+def match(x):
+    return "ReferenceFile" in x[0] or "HugoFrontMatter" in x[0]
+
+above = [x for x in results if match(x)]
+below = [x for x in results if not match(x)]
+
+printtable(above)
+print("<details><summary>See more</summary>")
+print("""<p>The table above has the results of the most common use-cases. The table below
+contains the results of all benchmarks, including unrealistic ones. It is
+provided for completeness.</p>""")
+printtable(below)
+print('<p>This table can be generated with <code>./ci.sh benchmark -a -html</code>.</p>')
+print("</details>")
+
+EOF
+}
+
 benchmark() {
     case "$1" in
     -d)
         shift
      	target="${1?Need to provide a target branch argument}"
-        old=`mktemp`
+
+        old=`fmktemp ${target}`
         bench "${target}" "${old}"
 
-        new=`mktemp`
+        new=`fmktemp HEAD`
         bench HEAD "${new}"
+
         benchstat "${old}" "${new}"
         return 0
         ;;
+    -a)
+        shift
+
+        v2stats=`fmktemp go-toml-v2`
+        bench HEAD "${v2stats}" "github.com/pelletier/go-toml/v2"
+        v1stats=`fmktemp go-toml-v1`
+        bench HEAD "${v1stats}" "github.com/pelletier/go-toml"
+        bsstats=`fmktemp bs-toml`
+        bench HEAD "${bsstats}" "github.com/BurntSushi/toml"
+
+        cp "${v2stats}" go-toml-v2.txt
+        cp "${v1stats}" go-toml-v1.txt
+        cp "${bsstats}" bs-toml.txt
+
+        if [ "$1" = "-html" ]; then
+            tmpcsv=`fmktemp csv`
+            benchstat -csv -geomean go-toml-v2.txt go-toml-v1.txt bs-toml.txt > $tmpcsv
+            benchstathtml $tmpcsv
+        else
+            benchstat -geomean go-toml-v2.txt go-toml-v1.txt bs-toml.txt
+        fi
+
+        rm -f go-toml-v2.txt go-toml-v1.txt bs-toml.txt
+        return $?
     esac
 
     bench "${1-HEAD}" `mktemp`

cmd/gotoml-test-decoder/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"log"
+	"os"
+	"path"
+
+	"github.com/pelletier/go-toml/v2/testsuite"
+)
+
+func main() {
+	log.SetFlags(0)
+	flag.Usage = usage
+	flag.Parse()
+	if flag.NArg() != 0 {
+		flag.Usage()
+	}
+
+	err := testsuite.DecodeStdin()
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func usage() {
+	log.Printf("Usage: %s < toml-file\n", path.Base(os.Args[0]))
+	flag.PrintDefaults()
+	os.Exit(1)
+}

cmd/tomltestgen/main.go

@@ -0,0 +1,223 @@
+// tomltestgen retrieves a given version of the language-agnostic TOML test suite in
+// https://github.com/BurntSushi/toml-test and generates go-toml unit tests.
+//
+// Within the go-toml package, run `go generate`.  Otherwise, use:
+//
+//     go run github.com/pelletier/go-toml/cmd/tomltestgen -o toml_testgen_test.go
+package main
+
+import (
+	"archive/zip"
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"io"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+	"text/template"
+	"time"
+)
+
+type invalid struct {
+	Name  string
+	Input string
+}
+
+type valid struct {
+	Name    string
+	Input   string
+	JsonRef string
+}
+
+type testsCollection struct {
+	Ref       string
+	Timestamp string
+	Invalid   []invalid
+	Valid     []valid
+	Count     int
+}
+
+const srcTemplate = "// Generated by tomltestgen for toml-test ref {{.Ref}} on {{.Timestamp}}\n" +
+	"package toml_test\n" +
+	" import (\n" +
+	"	\"testing\"\n" +
+	")\n" +
+
+	"{{range .Invalid}}\n" +
+	"func TestTOMLTest_Invalid_{{.Name}}(t *testing.T) {\n" +
+	"	input := {{.Input|gostr}}\n" +
+	"	testgenInvalid(t, input)\n" +
+	"}\n" +
+	"{{end}}\n" +
+	"\n" +
+	"{{range .Valid}}\n" +
+	"func TestTOMLTest_Valid_{{.Name}}(t *testing.T) {\n" +
+	"   input := {{.Input|gostr}}\n" +
+	"   jsonRef := {{.JsonRef|gostr}}\n" +
+	"   testgenValid(t, input, jsonRef)\n" +
+	"}\n" +
+	"{{end}}\n"
+
+func downloadTmpFile(url string) string {
+	log.Println("starting to download file from", url)
+	resp, err := http.Get(url)
+	if err != nil {
+		panic(err)
+	}
+	defer resp.Body.Close()
+
+	tmpfile, err := ioutil.TempFile("", "toml-test-*.zip")
+	if err != nil {
+		panic(err)
+	}
+	defer tmpfile.Close()
+
+	copiedLen, err := io.Copy(tmpfile, resp.Body)
+	if err != nil {
+		panic(err)
+	}
+	if resp.ContentLength > 0 && copiedLen != resp.ContentLength {
+		panic(fmt.Errorf("copied %d bytes, request body had %d", copiedLen, resp.ContentLength))
+	}
+	return tmpfile.Name()
+}
+
+func kebabToCamel(kebab string) string {
+	camel := ""
+	nextUpper := true
+	for _, c := range kebab {
+		if nextUpper {
+			camel += strings.ToUpper(string(c))
+			nextUpper = false
+		} else if c == '-' {
+			nextUpper = true
+		} else if c == '/' {
+			nextUpper = true
+			camel += "_"
+		} else {
+			camel += string(c)
+		}
+	}
+	return camel
+}
+
+func readFileFromZip(f *zip.File) string {
+	reader, err := f.Open()
+	if err != nil {
+		panic(err)
+	}
+	defer reader.Close()
+	bytes, err := ioutil.ReadAll(reader)
+	if err != nil {
+		panic(err)
+	}
+	return string(bytes)
+}
+
+func templateGoStr(input string) string {
+	return strconv.Quote(input)
+}
+
+var (
+	ref = flag.String("r", "master", "git reference")
+	out = flag.String("o", "", "output file")
+)
+
+func usage() {
+	_, _ = fmt.Fprintf(os.Stderr, "usage: tomltestgen [flags]\n")
+	flag.PrintDefaults()
+}
+
+func main() {
+	flag.Usage = usage
+	flag.Parse()
+
+	url := "https://codeload.github.com/BurntSushi/toml-test/zip/" + *ref
+	resultFile := downloadTmpFile(url)
+	defer os.Remove(resultFile)
+	log.Println("file written to", resultFile)
+
+	zipReader, err := zip.OpenReader(resultFile)
+	if err != nil {
+		panic(err)
+	}
+	defer zipReader.Close()
+
+	collection := testsCollection{
+		Ref:       *ref,
+		Timestamp: time.Now().Format(time.RFC3339),
+	}
+
+	zipFilesMap := map[string]*zip.File{}
+
+	for _, f := range zipReader.File {
+		zipFilesMap[f.Name] = f
+	}
+
+	testFileRegexp := regexp.MustCompile(`([^/]+/tests/(valid|invalid)/(.+))\.(toml)`)
+	for _, f := range zipReader.File {
+		groups := testFileRegexp.FindStringSubmatch(f.Name)
+		if len(groups) > 0 {
+			name := kebabToCamel(groups[3])
+			testType := groups[2]
+
+			log.Printf("> [%s] %s\n", testType, name)
+
+			tomlContent := readFileFromZip(f)
+
+			switch testType {
+			case "invalid":
+				collection.Invalid = append(collection.Invalid, invalid{
+					Name:  name,
+					Input: tomlContent,
+				})
+				collection.Count++
+			case "valid":
+				baseFilePath := groups[1]
+				jsonFilePath := baseFilePath + ".json"
+				jsonContent := readFileFromZip(zipFilesMap[jsonFilePath])
+
+				collection.Valid = append(collection.Valid, valid{
+					Name:    name,
+					Input:   tomlContent,
+					JsonRef: jsonContent,
+				})
+				collection.Count++
+			default:
+				panic(fmt.Sprintf("unknown test type: %s", testType))
+			}
+		}
+	}
+
+	log.Printf("Collected %d tests from toml-test\n", collection.Count)
+
+	funcMap := template.FuncMap{
+		"gostr": templateGoStr,
+	}
+	t := template.Must(template.New("src").Funcs(funcMap).Parse(srcTemplate))
+	buf := new(bytes.Buffer)
+	err = t.Execute(buf, collection)
+	if err != nil {
+		panic(err)
+	}
+	outputBytes, err := format.Source(buf.Bytes())
+	if err != nil {
+		panic(err)
+	}
+
+	if *out == "" {
+		fmt.Println(string(outputBytes))
+		return
+	}
+
+	err = os.WriteFile(*out, outputBytes, 0644)
+	if err != nil {
+		panic(err)
+	}
+}

decode.go

@@ -35,26 +35,42 @@ func parseLocalDate(b []byte) (LocalDate, error) {
 		return date, newDecodeError(b, "dates are expected to have the format YYYY-MM-DD")
 	}
 
-	date.Year = parseDecimalDigits(b[0:4])
+	var err error
 
-	v := parseDecimalDigits(b[5:7])
+	date.Year, err = parseDecimalDigits(b[0:4])
+	if err != nil {
+		return LocalDate{}, err
+	}
 
-	date.Month = time.Month(v)
+	date.Month, err = parseDecimalDigits(b[5:7])
+	if err != nil {
+		return LocalDate{}, err
+	}
 
-	date.Day = parseDecimalDigits(b[8:10])
+	date.Day, err = parseDecimalDigits(b[8:10])
+	if err != nil {
+		return LocalDate{}, err
+	}
+
+	if !isValidDate(date.Year, date.Month, date.Day) {
+		return LocalDate{}, newDecodeError(b, "impossible date")
+	}
 
 	return date, nil
 }
 
-func parseDecimalDigits(b []byte) int {
+func parseDecimalDigits(b []byte) (int, error) {
 	v := 0
 
-	for _, c := range b {
+	for i, c := range b {
+		if c < '0' || c > '9' {
+			return 0, newDecodeError(b[i:i+1], "expected digit (0-9)")
+		}
 		v *= 10
 		v += int(c - '0')
 	}
 
-	return v
+	return v, nil
 }
 
 func parseDateTime(b []byte) (time.Time, error) {
@@ -75,7 +91,7 @@ func parseDateTime(b []byte) (time.Time, error) {
 		panic("date time should have a timezone")
 	}
 
-	if b[0] == 'Z' {
+	if b[0] == 'Z' || b[0] == 'z' {
 		b = b[1:]
 		zone = time.UTC
 	} else {
@@ -100,13 +116,13 @@ func parseDateTime(b []byte) (time.Time, error) {
 	}
 
 	t := time.Date(
-		dt.Date.Year,
-		dt.Date.Month,
-		dt.Date.Day,
-		dt.Time.Hour,
-		dt.Time.Minute,
-		dt.Time.Second,
-		dt.Time.Nanosecond,
+		dt.Year,
+		time.Month(dt.Month),
+		dt.Day,
+		dt.Hour,
+		dt.Minute,
+		dt.Second,
+		dt.Nanosecond,
 		zone)
 
 	return t, nil
@@ -124,10 +140,10 @@ func parseLocalDateTime(b []byte) (LocalDateTime, []byte, error) {
 	if err != nil {
 		return dt, nil, err
 	}
-	dt.Date = date
+	dt.LocalDate = date
 
 	sep := b[10]
-	if sep != 'T' && sep != ' ' {
+	if sep != 'T' && sep != ' ' && sep != 't' {
 		return dt, nil, newDecodeError(b[10:11], "datetime separator is expected to be T or a space")
 	}
 
@@ -135,7 +151,7 @@ func parseLocalDateTime(b []byte) (LocalDateTime, []byte, error) {
 	if err != nil {
 		return dt, nil, err
 	}
-	dt.Time = t
+	dt.LocalTime = t
 
 	return dt, rest, nil
 }
@@ -149,22 +165,45 @@ func parseLocalTime(b []byte) (LocalTime, []byte, error) {
 		t     LocalTime
 	)
 
+	// check if b matches to have expected format HH:MM:SS[.NNNNNN]
 	const localTimeByteLen = 8
 	if len(b) < localTimeByteLen {
 		return t, nil, newDecodeError(b, "times are expected to have the format HH:MM:SS[.NNNNNN]")
 	}
 
-	t.Hour = parseDecimalDigits(b[0:2])
+	var err error
+
+	t.Hour, err = parseDecimalDigits(b[0:2])
+	if err != nil {
+		return t, nil, err
+	}
+
+	if t.Hour > 23 {
+		return t, nil, newDecodeError(b[0:2], "hour cannot be greater 23")
+	}
 	if b[2] != ':' {
 		return t, nil, newDecodeError(b[2:3], "expecting colon between hours and minutes")
 	}
 
-	t.Minute = parseDecimalDigits(b[3:5])
+	t.Minute, err = parseDecimalDigits(b[3:5])
+	if err != nil {
+		return t, nil, err
+	}
+	if t.Minute > 59 {
+		return t, nil, newDecodeError(b[3:5], "minutes cannot be greater 59")
+	}
 	if b[5] != ':' {
 		return t, nil, newDecodeError(b[5:6], "expecting colon between minutes and seconds")
 	}
 
-	t.Second = parseDecimalDigits(b[6:8])
+	t.Second, err = parseDecimalDigits(b[6:8])
+	if err != nil {
+		return t, nil, err
+	}
+
+	if t.Second > 59 {
+		return t, nil, newDecodeError(b[3:5], "seconds cannot be greater 59")
+	}
 
 	const minLengthWithFrac = 9
 	if len(b) >= minLengthWithFrac && b[minLengthWithFrac-1] == '.' {
@@ -172,6 +211,14 @@ func parseLocalTime(b []byte) (LocalTime, []byte, error) {
 		digits := 0
 
 		for i, c := range b[minLengthWithFrac:] {
+			if !isDigit(c) {
+				if i == 0 {
+					return t, nil, newDecodeError(b[i:i+1], "need at least one digit after fraction point")
+				}
+
+				break
+			}
+
 			const maxFracPrecision = 9
 			if i >= maxFracPrecision {
 				return t, nil, newDecodeError(b[i:i+1], "maximum precision for date time is nanosecond")
@@ -182,7 +229,12 @@ func parseLocalTime(b []byte) (LocalTime, []byte, error) {
 			digits++
 		}
 
+		if digits == 0 {
+			return t, nil, newDecodeError(b[minLengthWithFrac-1:minLengthWithFrac], "nanoseconds need at least one digit")
+		}
+
 		t.Nanosecond = frac * nspow[digits]
+		t.Precision = digits
 
 		return t, b[9+digits:], nil
 	}
@@ -196,7 +248,7 @@ func parseFloat(b []byte) (float64, error) {
 		return math.NaN(), nil
 	}
 
-	cleaned, err := checkAndRemoveUnderscores(b)
+	cleaned, err := checkAndRemoveUnderscoresFloats(b)
 	if err != nil {
 		return 0, err
 	}
@@ -209,6 +261,30 @@ func parseFloat(b []byte) (float64, error) {
 		return 0, newDecodeError(b, "float cannot end with a dot")
 	}
 
+	dotAlreadySeen := false
+	for i, c := range cleaned {
+		if c == '.' {
+			if dotAlreadySeen {
+				return 0, newDecodeError(b[i:i+1], "float can have at most one decimal point")
+			}
+			if !isDigit(cleaned[i-1]) {
+				return 0, newDecodeError(b[i-1:i+1], "float decimal point must be preceded by a digit")
+			}
+			if !isDigit(cleaned[i+1]) {
+				return 0, newDecodeError(b[i:i+2], "float decimal point must be followed by a digit")
+			}
+			dotAlreadySeen = true
+		}
+	}
+
+	start := 0
+	if b[0] == '+' || b[0] == '-' {
+		start = 1
+	}
+	if b[start] == '0' && isDigit(b[start+1]) {
+		return 0, newDecodeError(b, "float integer part cannot have leading zeroes")
+	}
+
 	f, err := strconv.ParseFloat(string(cleaned), 64)
 	if err != nil {
 		return 0, newDecodeError(b, "unable to parse float: %w", err)
@@ -218,7 +294,7 @@ func parseFloat(b []byte) (float64, error) {
 }
 
 func parseIntHex(b []byte) (int64, error) {
-	cleaned, err := checkAndRemoveUnderscores(b[2:])
+	cleaned, err := checkAndRemoveUnderscoresIntegers(b[2:])
 	if err != nil {
 		return 0, err
 	}
@@ -232,7 +308,7 @@ func parseIntHex(b []byte) (int64, error) {
 }
 
 func parseIntOct(b []byte) (int64, error) {
-	cleaned, err := checkAndRemoveUnderscores(b[2:])
+	cleaned, err := checkAndRemoveUnderscoresIntegers(b[2:])
 	if err != nil {
 		return 0, err
 	}
@@ -246,7 +322,7 @@ func parseIntOct(b []byte) (int64, error) {
 }
 
 func parseIntBin(b []byte) (int64, error) {
-	cleaned, err := checkAndRemoveUnderscores(b[2:])
+	cleaned, err := checkAndRemoveUnderscoresIntegers(b[2:])
 	if err != nil {
 		return 0, err
 	}
@@ -259,12 +335,26 @@ func parseIntBin(b []byte) (int64, error) {
 	return i, nil
 }
 
+func isSign(b byte) bool {
+	return b == '+' || b == '-'
+}
+
 func parseIntDec(b []byte) (int64, error) {
-	cleaned, err := checkAndRemoveUnderscores(b)
+	cleaned, err := checkAndRemoveUnderscoresIntegers(b)
 	if err != nil {
 		return 0, err
 	}
 
+	startIdx := 0
+
+	if isSign(cleaned[0]) {
+		startIdx++
+	}
+
+	if len(cleaned) > startIdx+1 && cleaned[startIdx] == '0' {
+		return 0, newDecodeError(b, "leading zero not allowed on decimal number")
+	}
+
 	i, err := strconv.ParseInt(string(cleaned), 10, 64)
 	if err != nil {
 		return 0, newDecodeError(b, "couldn't parse decimal number: %w", err)
@@ -273,7 +363,7 @@ func parseIntDec(b []byte) (int64, error) {
 	return i, nil
 }
 
-func checkAndRemoveUnderscores(b []byte) ([]byte, error) {
+func checkAndRemoveUnderscoresIntegers(b []byte) ([]byte, error) {
 	if b[0] == '_' {
 		return nil, newDecodeError(b[0:1], "number cannot start with underscore")
 	}
@@ -312,3 +402,95 @@ func checkAndRemoveUnderscores(b []byte) ([]byte, error) {
 
 	return cleaned, nil
 }
+
+func checkAndRemoveUnderscoresFloats(b []byte) ([]byte, error) {
+	if b[0] == '_' {
+		return nil, newDecodeError(b[0:1], "number cannot start with underscore")
+	}
+
+	if b[len(b)-1] == '_' {
+		return nil, newDecodeError(b[len(b)-1:], "number cannot end with underscore")
+	}
+
+	// fast path
+	i := 0
+	for ; i < len(b); i++ {
+		if b[i] == '_' {
+			break
+		}
+	}
+	if i == len(b) {
+		return b, nil
+	}
+
+	before := false
+	cleaned := make([]byte, 0, len(b))
+
+	for i := 0; i < len(b); i++ {
+		c := b[i]
+
+		switch c {
+		case '_':
+			if !before {
+				return nil, newDecodeError(b[i-1:i+1], "number must have at least one digit between underscores")
+			}
+			if i < len(b)-1 && (b[i+1] == 'e' || b[i+1] == 'E') {
+				return nil, newDecodeError(b[i+1:i+2], "cannot have underscore before exponent")
+			}
+			before = false
+		case 'e', 'E':
+			if i < len(b)-1 && b[i+1] == '_' {
+				return nil, newDecodeError(b[i+1:i+2], "cannot have underscore after exponent")
+			}
+			cleaned = append(cleaned, c)
+		case '.':
+			if i < len(b)-1 && b[i+1] == '_' {
+				return nil, newDecodeError(b[i+1:i+2], "cannot have underscore after decimal point")
+			}
+			if i > 0 && b[i-1] == '_' {
+				return nil, newDecodeError(b[i-1:i], "cannot have underscore before decimal point")
+			}
+			cleaned = append(cleaned, c)
+		default:
+			before = true
+			cleaned = append(cleaned, c)
+		}
+	}
+
+	return cleaned, nil
+}
+
+// isValidDate checks if a provided date is a date that exists.
+func isValidDate(year int, month int, day int) bool {
+	return day <= daysIn(month, year)
+}
+
+// daysBefore[m] counts the number of days in a non-leap year
+// before month m begins. There is an entry for m=12, counting
+// the number of days before January of next year (365).
+var daysBefore = [...]int32{
+	0,
+	31,
+	31 + 28,
+	31 + 28 + 31,
+	31 + 28 + 31 + 30,
+	31 + 28 + 31 + 30 + 31,
+	31 + 28 + 31 + 30 + 31 + 30,
+	31 + 28 + 31 + 30 + 31 + 30 + 31,
+	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31,
+	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
+	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
+	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30,
+	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31,
+}
+
+func daysIn(m int, year int) int {
+	if m == 2 && isLeap(year) {
+		return 29
+	}
+	return int(daysBefore[m] - daysBefore[m-1])
+}
+
+func isLeap(year int) bool {
+	return year%4 == 0 && (year%100 != 0 || year%400 == 0)
+}

errors.go

@@ -5,7 +5,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/pelletier/go-toml/v2/internal/unsafe"
+	"github.com/pelletier/go-toml/v2/internal/danger"
 )
 
 // DecodeError represents an error encountered during the parsing or decoding
@@ -105,7 +105,7 @@ func (e *DecodeError) Key() Key {
 // highlight can be freely deallocated.
 //nolint:funlen
 func wrapDecodeError(document []byte, de *decodeError) *DecodeError {
-	offset := unsafe.SubsliceOffset(document, de.highlight)
+	offset := danger.SubsliceOffset(document, de.highlight)
 
 	errMessage := de.Error()
 	errLine, errColumn := positionAtEnd(document[:offset])
@@ -116,6 +116,7 @@ func wrapDecodeError(document []byte, de *decodeError) *DecodeError {
 	maxLine := errLine + len(after) - 1
 	lineColumnWidth := len(strconv.Itoa(maxLine))
 
+	// Write the lines of context strictly before the error.
 	for i := len(before) - 1; i > 0; i-- {
 		line := errLine - i
 		buf.WriteString(formatLineNumber(line, lineColumnWidth))
@@ -129,6 +130,8 @@ func wrapDecodeError(document []byte, de *decodeError) *DecodeError {
 		buf.WriteRune('\n')
 	}
 
+	// Write the document line that contains the error.
+
 	buf.WriteString(formatLineNumber(errLine, lineColumnWidth))
 	buf.WriteString("| ")
 
@@ -143,6 +146,10 @@ func wrapDecodeError(document []byte, de *decodeError) *DecodeError {
 	}
 
 	buf.WriteRune('\n')
+
+	// Write the line with the error message itself (so it does not have a line
+	// number).
+
 	buf.WriteString(strings.Repeat(" ", lineColumnWidth))
 	buf.WriteString("| ")
 
@@ -157,6 +164,8 @@ func wrapDecodeError(document []byte, de *decodeError) *DecodeError {
 		buf.WriteString(errMessage)
 	}
 
+	// Write the lines of context strictly after the error.
+
 	for i := 1; i < len(after); i++ {
 		buf.WriteRune('\n')
 		line := errLine + i
@@ -230,7 +239,7 @@ forward:
 			rest = rest[o+1:]
 			o = 0
 
-		case o == len(rest)-1 && o > 0:
+		case o == len(rest)-1:
 			// add last line only if it's non-empty
 			afterLines = append(afterLines, rest)
 

errors_test.go

@@ -12,7 +12,6 @@ import (
 
 //nolint:funlen
 func TestDecodeError(t *testing.T) {
-	t.Parallel()
 
 	examples := []struct {
 		desc     string
@@ -149,12 +148,19 @@ line 5`,
 6|
 7| line 4`,
 		},
+		{
+			desc: "handle remainder of the error line when there is only one line",
+			doc:  [3]string{`P=`, `[`, `#`},
+			msg:  "array is incomplete",
+			expected: `1| P=[#
+ |   ~ array is incomplete`,
+		},
 	}
 
 	for _, e := range examples {
 		e := e
 		t.Run(e.desc, func(t *testing.T) {
-			t.Parallel()
+
 			b := bytes.Buffer{}
 			b.Write([]byte(e.doc[0]))
 			start := b.Len()
@@ -182,7 +188,6 @@ line 5`,
 }
 
 func TestDecodeError_Accessors(t *testing.T) {
-	t.Parallel()
 
 	e := DecodeError{
 		message: "foo",

fast_test.go

@@ -0,0 +1,100 @@
+package toml_test
+
+import (
+	"testing"
+
+	"github.com/pelletier/go-toml/v2"
+	"github.com/stretchr/testify/require"
+)
+
+func TestFastSimple(t *testing.T) {
+	m := map[string]int64{}
+	err := toml.Unmarshal([]byte(`a = 42`), &m)
+	require.NoError(t, err)
+	require.Equal(t, map[string]int64{"a": 42}, m)
+}
+
+func TestFastSimpleString(t *testing.T) {
+	m := map[string]string{}
+	err := toml.Unmarshal([]byte(`a = "hello"`), &m)
+	require.NoError(t, err)
+	require.Equal(t, map[string]string{"a": "hello"}, m)
+}
+
+func TestFastSimpleInterface(t *testing.T) {
+	m := map[string]interface{}{}
+	err := toml.Unmarshal([]byte(`
+	a = "hello"
+	b = 42`), &m)
+	require.NoError(t, err)
+	require.Equal(t, map[string]interface{}{
+		"a": "hello",
+		"b": int64(42),
+	}, m)
+}
+
+func TestFastMultipartKeyInterface(t *testing.T) {
+	m := map[string]interface{}{}
+	err := toml.Unmarshal([]byte(`
+	a.interim = "test"
+	a.b.c = "hello"
+	b = 42`), &m)
+	require.NoError(t, err)
+	require.Equal(t, map[string]interface{}{
+		"a": map[string]interface{}{
+			"interim": "test",
+			"b": map[string]interface{}{
+				"c": "hello",
+			},
+		},
+		"b": int64(42),
+	}, m)
+}
+
+func TestFastExistingMap(t *testing.T) {
+	m := map[string]interface{}{
+		"ints": map[string]int{},
+	}
+	err := toml.Unmarshal([]byte(`
+	ints.one = 1
+	ints.two = 2
+	strings.yo = "hello"`), &m)
+	require.NoError(t, err)
+	require.Equal(t, map[string]interface{}{
+		"ints": map[string]interface{}{
+			"one": int64(1),
+			"two": int64(2),
+		},
+		"strings": map[string]interface{}{
+			"yo": "hello",
+		},
+	}, m)
+}
+
+func TestFastArrayTable(t *testing.T) {
+	b := []byte(`
+	[root]
+	[[root.nested]]
+	name = 'Bob'
+	[[root.nested]]
+	name = 'Alice'
+	`)
+
+	m := map[string]interface{}{}
+
+	err := toml.Unmarshal(b, &m)
+	require.NoError(t, err)
+
+	require.Equal(t, map[string]interface{}{
+		"root": map[string]interface{}{
+			"nested": []interface{}{
+				map[string]interface{}{
+					"name": "Bob",
+				},
+				map[string]interface{}{
+					"name": "Alice",
+				},
+			},
+		},
+	}, m)
+}

go.mod

@@ -1,5 +1,6 @@
 module github.com/pelletier/go-toml/v2
 
-go 1.15
+go 1.16
 
-require github.com/stretchr/testify v1.7.0
+// latest (v1.7.0) doesn't have the fix for time.Time
+require github.com/stretchr/testify v1.7.1-0.20210427113832-6241f9ab9942

go.sum

@@ -3,8 +3,8 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 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=
+github.com/stretchr/testify v1.7.1-0.20210427113832-6241f9ab9942 h1:t0lM6y/M5IiUZyvbBTcngso8SZEZICH7is9B6g/obVU=
+github.com/stretchr/testify v1.7.1-0.20210427113832-6241f9ab9942/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 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=

internal/ast/ast.go

@@ -2,6 +2,9 @@ package ast
 
 import (
 	"fmt"
+	"unsafe"
+
+	"github.com/pelletier/go-toml/v2/internal/danger"
 )
 
 // Iterator starts uninitialized, you need to call Next() first.
@@ -14,7 +17,7 @@ import (
 // }
 type Iterator struct {
 	started bool
-	node    Node
+	node    *Node
 }
 
 // Next moves the iterator forward and returns true if points to a node, false
@@ -28,8 +31,14 @@ func (c *Iterator) Next() bool {
 	return c.node.Valid()
 }
 
+// IsLast returns true if the current node of the iterator is the last one.
+// Subsequent call to Next() will return false.
+func (c *Iterator) IsLast() bool {
+	return c.node.next == 0
+}
+
 // Node returns a copy of the node pointed at by the iterator.
-func (c *Iterator) Node() Node {
+func (c *Iterator) Node() *Node {
 	return c.node
 }
 
@@ -44,14 +53,13 @@ type Root struct {
 func (r *Root) Iterator() Iterator {
 	it := Iterator{}
 	if len(r.nodes) > 0 {
-		it.node = 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]
+func (r *Root) at(idx Reference) *Node {
+	return &r.nodes[idx]
 }
 
 // Arrays have one child per element in the array.
@@ -63,42 +71,48 @@ func (r *Root) at(idx int) Node {
 // children []Node
 type Node struct {
 	Kind Kind
-	Data []byte // Raw bytes from the input
+	Raw  Range  // Raw bytes from the input.
+	Data []byte // Node value (could be either allocated or referencing 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
+	// References to other nodes, as offsets in the backing array from this
+	// node. References can go backward, so those can be negative.
+	next  int // 0 if last element
+	child int // 0 if no child
+}
+
+type Range struct {
+	Offset uint32
+	Length uint32
 }
 
 // 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
+func (n *Node) Next() *Node {
+	if n.next == 0 {
+		return nil
 	}
-	return n.root.at(n.next)
+	ptr := unsafe.Pointer(n)
+	size := unsafe.Sizeof(Node{})
+	return (*Node)(danger.Stride(ptr, size, 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
+func (n *Node) Child() *Node {
+	if n.child == 0 {
+		return nil
 	}
-	return n.root.at(n.child)
+	ptr := unsafe.Pointer(n)
+	size := unsafe.Sizeof(Node{})
+	return (*Node)(danger.Stride(ptr, size, n.child))
 }
 
 // Valid returns true if the node's kind is set (not to Invalid).
-func (n Node) Valid() bool {
-	return n.Kind != Invalid
+func (n *Node) Valid() bool {
+	return n != nil
 }
 
-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
@@ -121,18 +135,11 @@ func (n *Node) Key() Iterator {
 // 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)
+func (n *Node) Value() *Node {
 	return n.Child()
 }
 
 // Children returns an iterator over a node's children.
-func (n Node) Children() Iterator {
+func (n *Node) Children() Iterator {
 	return Iterator{node: n.Child()}
 }
-
-func assertKind(k Kind, n Node) {
-	if n.Kind != k {
-		panic(fmt.Errorf("method was expecting a %s, not a %s", k, n.Kind))
-	}
-}

internal/ast/builder.go

@@ -1,12 +1,11 @@
 package ast
 
-type Reference struct {
-	idx int
-	set bool
-}
+type Reference int
+
+const InvalidReference Reference = -1
 
 func (r Reference) Valid() bool {
-	return r.set
+	return r != InvalidReference
 }
 
 type Builder struct {
@@ -18,8 +17,8 @@ func (b *Builder) Tree() *Root {
 	return &b.tree
 }
 
-func (b *Builder) NodeAt(ref Reference) Node {
-	return b.tree.at(ref.idx)
+func (b *Builder) NodeAt(ref Reference) *Node {
+	return b.tree.at(ref)
 }
 
 func (b *Builder) Reset() {
@@ -28,33 +27,25 @@ func (b *Builder) Reset() {
 }
 
 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,
-	}
+	return Reference(b.lastIdx)
 }
 
 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.tree.nodes[b.lastIdx].next = newIdx - b.lastIdx
 	}
 	b.lastIdx = newIdx
-	return Reference{
-		idx: b.lastIdx,
-		set: true,
-	}
+	return Reference(b.lastIdx)
 }
 
 func (b *Builder) AttachChild(parent Reference, child Reference) {
-	b.tree.nodes[parent.idx].child = child.idx
+	b.tree.nodes[parent].child = int(child) - int(parent)
 }
 
 func (b *Builder) Chain(from Reference, to Reference) {
-	b.tree.nodes[from.idx].next = to.idx
+	b.tree.nodes[from].next = int(to) - int(from)
 }

internal/ast/kind.go

@@ -25,9 +25,9 @@ const (
 	Float
 	Integer
 	LocalDate
+	LocalTime
 	LocalDateTime
 	DateTime
-	Time
 )
 
 func (k Kind) String() string {
@@ -58,12 +58,12 @@ func (k Kind) String() string {
 		return "Integer"
 	case LocalDate:
 		return "LocalDate"
+	case LocalTime:
+		return "LocalTime"
 	case LocalDateTime:
 		return "LocalDateTime"
 	case DateTime:
 		return "DateTime"
-	case Time:
-		return "Time"
 	}
 	panic(fmt.Errorf("Kind.String() not implemented for '%d'", k))
 }

internal/danger/danger.go

@@ -1,4 +1,4 @@
-package unsafe
+package danger
 
 import (
 	"fmt"
@@ -57,3 +57,20 @@ func BytesRange(start []byte, end []byte) []byte {
 
 	return start[:l]
 }
+
+func Stride(ptr unsafe.Pointer, size uintptr, offset int) unsafe.Pointer {
+	// TODO: replace with unsafe.Add when Go 1.17 is released
+	//   https://github.com/golang/go/issues/40481
+	return unsafe.Pointer(uintptr(ptr) + uintptr(int(size)*offset))
+}
+
+type Slice struct {
+	Data unsafe.Pointer
+	Len  int
+	Cap  int
+}
+
+type iface struct {
+	typ unsafe.Pointer
+	ptr unsafe.Pointer
+}

internal/danger/danger_test.go

@@ -1,15 +1,16 @@
-package unsafe_test
+package danger_test
 
 import (
 	"testing"
+	"unsafe"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"github.com/pelletier/go-toml/v2/internal/unsafe"
+	"github.com/pelletier/go-toml/v2/internal/danger"
 )
 
-func TestUnsafeSubsliceOffsetValid(t *testing.T) {
+func TestSubsliceOffsetValid(t *testing.T) {
 	examples := []struct {
 		desc   string
 		test   func() ([]byte, []byte)
@@ -28,13 +29,13 @@ func TestUnsafeSubsliceOffsetValid(t *testing.T) {
 	for _, e := range examples {
 		t.Run(e.desc, func(t *testing.T) {
 			d, s := e.test()
-			offset := unsafe.SubsliceOffset(d, s)
+			offset := danger.SubsliceOffset(d, s)
 			assert.Equal(t, e.offset, offset)
 		})
 	}
 }
 
-func TestUnsafeSubsliceOffsetInvalid(t *testing.T) {
+func TestSubsliceOffsetInvalid(t *testing.T) {
 	examples := []struct {
 		desc string
 		test func() ([]byte, []byte)
@@ -72,13 +73,22 @@ func TestUnsafeSubsliceOffsetInvalid(t *testing.T) {
 		t.Run(e.desc, func(t *testing.T) {
 			d, s := e.test()
 			require.Panics(t, func() {
-				unsafe.SubsliceOffset(d, s)
+				danger.SubsliceOffset(d, s)
 			})
 		})
 	}
 }
 
-func TestUnsafeBytesRange(t *testing.T) {
+func TestStride(t *testing.T) {
+	a := []byte{1, 2, 3, 4}
+	x := &a[1]
+	n := (*byte)(danger.Stride(unsafe.Pointer(x), unsafe.Sizeof(byte(0)), 1))
+	require.Equal(t, &a[2], n)
+	n = (*byte)(danger.Stride(unsafe.Pointer(x), unsafe.Sizeof(byte(0)), -1))
+	require.Equal(t, &a[0], n)
+}
+
+func TestBytesRange(t *testing.T) {
 	type fn = func() ([]byte, []byte)
 	examples := []struct {
 		desc     string
@@ -157,10 +167,10 @@ func TestUnsafeBytesRange(t *testing.T) {
 			start, end := e.test()
 			if e.expected == nil {
 				require.Panics(t, func() {
-					unsafe.BytesRange(start, end)
+					danger.BytesRange(start, end)
 				})
 			} else {
-				res := unsafe.BytesRange(start, end)
+				res := danger.BytesRange(start, end)
 				require.Equal(t, e.expected, res)
 			}
 		})

internal/danger/slices.go

@@ -0,0 +1,20 @@
+//go:build go1.18
+// +build go1.18
+
+package danger
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+func ExtendSlice(t reflect.Type, s *Slice, n int) Slice {
+	arrayType := reflect.ArrayOf(n, t.Elem())
+	arrayData := reflect.New(arrayType)
+	reflect.Copy(arrayData.Elem(), reflect.NewAt(t, unsafe.Pointer(s)).Elem())
+	return Slice{
+		Data: unsafe.Pointer(arrayData.Pointer()),
+		Len:  s.Len,
+		Cap:  n,
+	}
+}

internal/danger/slices_optimized.go

@@ -0,0 +1,30 @@
+//go:build !go1.18
+// +build !go1.18
+
+package danger
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+//go:linkname unsafe_NewArray reflect.unsafe_NewArray
+func unsafe_NewArray(rtype unsafe.Pointer, length int) unsafe.Pointer
+
+//go:linkname typedslicecopy reflect.typedslicecopy
+//go:noescape
+func typedslicecopy(elemType unsafe.Pointer, dst, src Slice) int
+
+func ExtendSlice(t reflect.Type, s *Slice, n int) Slice {
+	elemTypeRef := t.Elem()
+	elemTypePtr := ((*iface)(unsafe.Pointer(&elemTypeRef))).ptr
+
+	d := Slice{
+		Data: unsafe_NewArray(elemTypePtr, n),
+		Len:  s.Len,
+		Cap:  n,
+	}
+
+	typedslicecopy(elemTypePtr, d, *s)
+	return d
+}

internal/danger/typeid.go

@@ -0,0 +1,23 @@
+package danger
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+// typeID is used as key in encoder and decoder caches to enable using
+// the optimize runtime.mapaccess2_fast64 function instead of the more
+// expensive lookup if we were to use reflect.Type as map key.
+//
+// typeID holds the pointer to the reflect.Type value, which is unique
+// in the program.
+//
+// https://github.com/segmentio/encoding/blob/master/json/codec.go#L59-L61
+type TypeID unsafe.Pointer
+
+func MakeTypeID(t reflect.Type) TypeID {
+	// reflect.Type has the fields:
+	// typ unsafe.Pointer
+	// ptr unsafe.Pointer
+	return TypeID((*[2]unsafe.Pointer)(unsafe.Pointer(&t))[1])
+}

internal/imported_tests/unmarshal_imported_test.go

@@ -223,11 +223,13 @@ type testSubDoc struct {
 	unexported int    `toml:"shouldntBeHere"`
 }
 
-var biteMe = "Bite me"
-var float1 float32 = 12.3
-var float2 float32 = 45.6
-var float3 float32 = 78.9
-var subdoc = testSubDoc{"Second", 0}
+var (
+	biteMe         = "Bite me"
+	float1 float32 = 12.3
+	float2 float32 = 45.6
+	float3 float32 = 78.9
+	subdoc         = testSubDoc{"Second", 0}
+)
 
 var docData = testDoc{
 	Title:       "TOML Marshal Testing",
@@ -382,7 +384,7 @@ var intErrTomls = []string{
 }
 
 func TestErrUnmarshal(t *testing.T) {
-	var errTomls = []string{
+	errTomls := []string{
 		"bool = truly\ndate = 1979-05-27T07:32:00Z\nfloat = 123.4\nint = 5000\nstring = \"Bite me\"",
 		"bool = true\ndate = 1979-05-27T07:3200Z\nfloat = 123.4\nint = 5000\nstring = \"Bite me\"",
 		"bool = true\ndate = 1979-05-27T07:32:00Z\nfloat = 123a4\nint = 5000\nstring = \"Bite me\"",
@@ -468,7 +470,7 @@ func TestEmptyUnmarshalOmit(t *testing.T) {
 		Map        map[string]string       `toml:"map,omitempty"`
 	}
 
-	var emptyTestData2 = emptyMarshalTestStruct2{
+	emptyTestData2 := emptyMarshalTestStruct2{
 		Title:      "Placeholder",
 		Bool:       false,
 		Int:        0,
@@ -496,21 +498,23 @@ type pointerMarshalTestStruct struct {
 	DblPtr    *[]*[]*string
 }
 
-var pointerStr = "Hello"
-var pointerList = []string{"Hello back"}
-var pointerListPtr = []*string{&pointerStr}
-var pointerMap = map[string]string{"response": "Goodbye"}
-var pointerMapPtr = map[string]*string{"alternate": &pointerStr}
-var pointerTestData = pointerMarshalTestStruct{
-	Str:       &pointerStr,
-	List:      &pointerList,
-	ListPtr:   &pointerListPtr,
-	Map:       &pointerMap,
-	MapPtr:    &pointerMapPtr,
-	EmptyStr:  nil,
-	EmptyList: nil,
-	EmptyMap:  nil,
-}
+var (
+	pointerStr      = "Hello"
+	pointerList     = []string{"Hello back"}
+	pointerListPtr  = []*string{&pointerStr}
+	pointerMap      = map[string]string{"response": "Goodbye"}
+	pointerMapPtr   = map[string]*string{"alternate": &pointerStr}
+	pointerTestData = pointerMarshalTestStruct{
+		Str:       &pointerStr,
+		List:      &pointerList,
+		ListPtr:   &pointerListPtr,
+		Map:       &pointerMap,
+		MapPtr:    &pointerMapPtr,
+		EmptyStr:  nil,
+		EmptyList: nil,
+		EmptyMap:  nil,
+	}
+)
 
 var pointerTestToml = []byte(`List = ["Hello back"]
 ListPtr = ["Hello"]
@@ -538,15 +542,17 @@ func TestUnmarshalTypeMismatch(t *testing.T) {
 
 type nestedMarshalTestStruct struct {
 	String [][]string
-	//Struct [][]basicMarshalTestSubStruct
+	// Struct [][]basicMarshalTestSubStruct
 	StringPtr *[]*[]*string
 	// StructPtr *[]*[]*basicMarshalTestSubStruct
 }
 
-var str1 = "Three"
-var str2 = "Four"
-var strPtr = []*string{&str1, &str2}
-var strPtr2 = []*[]*string{&strPtr}
+var (
+	str1    = "Three"
+	str2    = "Four"
+	strPtr  = []*string{&str1, &str2}
+	strPtr2 = []*[]*string{&strPtr}
+)
 
 var nestedTestData = nestedMarshalTestStruct{
 	String:    [][]string{{"Five", "Six"}, {"One", "Two"}},
@@ -597,6 +603,7 @@ var nestedCustomMarshalerData = customMarshalerParent{
 var nestedCustomMarshalerToml = []byte(`friends = ["Sally Fields"]
 me = "Maiku Suteda"
 `)
+
 var nestedCustomMarshalerTomlForUnmarshal = []byte(`[friends]
 FirstName = "Sally"
 LastName = "Fields"`)
@@ -613,11 +620,11 @@ func (x *IntOrString) MarshalTOML() ([]byte, error) {
 }
 
 func TestUnmarshalTextMarshaler(t *testing.T) {
-	var nested = struct {
+	nested := struct {
 		Friends textMarshaler `toml:"friends"`
 	}{}
 
-	var expected = struct {
+	expected := struct {
 		Friends textMarshaler `toml:"friends"`
 	}{
 		Friends: textMarshaler{FirstName: "Sally", LastName: "Fields"},
@@ -1360,7 +1367,6 @@ func TestUnmarshalPreservesUnexportedFields(t *testing.T) {
 	t.Run("unexported field should not be set from toml", func(t *testing.T) {
 		var actual unexportedFieldPreservationTest
 		err := toml.Unmarshal([]byte(doc), &actual)
-
 		if err != nil {
 			t.Fatal("did not expect an error")
 		}
@@ -1394,7 +1400,6 @@ func TestUnmarshalPreservesUnexportedFields(t *testing.T) {
 			Nested3:    &unexportedFieldPreservationTestNested{"baz", "bax"},
 		}
 		err := toml.Unmarshal([]byte(doc), &actual)
-
 		if err != nil {
 			t.Fatal("did not expect an error")
 		}
@@ -1431,7 +1436,6 @@ func TestUnmarshalLocalDate(t *testing.T) {
 		var obj dateStruct
 
 		err := toml.Unmarshal([]byte(doc), &obj)
-
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -1457,7 +1461,6 @@ func TestUnmarshalLocalDate(t *testing.T) {
 		var obj dateStruct
 
 		err := toml.Unmarshal([]byte(doc), &obj)
-
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -1484,32 +1487,34 @@ func TestUnmarshalLocalDateTime(t *testing.T) {
 			name: "normal",
 			in:   "1979-05-27T07:32:00",
 			out: toml.LocalDateTime{
-				Date: toml.LocalDate{
+				LocalDate: toml.LocalDate{
 					Year:  1979,
 					Month: 5,
 					Day:   27,
 				},
-				Time: toml.LocalTime{
+				LocalTime: toml.LocalTime{
 					Hour:       7,
 					Minute:     32,
 					Second:     0,
 					Nanosecond: 0,
 				},
-			}},
+			},
+		},
 		{
 			name: "with nanoseconds",
 			in:   "1979-05-27T00:32:00.999999",
 			out: toml.LocalDateTime{
-				Date: toml.LocalDate{
+				LocalDate: toml.LocalDate{
 					Year:  1979,
 					Month: 5,
 					Day:   27,
 				},
-				Time: toml.LocalTime{
+				LocalTime: toml.LocalTime{
 					Hour:       0,
 					Minute:     32,
 					Second:     0,
 					Nanosecond: 999999000,
+					Precision:  6,
 				},
 			},
 		},
@@ -1526,7 +1531,6 @@ func TestUnmarshalLocalDateTime(t *testing.T) {
 			var obj dateStruct
 
 			err := toml.Unmarshal([]byte(doc), &obj)
-
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -1544,31 +1548,30 @@ func TestUnmarshalLocalDateTime(t *testing.T) {
 			var obj dateStruct
 
 			err := toml.Unmarshal([]byte(doc), &obj)
-
 			if err != nil {
 				t.Fatal(err)
 			}
 
-			if obj.Date.Year() != example.out.Date.Year {
-				t.Errorf("expected year %d, got %d", example.out.Date.Year, obj.Date.Year())
+			if obj.Date.Year() != example.out.Year {
+				t.Errorf("expected year %d, got %d", example.out.Year, obj.Date.Year())
 			}
-			if obj.Date.Month() != example.out.Date.Month {
-				t.Errorf("expected month %d, got %d", example.out.Date.Month, obj.Date.Month())
+			if obj.Date.Month() != time.Month(example.out.Month) {
+				t.Errorf("expected month %d, got %d", example.out.Month, obj.Date.Month())
 			}
-			if obj.Date.Day() != example.out.Date.Day {
-				t.Errorf("expected day %d, got %d", example.out.Date.Day, obj.Date.Day())
+			if obj.Date.Day() != example.out.Day {
+				t.Errorf("expected day %d, got %d", example.out.Day, obj.Date.Day())
 			}
-			if obj.Date.Hour() != example.out.Time.Hour {
-				t.Errorf("expected hour %d, got %d", example.out.Time.Hour, obj.Date.Hour())
+			if obj.Date.Hour() != example.out.Hour {
+				t.Errorf("expected hour %d, got %d", example.out.Hour, obj.Date.Hour())
 			}
-			if obj.Date.Minute() != example.out.Time.Minute {
-				t.Errorf("expected minute %d, got %d", example.out.Time.Minute, obj.Date.Minute())
+			if obj.Date.Minute() != example.out.Minute {
+				t.Errorf("expected minute %d, got %d", example.out.Minute, obj.Date.Minute())
 			}
-			if obj.Date.Second() != example.out.Time.Second {
-				t.Errorf("expected second %d, got %d", example.out.Time.Second, obj.Date.Second())
+			if obj.Date.Second() != example.out.Second {
+				t.Errorf("expected second %d, got %d", example.out.Second, obj.Date.Second())
 			}
-			if obj.Date.Nanosecond() != example.out.Time.Nanosecond {
-				t.Errorf("expected nanoseconds %d, got %d", example.out.Time.Nanosecond, obj.Date.Nanosecond())
+			if obj.Date.Nanosecond() != example.out.Nanosecond {
+				t.Errorf("expected nanoseconds %d, got %d", example.out.Nanosecond, obj.Date.Nanosecond())
 			}
 		})
 	}
@@ -1598,6 +1601,7 @@ func TestUnmarshalLocalTime(t *testing.T) {
 				Minute:     32,
 				Second:     0,
 				Nanosecond: 999999000,
+				Precision:  6,
 			},
 		},
 	}
@@ -1613,7 +1617,6 @@ func TestUnmarshalLocalTime(t *testing.T) {
 			var obj dateStruct
 
 			err := toml.Unmarshal([]byte(doc), &obj)
-
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -2283,8 +2286,7 @@ func (d *durationString) UnmarshalTOML(v interface{}) error {
 	return nil
 }
 
-type config437Error struct {
-}
+type config437Error struct{}
 
 func (e *config437Error) UnmarshalTOML(v interface{}) error {
 	return errors.New("expected")

internal/tracker/key.go

@@ -11,19 +11,19 @@ type KeyTracker struct {
 }
 
 // UpdateTable sets the state of the tracker with the AST table node.
-func (t *KeyTracker) UpdateTable(node ast.Node) {
+func (t *KeyTracker) UpdateTable(node *ast.Node) {
 	t.reset()
 	t.Push(node)
 }
 
 // UpdateArrayTable sets the state of the tracker with the AST array table node.
-func (t *KeyTracker) UpdateArrayTable(node ast.Node) {
+func (t *KeyTracker) UpdateArrayTable(node *ast.Node) {
 	t.reset()
 	t.Push(node)
 }
 
 // Push the given key on the stack.
-func (t *KeyTracker) Push(node ast.Node) {
+func (t *KeyTracker) Push(node *ast.Node) {
 	it := node.Key()
 	for it.Next() {
 		t.k = append(t.k, string(it.Node().Data))
@@ -31,7 +31,7 @@ func (t *KeyTracker) Push(node ast.Node) {
 }
 
 // Pop key from stack.
-func (t *KeyTracker) Pop(node ast.Node) {
+func (t *KeyTracker) Pop(node *ast.Node) {
 	it := node.Key()
 	for it.Next() {
 		t.k = t.k[:len(t.k)-1]

internal/tracker/seen.go

@@ -1,6 +1,7 @@
 package tracker
 
 import (
+	"bytes"
 	"fmt"
 
 	"github.com/pelletier/go-toml/v2/internal/ast"
@@ -29,67 +30,93 @@ func (k keyKind) String() string {
 	panic("missing keyKind string mapping")
 }
 
-// SeenTracker tracks which keys have been seen with which TOML type to flag duplicates
-// and mismatches according to the spec.
+// SeenTracker tracks which keys have been seen with which TOML type to flag
+// duplicates and mismatches according to the spec.
+//
+// Each node in the visited tree is represented by an entry. Each entry has an
+// identifier, which is provided by a counter. Entries are stored in the array
+// entries. As new nodes are discovered (referenced for the first time in the
+// TOML document), entries are created and appended to the array. An entry
+// points to its parent using its id.
+//
+// To find whether a given key (sequence of []byte) has already been visited,
+// the entries are linearly searched, looking for one with the right name and
+// parent id.
+//
+// Given that all keys appear in the document after their parent, it is
+// guaranteed that all descendants of a node are stored after the node, this
+// speeds up the search process.
+//
+// When encountering [[array tables]], the descendants of that node are removed
+// to allow that branch of the tree to be "rediscovered". To maintain the
+// invariant above, the deletion process needs to keep the order of entries.
+// This results in more copies in that case.
 type SeenTracker struct {
-	root    *info
-	current *info
+	entries    []entry
+	currentIdx int
+	nextID     int
 }
 
-type info struct {
-	parent   *info
+type entry struct {
+	id       int
+	parent   int
+	name     []byte
 	kind     keyKind
-	children map[string]*info
 	explicit bool
 }
 
-func (i *info) Clear() {
-	i.children = nil
+// Remove all descendants of node at position idx.
+func (s *SeenTracker) clear(idx int) {
+	p := s.entries[idx].id
+	rest := clear(p, s.entries[idx+1:])
+	s.entries = s.entries[:idx+1+len(rest)]
 }
 
-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)
+func clear(parentID int, entries []entry) []entry {
+	for i := 0; i < len(entries); {
+		if entries[i].parent == parentID {
+			id := entries[i].id
+			copy(entries[i:], entries[i+1:])
+			entries = entries[:len(entries)-1]
+			rest := clear(id, entries[i:])
+			entries = entries[:i+len(rest)]
+		} else {
+			i++
+		}
 	}
+	return entries
+}
 
-	x := &info{
-		parent:   i,
+func (s *SeenTracker) create(parentIdx int, name []byte, kind keyKind, explicit bool) int {
+	parentID := s.id(parentIdx)
+
+	idx := len(s.entries)
+	s.entries = append(s.entries, entry{
+		id:       s.nextID,
+		parent:   parentID,
+		name:     name,
 		kind:     kind,
 		explicit: explicit,
-	}
-	i.children[k] = x
-	return x
+	})
+	s.nextID++
+	return idx
 }
 
-// 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 *SeenTracker) CheckExpression(node ast.Node) error {
-	if s.root == nil {
-		s.root = &info{
-			kind: tableKind,
-		}
-		s.current = s.root
+// 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 *SeenTracker) CheckExpression(node *ast.Node) error {
+	if s.entries == nil {
+		// Skip ID = 0 to remove the confusion between nodes whose
+		// parent has id 0 and root nodes (parent id is 0 because it's
+		// the zero value).
+		s.nextID = 1
+		// Start unscoped, so idx is negative.
+		s.currentIdx = -1
 	}
 	switch node.Kind {
 	case ast.KeyValue:
-		return s.checkKeyValue(s.current, node)
+		return s.checkKeyValue(s.currentIdx, node)
 	case ast.Table:
 		return s.checkTable(node)
 	case ast.ArrayTable:
@@ -97,104 +124,181 @@ func (s *SeenTracker) CheckExpression(node ast.Node) error {
 	default:
 		panic(fmt.Errorf("this should not be a top level node type: %s", node.Kind))
 	}
-
 }
-func (s *SeenTracker) checkTable(node ast.Node) error {
-	s.current = s.root
 
+func (s *SeenTracker) checkTable(node *ast.Node) error {
 	it := node.Key()
-	// handle the first parts of the key, excluding the last one
+
+	parentIdx := -1
+
+	// This code is duplicated in checkArrayTable. This is because factoring
+	// it in a function requires to copy the iterator, or allocate it to the
+	// heap, which is not cheap.
 	for it.Next() {
-		if !it.Node().Next().Valid() {
+		if it.IsLast() {
 			break
 		}
 
-		k := string(it.Node().Data)
-		child, found := s.current.Has(k)
-		if !found {
-			child = s.current.CreateTable(k, false)
+		k := it.Node().Data
+
+		idx := s.find(parentIdx, k)
+
+		if idx < 0 {
+			idx = s.create(parentIdx, k, tableKind, false)
 		}
-		s.current = child
+		parentIdx = idx
 	}
 
-	// handle the last part of the key
-	k := string(it.Node().Data)
+	k := it.Node().Data
+	idx := s.find(parentIdx, k)
 
-	i, found := s.current.Has(k)
-	if found {
-		if i.kind != tableKind {
-			return fmt.Errorf("toml: key %s should be a table, not a %s", k, i.kind)
+	if idx >= 0 {
+		kind := s.entries[idx].kind
+		if kind != tableKind {
+			return fmt.Errorf("toml: key %s should be a table, not a %s", string(k), kind)
 		}
-		if i.explicit {
-			return fmt.Errorf("toml: table %s already exists", k)
+		if s.entries[idx].explicit {
+			return fmt.Errorf("toml: table %s already exists", string(k))
 		}
-		i.explicit = true
-		s.current = i
+		s.entries[idx].explicit = true
 	} else {
-		s.current = s.current.CreateTable(k, true)
+		idx = s.create(parentIdx, k, tableKind, true)
 	}
 
+	s.currentIdx = idx
+
 	return nil
 }
 
-func (s *SeenTracker) checkArrayTable(node ast.Node) error {
-	s.current = s.root
-
+func (s *SeenTracker) checkArrayTable(node *ast.Node) error {
 	it := node.Key()
 
-	// handle the first parts of the key, excluding the last one
+	parentIdx := -1
+
 	for it.Next() {
-		if !it.Node().Next().Valid() {
+		if it.IsLast() {
 			break
 		}
 
-		k := string(it.Node().Data)
-		child, found := s.current.Has(k)
-		if !found {
-			child = s.current.CreateTable(k, false)
+		k := it.Node().Data
+
+		idx := s.find(parentIdx, k)
+
+		if idx < 0 {
+			idx = s.create(parentIdx, k, tableKind, false)
 		}
-		s.current = child
+		parentIdx = idx
 	}
 
-	// handle the last part of the key
-	k := string(it.Node().Data)
+	k := it.Node().Data
+	idx := s.find(parentIdx, k)
 
-	info, found := s.current.Has(k)
-	if found {
-		if info.kind != arrayTableKind {
-			return fmt.Errorf("toml: key %s already exists as a %s,  but should be an array table", info.kind, k)
+	if idx >= 0 {
+		kind := s.entries[idx].kind
+		if kind != arrayTableKind {
+			return fmt.Errorf("toml: key %s already exists as a %s,  but should be an array table", kind, string(k))
 		}
-		info.Clear()
+		s.clear(idx)
 	} else {
-		info = s.current.CreateArrayTable(k, true)
+		idx = s.create(parentIdx, k, arrayTableKind, true)
 	}
 
-	s.current = info
+	s.currentIdx = idx
+
 	return nil
 }
 
-func (s *SeenTracker) checkKeyValue(context *info, node ast.Node) error {
+func (s *SeenTracker) checkKeyValue(parentIdx int, 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("toml: expected %s to be a table, not a %s", k, child.kind)
-			}
+		k := it.Node().Data
+
+		idx := s.find(parentIdx, k)
+
+		if idx < 0 {
+			idx = s.create(parentIdx, k, tableKind, false)
 		} else {
-			child = context.CreateTable(k, false)
+			entry := s.entries[idx]
+			if it.IsLast() {
+				return fmt.Errorf("toml: key %s is already defined", string(k))
+			} else if entry.kind != tableKind {
+				return fmt.Errorf("toml: expected %s to be a table, not a %s", string(k), entry.kind)
+			} else if entry.explicit {
+				return fmt.Errorf("toml: cannot redefine table %s that has already been explicitly defined", string(k))
+			}
 		}
-		context = child
+
+		parentIdx = idx
 	}
 
-	if node.Value().Kind == ast.InlineTable {
-		context.SetKind(tableKind)
-	} else {
-		context.SetKind(valueKind)
+	s.entries[parentIdx].kind = valueKind
+
+	value := node.Value()
+
+	switch value.Kind {
+	case ast.InlineTable:
+		return s.checkInlineTable(parentIdx, value)
+	case ast.Array:
+		return s.checkArray(parentIdx, value)
 	}
 
 	return nil
 }
+
+func (s *SeenTracker) checkArray(parentIdx int, node *ast.Node) error {
+	set := false
+	it := node.Children()
+	for it.Next() {
+		if set {
+			s.clear(parentIdx)
+		}
+		n := it.Node()
+		switch n.Kind {
+		case ast.InlineTable:
+			err := s.checkInlineTable(parentIdx, n)
+			if err != nil {
+				return err
+			}
+			set = true
+		case ast.Array:
+			err := s.checkArray(parentIdx, n)
+			if err != nil {
+				return err
+			}
+			set = true
+		}
+	}
+	return nil
+}
+
+func (s *SeenTracker) checkInlineTable(parentIdx int, node *ast.Node) error {
+	it := node.Children()
+	for it.Next() {
+		n := it.Node()
+		err := s.checkKeyValue(parentIdx, n)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *SeenTracker) id(idx int) int {
+	if idx >= 0 {
+		return s.entries[idx].id
+	}
+	return 0
+}
+
+func (s *SeenTracker) find(parentIdx int, k []byte) int {
+	parentID := s.id(parentIdx)
+
+	for i := parentIdx + 1; i < len(s.entries); i++ {
+		if s.entries[i].parent == parentID && bytes.Equal(s.entries[i].name, k) {
+			return i
+		}
+	}
+
+	return -1
+}

localtime.go

@@ -1,300 +1,120 @@
-// Implementation of TOML's local date/time.
-// Copied over from https://github.com/googleapis/google-cloud-go/blob/master/civil/civil.go
-// to avoid pulling all the Google dependencies.
-//
-// Copyright 2016 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package civil implements types for civil time, a time-zone-independent
-// representation of time that follows the rules of the proleptic
-// Gregorian calendar with exactly 24-hour days, 60-minute hours, and 60-second
-// minutes.
-//
-// Because they lack location information, these types do not represent unique
-// moments or intervals of time. Use time.Time for that purpose.
-
 package toml
 
 import (
 	"fmt"
+	"strings"
 	"time"
 )
 
-// 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.
+// LocalDate represents a calendar day in no specific timezone.
 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.
+	Year  int
+	Month int
+	Day   int
 }
 
-// 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
+// AsTime converts d into a specific time instance at midnight in zone.
+func (d LocalDate) AsTime(zone *time.Location) time.Time {
+	return time.Date(d.Year, time.Month(d.Month), d.Day, 0, 0, 0, 0, zone)
 }
 
-// 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.
+// String returns RFC 3339 representation of d.
 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()
-
-	const secondsInADay = 86400
-
-	return int(deltaUnix / secondsInADay)
-}
-
-// Before reports whether d1 occurs before future date.
-func (d LocalDate) Before(future LocalDate) bool {
-	if d.Year != future.Year {
-		return d.Year < future.Year
-	}
-
-	if d.Month != future.Month {
-		return d.Month < future.Month
-	}
-
-	return d.Day < future.Day
-}
-
-// After reports whether d1 occurs after past date.
-func (d LocalDate) After(past LocalDate) bool {
-	return past.Before(d)
-}
-
-// MarshalText implements the encoding.TextMarshaler interface.
-// The output is the result of d.String().
+// MarshalText returns RFC 3339 representation of d.
 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
+// UnmarshalText parses b using RFC 3339 to fill d.
+func (d *LocalDate) UnmarshalText(b []byte) error {
+	res, err := parseLocalDate(b)
+	if err != nil {
+		return err
+	}
+	*d = res
+	return nil
 }
 
-// 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.
+// LocalTime represents a time of day of no specific day in no specific
+// timezone.
 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]
+	Hour       int // Hour of the day: [0; 24[
+	Minute     int // Minute of the hour: [0; 60[
+	Second     int // Second of the minute: [0; 60[
+	Nanosecond int // Nanoseconds within the second:  [0, 1000000000[
+	Precision  int // Number of digits to display for Nanosecond.
 }
 
-// LocalTimeOf returns the LocalTime representing the time of day in which a time occurs
-// 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()
+// String returns RFC 3339 representation of d.
+// If d.Nanosecond and d.Precision are zero, the time won't have a nanosecond
+// component. If d.Nanosecond > 0 but d.Precision = 0, then the minimum number
+// of digits for nanoseconds is provided.
+func (d LocalTime) String() string {
+	s := fmt.Sprintf("%02d:%02d:%02d", d.Hour, d.Minute, d.Second)
 
-	return tm
+	if d.Precision > 0 {
+		s += fmt.Sprintf(".%09d", d.Nanosecond)[:d.Precision+1]
+	} else if d.Nanosecond > 0 {
+		// Nanoseconds are specified, but precision is not provided. Use the
+		// minimum.
+		s += strings.Trim(fmt.Sprintf(".%09d", d.Nanosecond), "0")
+	}
+
+	return s
 }
 
-// ParseLocalTime parses a string and returns the time value it represents.
-// 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)
+// MarshalText returns RFC 3339 representation of d.
+func (d LocalTime) MarshalText() ([]byte, error) {
+	return []byte(d.String()), nil
+}
+
+// UnmarshalText parses b using RFC 3339 to fill d.
+func (d *LocalTime) UnmarshalText(b []byte) error {
+	res, left, err := parseLocalTime(b)
+	if err == nil && len(left) != 0 {
+		err = newDecodeError(left, "extra characters")
+	}
 	if err != nil {
-		return LocalTime{}, err
+		return err
 	}
-
-	return LocalTimeOf(t), nil
+	*d = res
+	return nil
 }
 
-// String returns the date in the format described in ParseLocalTime. If Nanoseconds
-// 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.
+// LocalDateTime represents a time of a specific day in no specific timezone.
 type LocalDateTime struct {
-	Date LocalDate
-	Time LocalTime
+	LocalDate
+	LocalTime
 }
 
-// Note: We deliberately do not embed LocalDate into LocalDateTime, to avoid promoting AddDays and Sub.
+// AsTime converts d into a specific time instance in zone.
+func (d LocalDateTime) AsTime(zone *time.Location) time.Time {
+	return time.Date(d.Year, time.Month(d.Month), d.Day, d.Hour, d.Minute, d.Second, d.Nanosecond, zone)
+}
 
-// LocalDateTimeOf returns the LocalDateTime in which a time occurs in that time's location.
-func LocalDateTimeOf(t time.Time) LocalDateTime {
-	return LocalDateTime{
-		Date: LocalDateOf(t),
-		Time: LocalTimeOf(t),
+// String returns RFC 3339 representation of d.
+func (d LocalDateTime) String() string {
+	return d.LocalDate.String() + "T" + d.LocalTime.String()
+}
+
+// MarshalText returns RFC 3339 representation of d.
+func (d LocalDateTime) MarshalText() ([]byte, error) {
+	return []byte(d.String()), nil
+}
+
+// UnmarshalText parses b using RFC 3339 to fill d.
+func (d *LocalDateTime) UnmarshalText(data []byte) error {
+	res, left, err := parseLocalDateTime(data)
+	if err == nil && len(left) != 0 {
+		err = newDecodeError(left, "extra characters")
 	}
-}
-
-// ParseLocalDateTime parses a string and returns the LocalDateTime it represents.
-// ParseLocalDateTime accepts a variant of the RFC3339 date-time format that omits
-// the time offset but includes an optional fractional time, as described in
-// ParseLocalTime. Informally, the accepted format is
-//     YYYY-MM-DDTHH:MM:SS[.FFFFFFFFF]
-// where the 'T' may be a lower-case 't'.
-func ParseLocalDateTime(s string) (LocalDateTime, error) {
-	t, err := time.Parse("2006-01-02T15:04:05.999999999", s)
 	if err != nil {
-		t, err = time.Parse("2006-01-02t15:04:05.999999999", s)
-		if err != nil {
-			return LocalDateTime{}, err
-		}
+		return 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 dt occurs before future.
-func (dt LocalDateTime) Before(future LocalDateTime) bool {
-	return dt.In(time.UTC).Before(future.In(time.UTC))
-}
-
-// After reports whether dt occurs after past.
-func (dt LocalDateTime) After(past LocalDateTime) bool {
-	return past.Before(dt)
-}
-
-// 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
+	*d = res
+	return nil
 }

localtime_test.go

@@ -1,507 +1,118 @@
-// 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
+package toml_test
 
 import (
-	"encoding/json"
-	"reflect"
 	"testing"
 	"time"
+
+	"github.com/pelletier/go-toml/v2"
+	"github.com/stretchr/testify/require"
 )
 
-func cmpEqual(x, y interface{}) bool {
-	return reflect.DeepEqual(x, y)
+func TestLocalDate_AsTime(t *testing.T) {
+	d := toml.LocalDate{2021, 6, 8}
+	cast := d.AsTime(time.UTC)
+	require.Equal(t, time.Date(2021, time.June, 8, 0, 0, 0, 0, time.UTC), cast)
 }
 
-func TestDates(t *testing.T) {
-	t.Parallel()
-
-	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 TestLocalDate_String(t *testing.T) {
+	d := toml.LocalDate{2021, 6, 8}
+	require.Equal(t, "2021-06-08", d.String())
 }
 
-func TestDateIsValid(t *testing.T) {
-	t.Parallel()
-
-	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 TestLocalDate_MarshalText(t *testing.T) {
+	d := toml.LocalDate{2021, 6, 8}
+	b, err := d.MarshalText()
+	require.NoError(t, err)
+	require.Equal(t, []byte("2021-06-08"), b)
 }
 
-func TestParseDate(t *testing.T) {
-	t.Parallel()
+func TestLocalDate_UnmarshalMarshalText(t *testing.T) {
+	d := toml.LocalDate{}
+	err := d.UnmarshalText([]byte("2021-06-08"))
+	require.NoError(t, err)
+	require.Equal(t, toml.LocalDate{2021, 6, 8}, d)
 
-	var emptyDate LocalDate
-
-	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", emptyDate},
-		{"", emptyDate},
-		{"2016-01-02x", emptyDate},
-	} {
-		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 != (emptyDate) {
-			t.Errorf("Unexpected error %v from ParseLocalDate(%q)", err, test.str)
-		}
-	}
+	err = d.UnmarshalText([]byte("what"))
+	require.Error(t, err)
 }
 
-func TestDateArithmetic(t *testing.T) {
-	t.Parallel()
-
-	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 TestLocalTime_String(t *testing.T) {
+	d := toml.LocalTime{20, 12, 1, 2, 9}
+	require.Equal(t, "20:12:01.000000002", d.String())
+	d = toml.LocalTime{20, 12, 1, 0, 0}
+	require.Equal(t, "20:12:01", d.String())
+	d = toml.LocalTime{20, 12, 1, 0, 9}
+	require.Equal(t, "20:12:01.000000000", d.String())
+	d = toml.LocalTime{20, 12, 1, 100, 0}
+	require.Equal(t, "20:12:01.0000001", d.String())
 }
 
-func TestDateBefore(t *testing.T) {
-	t.Parallel()
-
-	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 TestLocalTime_MarshalText(t *testing.T) {
+	d := toml.LocalTime{20, 12, 1, 2, 9}
+	b, err := d.MarshalText()
+	require.NoError(t, err)
+	require.Equal(t, []byte("20:12:01.000000002"), b)
 }
 
-func TestDateAfter(t *testing.T) {
-	t.Parallel()
+func TestLocalTime_UnmarshalMarshalText(t *testing.T) {
+	d := toml.LocalTime{}
+	err := d.UnmarshalText([]byte("20:12:01.000000002"))
+	require.NoError(t, err)
+	require.Equal(t, toml.LocalTime{20, 12, 1, 2, 9}, d)
 
-	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)
-		}
-	}
+	err = d.UnmarshalText([]byte("what"))
+	require.Error(t, err)
+
+	err = d.UnmarshalText([]byte("20:12:01.000000002 bad"))
+	require.Error(t, err)
 }
 
-func TestTimeToString(t *testing.T) {
-	t.Parallel()
-
-	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 TestLocalTime_RoundTrip(t *testing.T) {
+	var d struct{ A toml.LocalTime }
+	err := toml.Unmarshal([]byte("a=20:12:01.500"), &d)
+	require.NoError(t, err)
+	require.Equal(t, "20:12:01.500", d.A.String())
 }
 
-func TestTimeOf(t *testing.T) {
-	t.Parallel()
-
-	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 TestLocalDateTime_AsTime(t *testing.T) {
+	d := toml.LocalDateTime{
+		toml.LocalDate{2021, 6, 8},
+		toml.LocalTime{20, 12, 1, 2, 9},
 	}
+	cast := d.AsTime(time.UTC)
+	require.Equal(t, time.Date(2021, time.June, 8, 20, 12, 1, 2, time.UTC), cast)
 }
 
-func TestTimeIsValid(t *testing.T) {
-	t.Parallel()
-
-	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 TestLocalDateTime_String(t *testing.T) {
+	d := toml.LocalDateTime{
+		toml.LocalDate{2021, 6, 8},
+		toml.LocalTime{20, 12, 1, 2, 9},
 	}
+	require.Equal(t, "2021-06-08T20:12:01.000000002", d.String())
 }
 
-func TestDateTimeToString(t *testing.T) {
-	t.Parallel()
-
-	for _, test := range []struct {
-		str       string
-		dateTime  LocalDateTime
-		roundTrip bool // ParseLocalDateTime(str).String() == str?
-	}{
-		{"2016-03-22T13:26:33", LocalDateTime{LocalDate{2016, 3, 22}, LocalTime{13, 26, 33, 0}}, true},
-		{"2016-03-22T13:26:33.000000600", LocalDateTime{LocalDate{2016, 3, 22}, LocalTime{13, 26, 33, 600}}, true},
-		{"2016-03-22t13:26:33", LocalDateTime{LocalDate{2016, 3, 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 TestLocalDateTime_MarshalText(t *testing.T) {
+	d := toml.LocalDateTime{
+		toml.LocalDate{2021, 6, 8},
+		toml.LocalTime{20, 12, 1, 2, 9},
 	}
+	b, err := d.MarshalText()
+	require.NoError(t, err)
+	require.Equal(t, []byte("2021-06-08T20:12:01.000000002"), b)
 }
 
-func TestParseDateTimeErrors(t *testing.T) {
-	t.Parallel()
+func TestLocalDateTime_UnmarshalMarshalText(t *testing.T) {
+	d := toml.LocalDateTime{}
+	err := d.UnmarshalText([]byte("2021-06-08 20:12:01.000000002"))
+	require.NoError(t, err)
+	require.Equal(t, toml.LocalDateTime{
+		toml.LocalDate{2021, 6, 8},
+		toml.LocalTime{20, 12, 1, 2, 9},
+	}, d)
 
-	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) {
-	t.Parallel()
-
-	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) {
-	t.Parallel()
-
-	// 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) {
-	t.Parallel()
-
-	dt := LocalDateTime{LocalDate{2016, 1, 2}, LocalTime{3, 4, 5, 6}}
-
-	want := time.Date(2016, 1, 2, 3, 4, 5, 6, time.UTC)
-	if got := dt.In(time.UTC); !got.Equal(want) {
-		t.Errorf("got %v, want %v", got, want)
-	}
-}
-
-func TestDateTimeBefore(t *testing.T) {
-	t.Parallel()
-
-	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) {
-	t.Parallel()
-
-	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) {
-	t.Parallel()
-
-	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) {
-	t.Parallel()
-
-	var (
-		d  LocalDate
-		tm LocalTime
-		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)
-		}
-	}
+	err = d.UnmarshalText([]byte("what"))
+	require.Error(t, err)
+
+	err = d.UnmarshalText([]byte("2021-06-08 20:12:01.000000002 bad"))
+	require.Error(t, err)
 }

marshaler.go

@@ -5,6 +5,7 @@ import (
 	"encoding"
 	"fmt"
 	"io"
+	"math"
 	"reflect"
 	"sort"
 	"strconv"
@@ -53,8 +54,9 @@ func NewEncoder(w io.Writer) *Encoder {
 // inline tag:
 //
 //   MyField `inline:"true"`
-func (enc *Encoder) SetTablesInline(inline bool) {
+func (enc *Encoder) SetTablesInline(inline bool) *Encoder {
 	enc.tablesInline = inline
+	return enc
 }
 
 // SetArraysMultiline forces the encoder to emit all arrays with one element per
@@ -63,20 +65,23 @@ func (enc *Encoder) SetTablesInline(inline bool) {
 // This behavior can be controlled on an individual struct field basis with the multiline tag:
 //
 //   MyField `multiline:"true"`
-func (enc *Encoder) SetArraysMultiline(multiline bool) {
+func (enc *Encoder) SetArraysMultiline(multiline bool) *Encoder {
 	enc.arraysMultiline = multiline
+	return enc
 }
 
 // SetIndentSymbol defines the string that should be used for indentation. The
 // provided string is repeated for each indentation level. Defaults to two
 // spaces.
-func (enc *Encoder) SetIndentSymbol(s string) {
+func (enc *Encoder) SetIndentSymbol(s string) *Encoder {
 	enc.indentSymbol = s
+	return enc
 }
 
 // SetIndentTables forces the encoder to intent tables and array tables.
-func (enc *Encoder) SetIndentTables(indent bool) {
+func (enc *Encoder) SetIndentTables(indent bool) *Encoder {
 	enc.indentTables = indent
+	return enc
 }
 
 // Encode writes a TOML representation of v to the stream.
@@ -244,9 +249,17 @@ func (enc *Encoder) encode(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, e
 	case reflect.String:
 		b = enc.encodeString(b, v.String(), ctx.options)
 	case reflect.Float32:
-		b = strconv.AppendFloat(b, v.Float(), 'f', -1, 32)
+		if math.Trunc(v.Float()) == v.Float() {
+			b = strconv.AppendFloat(b, v.Float(), 'f', 1, 32)
+		} else {
+			b = strconv.AppendFloat(b, v.Float(), 'f', -1, 32)
+		}
 	case reflect.Float64:
-		b = strconv.AppendFloat(b, v.Float(), 'f', -1, 64)
+		if math.Trunc(v.Float()) == v.Float() {
+			b = strconv.AppendFloat(b, v.Float(), 'f', 1, 64)
+		} else {
+			b = strconv.AppendFloat(b, v.Float(), 'f', -1, 64)
+		}
 	case reflect.Bool:
 		if v.Bool() {
 			b = append(b, "true"...)
@@ -640,9 +653,10 @@ func (enc *Encoder) encodeTableInline(b []byte, ctx encoderCtx, t table) ([]byte
 	return b, nil
 }
 
-var textMarshalerType = reflect.TypeOf(new(encoding.TextMarshaler)).Elem()
-
 func willConvertToTable(ctx encoderCtx, v reflect.Value) bool {
+	if !v.IsValid() {
+		return false
+	}
 	if v.Type() == timeType || v.Type().Implements(textMarshalerType) {
 		return false
 	}

marshaler_test.go

@@ -14,8 +14,6 @@ import (
 
 //nolint:funlen
 func TestMarshal(t *testing.T) {
-	t.Parallel()
-
 	someInt := 42
 
 	type structInline struct {
@@ -516,8 +514,6 @@ K = 42`,
 	for _, e := range examples {
 		e := e
 		t.Run(e.desc, func(t *testing.T) {
-			t.Parallel()
-
 			b, err := toml.Marshal(e.v)
 			if e.err {
 				require.Error(t, err)
@@ -555,7 +551,7 @@ K = 42`,
 
 type flagsSetters []struct {
 	name string
-	f    func(enc *toml.Encoder, flag bool)
+	f    func(enc *toml.Encoder, flag bool) *toml.Encoder
 }
 
 var allFlags = flagsSetters{
@@ -609,8 +605,6 @@ func equalStringsIgnoreNewlines(t *testing.T, expected string, actual string) {
 
 //nolint:funlen
 func TestMarshalIndentTables(t *testing.T) {
-	t.Parallel()
-
 	examples := []struct {
 		desc     string
 		v        interface{}
@@ -661,8 +655,6 @@ root = 'value0'
 	for _, e := range examples {
 		e := e
 		t.Run(e.desc, func(t *testing.T) {
-			t.Parallel()
-
 			var buf strings.Builder
 			enc := toml.NewEncoder(&buf)
 			enc.SetIndentTables(true)
@@ -685,24 +677,18 @@ func (c *customTextMarshaler) MarshalText() ([]byte, error) {
 }
 
 func TestMarshalTextMarshaler_NoRoot(t *testing.T) {
-	t.Parallel()
-
 	c := customTextMarshaler{}
 	_, err := toml.Marshal(&c)
 	require.Error(t, err)
 }
 
 func TestMarshalTextMarshaler_Error(t *testing.T) {
-	t.Parallel()
-
 	m := map[string]interface{}{"a": &customTextMarshaler{value: 1}}
 	_, err := toml.Marshal(m)
 	require.Error(t, err)
 }
 
 func TestMarshalTextMarshaler_ErrorInline(t *testing.T) {
-	t.Parallel()
-
 	type s struct {
 		A map[string]interface{} `inline:"true"`
 	}
@@ -716,8 +702,6 @@ func TestMarshalTextMarshaler_ErrorInline(t *testing.T) {
 }
 
 func TestMarshalTextMarshaler(t *testing.T) {
-	t.Parallel()
-
 	m := map[string]interface{}{"a": &customTextMarshaler{value: 2}}
 	r, err := toml.Marshal(m)
 	require.NoError(t, err)
@@ -731,7 +715,6 @@ func (b *brokenWriter) Write([]byte) (int, error) {
 }
 
 func TestEncodeToBrokenWriter(t *testing.T) {
-	t.Parallel()
 	w := brokenWriter{}
 	enc := toml.NewEncoder(&w)
 	err := enc.Encode(map[string]string{"hello": "world"})
@@ -739,7 +722,6 @@ func TestEncodeToBrokenWriter(t *testing.T) {
 }
 
 func TestEncoderSetIndentSymbol(t *testing.T) {
-	t.Parallel()
 	var w strings.Builder
 	enc := toml.NewEncoder(&w)
 	enc.SetIndentTables(true)
@@ -753,8 +735,6 @@ func TestEncoderSetIndentSymbol(t *testing.T) {
 }
 
 func TestIssue436(t *testing.T) {
-	t.Parallel()
-
 	data := []byte(`{"a": [ { "b": { "c": "d" } } ]}`)
 
 	var v interface{}
@@ -774,8 +754,6 @@ c = 'd'
 }
 
 func TestIssue424(t *testing.T) {
-	t.Parallel()
-
 	type Message1 struct {
 		Text string
 	}
@@ -804,6 +782,22 @@ func TestIssue424(t *testing.T) {
 	require.Equal(t, msg2, msg2parsed)
 }
 
+func TestIssue567(t *testing.T) {
+	var m map[string]interface{}
+	err := toml.Unmarshal([]byte("A = 12:08:05"), &m)
+	require.NoError(t, err)
+	require.IsType(t, m["A"], toml.LocalTime{})
+}
+
+func TestIssue590(t *testing.T) {
+	type CustomType int
+	var cfg struct {
+		Option CustomType `toml:"option"`
+	}
+	err := toml.Unmarshal([]byte("option = 42"), &cfg)
+	require.NoError(t, err)
+}
+
 func ExampleMarshal() {
 	type MyConfig struct {
 		Version int
@@ -828,3 +822,26 @@ func ExampleMarshal() {
 	// Name = 'go-toml'
 	// Tags = ['go', 'toml']
 }
+
+func TestIssue571(t *testing.T) {
+	type Foo struct {
+		Float32 float32
+		Float64 float64
+	}
+
+	const closeEnough = 1e-9
+
+	foo := Foo{
+		Float32: 42,
+		Float64: 43,
+	}
+	b, err := toml.Marshal(foo)
+	require.NoError(t, err)
+
+	var foo2 Foo
+	err = toml.Unmarshal(b, &foo2)
+	require.NoError(t, err)
+
+	assert.InDelta(t, 42, foo2.Float32, closeEnough)
+	assert.InDelta(t, 43, foo2.Float64, closeEnough)
+}

parser.go

@@ -2,9 +2,10 @@ package toml
 
 import (
 	"bytes"
-	"strconv"
+	"unicode"
 
 	"github.com/pelletier/go-toml/v2/internal/ast"
+	"github.com/pelletier/go-toml/v2/internal/danger"
 )
 
 type parser struct {
@@ -16,9 +17,20 @@ type parser struct {
 	first   bool
 }
 
+func (p *parser) Range(b []byte) ast.Range {
+	return ast.Range{
+		Offset: uint32(danger.SubsliceOffset(p.data, b)),
+		Length: uint32(len(b)),
+	}
+}
+
+func (p *parser) Raw(raw ast.Range) []byte {
+	return p.data[raw.Offset : raw.Offset+raw.Length]
+}
+
 func (p *parser) Reset(b []byte) {
 	p.builder.Reset()
-	p.ref = ast.Reference{}
+	p.ref = ast.InvalidReference
 	p.data = b
 	p.left = b
 	p.err = nil
@@ -32,7 +44,7 @@ func (p *parser) NextExpression() bool {
 	}
 
 	p.builder.Reset()
-	p.ref = ast.Reference{}
+	p.ref = ast.InvalidReference
 
 	for {
 		if len(p.left) == 0 || p.err != nil {
@@ -61,7 +73,7 @@ func (p *parser) NextExpression() bool {
 	}
 }
 
-func (p *parser) Expression() ast.Node {
+func (p *parser) Expression() *ast.Node {
 	return p.builder.NodeAt(p.ref)
 }
 
@@ -86,7 +98,7 @@ func (p *parser) parseExpression(b []byte) (ast.Reference, []byte, error) {
 	// expression =  ws [ comment ]
 	// expression =/ ws keyval ws [ comment ]
 	// expression =/ ws table ws [ comment ]
-	var ref ast.Reference
+	ref := ast.InvalidReference
 
 	b = p.parseWhitespace(b)
 
@@ -95,9 +107,8 @@ func (p *parser) parseExpression(b []byte) (ast.Reference, []byte, error) {
 	}
 
 	if b[0] == '#' {
-		_, rest := scanComment(b)
-
-		return ref, rest, nil
+		_, rest, err := scanComment(b)
+		return ref, rest, err
 	}
 
 	if b[0] == '\n' || b[0] == '\r' {
@@ -118,9 +129,8 @@ func (p *parser) parseExpression(b []byte) (ast.Reference, []byte, error) {
 	b = p.parseWhitespace(b)
 
 	if len(b) > 0 && b[0] == '#' {
-		_, rest := scanComment(b)
-
-		return ref, rest, nil
+		_, rest, err := scanComment(b)
+		return ref, rest, err
 	}
 
 	return ref, b, nil
@@ -197,7 +207,7 @@ func (p *parser) parseKeyval(b []byte) (ast.Reference, []byte, error) {
 
 	key, b, err := p.parseKey(b)
 	if err != nil {
-		return ast.Reference{}, nil, err
+		return ast.InvalidReference, nil, err
 	}
 
 	// keyval-sep = ws %x3D ws ; =
@@ -205,12 +215,12 @@ func (p *parser) parseKeyval(b []byte) (ast.Reference, []byte, error) {
 	b = p.parseWhitespace(b)
 
 	if len(b) == 0 {
-		return ast.Reference{}, nil, newDecodeError(b, "expected = after a key, but the document ends there")
+		return ast.InvalidReference, nil, newDecodeError(b, "expected = after a key, but the document ends there")
 	}
 
 	b, err = expect('=', b)
 	if err != nil {
-		return ast.Reference{}, nil, err
+		return ast.InvalidReference, nil, err
 	}
 
 	b = p.parseWhitespace(b)
@@ -229,7 +239,7 @@ func (p *parser) parseKeyval(b []byte) (ast.Reference, []byte, error) {
 //nolint:cyclop,funlen
 func (p *parser) parseVal(b []byte) (ast.Reference, []byte, error) {
 	// val = string / boolean / array / inline-table / date-time / float / integer
-	var ref ast.Reference
+	ref := ast.InvalidReference
 
 	if len(b) == 0 {
 		return ref, nil, newDecodeError(b, "expected value, not eof")
@@ -240,32 +250,36 @@ func (p *parser) parseVal(b []byte) (ast.Reference, []byte, error) {
 
 	switch c {
 	case '"':
+		var raw []byte
 		var v []byte
 		if scanFollowsMultilineBasicStringDelimiter(b) {
-			v, b, err = p.parseMultilineBasicString(b)
+			raw, v, b, err = p.parseMultilineBasicString(b)
 		} else {
-			v, b, err = p.parseBasicString(b)
+			raw, v, b, err = p.parseBasicString(b)
 		}
 
 		if err == nil {
 			ref = p.builder.Push(ast.Node{
 				Kind: ast.String,
+				Raw:  p.Range(raw),
 				Data: v,
 			})
 		}
 
 		return ref, b, err
 	case '\'':
+		var raw []byte
 		var v []byte
 		if scanFollowsMultilineLiteralStringDelimiter(b) {
-			v, b, err = p.parseMultilineLiteralString(b)
+			raw, v, b, err = p.parseMultilineLiteralString(b)
 		} else {
-			v, b, err = p.parseLiteralString(b)
+			raw, v, b, err = p.parseLiteralString(b)
 		}
 
 		if err == nil {
 			ref = p.builder.Push(ast.Node{
 				Kind: ast.String,
+				Raw:  p.Range(raw),
 				Data: v,
 			})
 		}
@@ -310,13 +324,13 @@ func atmost(b []byte, n int) []byte {
 	return b[:n]
 }
 
-func (p *parser) parseLiteralString(b []byte) ([]byte, []byte, error) {
+func (p *parser) parseLiteralString(b []byte) ([]byte, []byte, []byte, error) {
 	v, rest, err := scanLiteralString(b)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 
-	return v[1 : len(v)-1], rest, nil
+	return v, v[1 : len(v)-1], rest, nil
 }
 
 func (p *parser) parseInlineTable(b []byte) (ast.Reference, []byte, error) {
@@ -338,7 +352,13 @@ func (p *parser) parseInlineTable(b []byte) (ast.Reference, []byte, error) {
 	var err error
 
 	for len(b) > 0 {
+		previousB := b
 		b = p.parseWhitespace(b)
+
+		if len(b) == 0 {
+			return parent, nil, newDecodeError(previousB[:1], "inline table is incomplete")
+		}
+
 		if b[0] == '}' {
 			break
 		}
@@ -382,6 +402,7 @@ func (p *parser) parseValArray(b []byte) (ast.Reference, []byte, error) {
 	// array-values =/ ws-comment-newline val ws-comment-newline [ array-sep ]
 	// array-sep = %x2C  ; , Comma
 	// ws-comment-newline = *( wschar / [ comment ] newline )
+	arrayStart := b
 	b = b[1:]
 
 	parent := p.builder.Push(ast.Node{
@@ -400,7 +421,7 @@ func (p *parser) parseValArray(b []byte) (ast.Reference, []byte, error) {
 		}
 
 		if len(b) == 0 {
-			return parent, nil, newDecodeError(b, "array is incomplete")
+			return parent, nil, newDecodeError(arrayStart[:1], "array is incomplete")
 		}
 
 		if b[0] == ']' {
@@ -417,6 +438,8 @@ func (p *parser) parseValArray(b []byte) (ast.Reference, []byte, error) {
 			if err != nil {
 				return parent, nil, err
 			}
+		} else if !first {
+			return parent, nil, newDecodeError(b[0:1], "array elements must be separated by commas")
 		}
 
 		// TOML allows trailing commas in arrays.
@@ -425,7 +448,6 @@ func (p *parser) parseValArray(b []byte) (ast.Reference, []byte, error) {
 		}
 
 		var valueRef ast.Reference
-
 		valueRef, b, err = p.parseVal(b)
 		if err != nil {
 			return parent, nil, err
@@ -456,7 +478,10 @@ func (p *parser) parseOptionalWhitespaceCommentNewline(b []byte) ([]byte, error)
 		b = p.parseWhitespace(b)
 
 		if len(b) > 0 && b[0] == '#' {
-			_, b = scanComment(b)
+			_, b, err = scanComment(b)
+			if err != nil {
+				return nil, err
+			}
 		}
 
 		if len(b) == 0 {
@@ -476,10 +501,10 @@ func (p *parser) parseOptionalWhitespaceCommentNewline(b []byte) ([]byte, error)
 	return b, nil
 }
 
-func (p *parser) parseMultilineLiteralString(b []byte) ([]byte, []byte, error) {
+func (p *parser) parseMultilineLiteralString(b []byte) ([]byte, []byte, []byte, error) {
 	token, rest, err := scanMultilineLiteralString(b)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 
 	i := 3
@@ -491,11 +516,11 @@ func (p *parser) parseMultilineLiteralString(b []byte) ([]byte, []byte, error) {
 		i += 2
 	}
 
-	return token[i : len(token)-3], rest, err
+	return token, token[i : len(token)-3], rest, err
 }
 
 //nolint:funlen,gocognit,cyclop
-func (p *parser) parseMultilineBasicString(b []byte) ([]byte, []byte, error) {
+func (p *parser) parseMultilineBasicString(b []byte) ([]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
@@ -506,13 +531,11 @@ func (p *parser) parseMultilineBasicString(b []byte) ([]byte, []byte, error) {
 	// mlb-quotes = 1*2quotation-mark
 	// mlb-unescaped = wschar / %x21 / %x23-5B / %x5D-7E / non-ascii
 	// mlb-escaped-nl = escape ws newline *( wschar / newline )
-	token, rest, err := scanMultilineBasicString(b)
+	token, escaped, rest, err := scanMultilineBasicString(b)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 
-	var builder bytes.Buffer
-
 	i := 3
 
 	// skip the immediate new line
@@ -522,9 +545,24 @@ func (p *parser) parseMultilineBasicString(b []byte) ([]byte, []byte, error) {
 		i += 2
 	}
 
+	// fast path
+	startIdx := i
+	endIdx := len(token) - len(`"""`)
+
+	if !escaped {
+		str := token[startIdx:endIdx]
+		verr := utf8TomlValidAlreadyEscaped(str)
+		if verr.Zero() {
+			return token, str, rest, nil
+		}
+		return nil, nil, nil, newDecodeError(str[verr.Index:verr.Index+verr.Size], "invalid UTF-8")
+	}
+
+	var builder bytes.Buffer
+
 	// The scanner ensures that the token starts and ends with quotes and that
 	// escapes are balanced.
-	for ; i < len(token)-3; i++ {
+	for i < len(token)-3 {
 		c := token[i]
 
 		//nolint:nestif
@@ -532,17 +570,29 @@ func (p *parser) parseMultilineBasicString(b []byte) ([]byte, []byte, error) {
 			// When the last non-whitespace character on a line is an unescaped \,
 			// it will be trimmed along with all whitespace (including newlines) up
 			// to the next non-whitespace character or closing delimiter.
-			if token[i+1] == '\n' || (token[i+1] == '\r' && token[i+2] == '\n') {
-				i++ // skip the \
+
+			isLastNonWhitespaceOnLine := false
+			j := 1
+		findEOLLoop:
+			for ; j < len(token)-3-i; j++ {
+				switch token[i+j] {
+				case ' ', '\t':
+					continue
+				case '\n':
+					isLastNonWhitespaceOnLine = true
+				}
+				break findEOLLoop
+			}
+			if isLastNonWhitespaceOnLine {
+				i += j
 				for ; i < len(token)-3; i++ {
 					c := token[i]
 					if !(c == '\n' || c == '\r' || c == ' ' || c == '\t') {
 						i--
-
 						break
 					}
 				}
-
+				i++
 				continue
 			}
 
@@ -564,30 +614,35 @@ func (p *parser) parseMultilineBasicString(b []byte) ([]byte, []byte, error) {
 			case 't':
 				builder.WriteByte('\t')
 			case 'u':
-				x, err := hexToString(atmost(token[i+1:], 4), 4)
+				x, err := hexToRune(atmost(token[i+1:], 4), 4)
 				if err != nil {
-					return nil, nil, err
+					return nil, nil, nil, err
 				}
-
-				builder.WriteString(x)
+				builder.WriteRune(x)
 				i += 4
 			case 'U':
-				x, err := hexToString(atmost(token[i+1:], 8), 8)
+				x, err := hexToRune(atmost(token[i+1:], 8), 8)
 				if err != nil {
-					return nil, nil, err
+					return nil, nil, nil, err
 				}
 
-				builder.WriteString(x)
+				builder.WriteRune(x)
 				i += 8
 			default:
-				return nil, nil, newDecodeError(token[i:i+1], "invalid escaped character %#U", c)
+				return nil, nil, nil, newDecodeError(token[i:i+1], "invalid escaped character %#U", c)
 			}
+			i++
 		} else {
-			builder.WriteByte(c)
+			size := utf8ValidNext(token[i:])
+			if size == 0 {
+				return nil, nil, nil, newDecodeError(token[i:i+1], "invalid character %#U", c)
+			}
+			builder.Write(token[i : i+size])
+			i += size
 		}
 	}
 
-	return builder.Bytes(), rest, nil
+	return token, builder.Bytes(), rest, nil
 }
 
 func (p *parser) parseKey(b []byte) (ast.Reference, []byte, error) {
@@ -599,13 +654,14 @@ func (p *parser) parseKey(b []byte) (ast.Reference, []byte, error) {
 	// dotted-key = simple-key 1*( dot-sep simple-key )
 	//
 	// dot-sep   = ws %x2E ws  ; . Period
-	key, b, err := p.parseSimpleKey(b)
+	raw, key, b, err := p.parseSimpleKey(b)
 	if err != nil {
-		return ast.Reference{}, nil, err
+		return ast.InvalidReference, nil, err
 	}
 
 	ref := p.builder.Push(ast.Node{
 		Kind: ast.Key,
+		Raw:  p.Range(raw),
 		Data: key,
 	})
 
@@ -614,13 +670,14 @@ func (p *parser) parseKey(b []byte) (ast.Reference, []byte, error) {
 		if len(b) > 0 && b[0] == '.' {
 			b = p.parseWhitespace(b[1:])
 
-			key, b, err = p.parseSimpleKey(b)
+			raw, key, b, err = p.parseSimpleKey(b)
 			if err != nil {
 				return ref, nil, err
 			}
 
 			p.builder.PushAndChain(ast.Node{
 				Kind: ast.Key,
+				Raw:  p.Range(raw),
 				Data: key,
 			})
 		} else {
@@ -631,14 +688,10 @@ func (p *parser) parseKey(b []byte) (ast.Reference, []byte, error) {
 	return ref, b, nil
 }
 
-func (p *parser) parseSimpleKey(b []byte) (key, rest []byte, err error) {
+func (p *parser) parseSimpleKey(b []byte) (raw, key, rest []byte, err error) {
 	// simple-key = quoted-key / unquoted-key
 	// unquoted-key = 1*( ALPHA / DIGIT / %x2D / %x5F ) ; A-Z / a-z / 0-9 / - / _
 	// quoted-key = basic-string / literal-string
-	if len(b) == 0 {
-		return nil, nil, newDecodeError(b, "key is incomplete")
-	}
-
 	switch {
 	case b[0] == '\'':
 		return p.parseLiteralString(b)
@@ -646,14 +699,14 @@ func (p *parser) parseSimpleKey(b []byte) (key, rest []byte, err error) {
 		return p.parseBasicString(b)
 	case isUnquotedKeyChar(b[0]):
 		key, rest = scanUnquotedKey(b)
-		return key, rest, nil
+		return key, key, rest, nil
 	default:
-		return nil, nil, newDecodeError(b[0:1], "invalid character at start of key: %c", b[0])
+		return nil, nil, nil, newDecodeError(b[0:1], "invalid character at start of key: %c", b[0])
 	}
 }
 
 //nolint:funlen,cyclop
-func (p *parser) parseBasicString(b []byte) ([]byte, []byte, error) {
+func (p *parser) parseBasicString(b []byte) ([]byte, []byte, []byte, error) {
 	// basic-string = quotation-mark *basic-char quotation-mark
 	// quotation-mark = %x22            ; "
 	// basic-char = basic-unescaped / escaped
@@ -668,16 +721,33 @@ func (p *parser) parseBasicString(b []byte) ([]byte, []byte, error) {
 	// escape-seq-char =/ %x74         ; t    tab             U+0009
 	// escape-seq-char =/ %x75 4HEXDIG ; uXXXX                U+XXXX
 	// escape-seq-char =/ %x55 8HEXDIG ; UXXXXXXXX            U+XXXXXXXX
-	token, rest, err := scanBasicString(b)
+	token, escaped, rest, err := scanBasicString(b)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 
+	startIdx := len(`"`)
+	endIdx := len(token) - len(`"`)
+
+	// Fast path. If there is no escape sequence, the string should just be
+	// an UTF-8 encoded string, which is the same as Go. In that case,
+	// validate the string and return a direct reference to the buffer.
+	if !escaped {
+		str := token[startIdx:endIdx]
+		verr := utf8TomlValidAlreadyEscaped(str)
+		if verr.Zero() {
+			return token, str, rest, nil
+		}
+		return nil, nil, nil, newDecodeError(str[verr.Index:verr.Index+verr.Size], "invalid UTF-8")
+	}
+
+	i := startIdx
+
 	var builder bytes.Buffer
 
 	// The scanner ensures that the token starts and ends with quotes and that
 	// escapes are balanced.
-	for i := 1; i < len(token)-1; i++ {
+	for i < len(token)-1 {
 		c := token[i]
 		if c == '\\' {
 			i++
@@ -697,46 +767,65 @@ func (p *parser) parseBasicString(b []byte) ([]byte, []byte, error) {
 			case 't':
 				builder.WriteByte('\t')
 			case 'u':
-				x, err := hexToString(token[i+1:len(token)-1], 4)
+				x, err := hexToRune(token[i+1:len(token)-1], 4)
 				if err != nil {
-					return nil, nil, err
+					return nil, nil, nil, err
 				}
 
-				builder.WriteString(x)
+				builder.WriteRune(x)
 				i += 4
 			case 'U':
-				x, err := hexToString(token[i+1:len(token)-1], 8)
+				x, err := hexToRune(token[i+1:len(token)-1], 8)
 				if err != nil {
-					return nil, nil, err
+					return nil, nil, nil, err
 				}
 
-				builder.WriteString(x)
+				builder.WriteRune(x)
 				i += 8
 			default:
-				return nil, nil, newDecodeError(token[i:i+1], "invalid escaped character %#U", c)
+				return nil, nil, nil, newDecodeError(token[i:i+1], "invalid escaped character %#U", c)
 			}
+			i++
 		} else {
-			builder.WriteByte(c)
+			size := utf8ValidNext(token[i:])
+			if size == 0 {
+				return nil, nil, nil, newDecodeError(token[i:i+1], "invalid character %#U", c)
+			}
+			builder.Write(token[i : i+size])
+			i += size
 		}
 	}
 
-	return builder.Bytes(), rest, nil
+	return token, builder.Bytes(), rest, nil
 }
 
-func hexToString(b []byte, length int) (string, error) {
+func hexToRune(b []byte, length int) (rune, error) {
 	if len(b) < length {
-		return "", newDecodeError(b, "unicode point needs %d character, not %d", length, len(b))
+		return -1, newDecodeError(b, "unicode point needs %d character, not %d", length, len(b))
 	}
 	b = b[:length]
 
-	//nolint:godox
-	// TODO: slow
-	intcode, err := strconv.ParseInt(string(b), 16, 32)
-	if err != nil {
-		return "", newDecodeError(b, "couldn't parse hexadecimal number: %w", err)
+	var r uint32
+	for i, c := range b {
+		d := uint32(0)
+		switch {
+		case '0' <= c && c <= '9':
+			d = uint32(c - '0')
+		case 'a' <= c && c <= 'f':
+			d = uint32(c - 'a' + 10)
+		case 'A' <= c && c <= 'F':
+			d = uint32(c - 'A' + 10)
+		default:
+			return -1, newDecodeError(b[i:i+1], "non-hex character")
+		}
+		r = r*16 + d
 	}
 
-	return string(rune(intcode)), nil
+	if r > unicode.MaxRune || 0xD800 <= r && r < 0xE000 {
+		return -1, newDecodeError(b, "escape sequence is invalid Unicode code point")
+	}
+
+	return rune(r), nil
 }
 
 func (p *parser) parseWhitespace(b []byte) []byte {
@@ -753,7 +842,7 @@ func (p *parser) parseIntOrFloatOrDateTime(b []byte) (ast.Reference, []byte, err
 	switch b[0] {
 	case 'i':
 		if !scanFollowsInf(b) {
-			return ast.Reference{}, nil, newDecodeError(atmost(b, 3), "expected 'inf'")
+			return ast.InvalidReference, nil, newDecodeError(atmost(b, 3), "expected 'inf'")
 		}
 
 		return p.builder.Push(ast.Node{
@@ -762,7 +851,7 @@ func (p *parser) parseIntOrFloatOrDateTime(b []byte) (ast.Reference, []byte, err
 		}), b[3:], nil
 	case 'n':
 		if !scanFollowsNan(b) {
-			return ast.Reference{}, nil, newDecodeError(atmost(b, 3), "expected 'nan'")
+			return ast.InvalidReference, nil, newDecodeError(atmost(b, 3), "expected 'nan'")
 		}
 
 		return p.builder.Push(ast.Node{
@@ -791,6 +880,8 @@ func (p *parser) parseIntOrFloatOrDateTime(b []byte) (ast.Reference, []byte, err
 		if idx == 2 && c == ':' || (idx == 4 && c == '-') {
 			return p.scanDateTime(b)
 		}
+
+		break
 	}
 
 	return p.scanIntOrFloat(b)
@@ -811,6 +902,7 @@ func digitsToInt(b []byte) int {
 func (p *parser) scanDateTime(b []byte) (ast.Reference, []byte, error) {
 	// scans for contiguous characters in [0-9T:Z.+-], and up to one space if
 	// followed by a digit.
+	hasDate := false
 	hasTime := false
 	hasTz := false
 	seenSpace := false
@@ -823,17 +915,23 @@ byteLoop:
 		switch {
 		case isDigit(c):
 		case c == '-':
-			const offsetOfTz = 19
-			if i == offsetOfTz {
+			hasDate = true
+			const minOffsetOfTz = 8
+			if i >= minOffsetOfTz {
 				hasTz = true
 			}
-		case c == 'T' || c == ':' || c == '.':
+		case c == 'T' || c == 't' || c == ':' || c == '.':
 			hasTime = true
-		case c == '+' || c == '-' || c == 'Z':
+		case c == '+' || c == '-' || c == 'Z' || c == 'z':
 			hasTz = true
 		case c == ' ':
 			if !seenSpace && i+1 < len(b) && isDigit(b[i+1]) {
 				i += 2
+				// Avoid reaching past the end of the document in case the time
+				// is malformed. See TestIssue585.
+				if i >= len(b) {
+					i--
+				}
 				seenSpace = true
 				hasTime = true
 			} else {
@@ -847,10 +945,14 @@ byteLoop:
 	var kind ast.Kind
 
 	if hasTime {
-		if hasTz {
-			kind = ast.DateTime
+		if hasDate {
+			if hasTz {
+				kind = ast.DateTime
+			} else {
+				kind = ast.LocalDateTime
+			}
 		} else {
-			kind = ast.LocalDateTime
+			kind = ast.LocalTime
 		}
 	} else {
 		kind = ast.LocalDate
@@ -866,7 +968,7 @@ byteLoop:
 func (p *parser) scanIntOrFloat(b []byte) (ast.Reference, []byte, error) {
 	i := 0
 
-	if len(b) > 2 && b[0] == '0' && b[1] != '.' {
+	if len(b) > 2 && b[0] == '0' && b[1] != '.' && b[1] != 'e' && b[1] != 'E' {
 		var isValidRune validRuneFn
 
 		switch b[1] {
@@ -918,7 +1020,7 @@ func (p *parser) scanIntOrFloat(b []byte) (ast.Reference, []byte, error) {
 				}), b[i+3:], nil
 			}
 
-			return ast.Reference{}, nil, newDecodeError(b[i:i+1], "unexpected character 'i' while scanning for a number")
+			return ast.InvalidReference, nil, newDecodeError(b[i:i+1], "unexpected character 'i' while scanning for a number")
 		}
 
 		if c == 'n' {
@@ -929,14 +1031,14 @@ func (p *parser) scanIntOrFloat(b []byte) (ast.Reference, []byte, error) {
 				}), b[i+3:], nil
 			}
 
-			return ast.Reference{}, nil, newDecodeError(b[i:i+1], "unexpected character 'n' while scanning for a number")
+			return ast.InvalidReference, nil, newDecodeError(b[i:i+1], "unexpected character 'n' while scanning for a number")
 		}
 
 		break
 	}
 
 	if i == 0 {
-		return ast.Reference{}, b, newDecodeError(b, "incomplete number")
+		return ast.InvalidReference, b, newDecodeError(b, "incomplete number")
 	}
 
 	kind := ast.Integer
@@ -973,8 +1075,12 @@ func isValidBinaryRune(r byte) bool {
 }
 
 func expect(x byte, b []byte) ([]byte, error) {
+	if len(b) == 0 {
+		return nil, newDecodeError(b, "expected character %c but the document ended here", x)
+	}
+
 	if b[0] != x {
-		return nil, newDecodeError(b[0:1], "expected character %U", x)
+		return nil, newDecodeError(b[0:1], "expected character %c", x)
 	}
 
 	return b[1:], nil

parser_test.go

@@ -1,6 +1,8 @@
 package toml
 
 import (
+	"strconv"
+	"strings"
 	"testing"
 
 	"github.com/pelletier/go-toml/v2/internal/ast"
@@ -9,8 +11,6 @@ import (
 
 //nolint:funlen
 func TestParser_AST_Numbers(t *testing.T) {
-	t.Parallel()
-
 	examples := []struct {
 		desc  string
 		input string
@@ -137,7 +137,6 @@ func TestParser_AST_Numbers(t *testing.T) {
 	for _, e := range examples {
 		e := e
 		t.Run(e.desc, func(t *testing.T) {
-			t.Parallel()
 			p := parser{}
 			p.Reset([]byte(`A = ` + e.input))
 			p.NextExpression()
@@ -168,7 +167,7 @@ type (
 	}
 )
 
-func compareNode(t *testing.T, e astNode, n ast.Node) {
+func compareNode(t *testing.T, e astNode, n *ast.Node) {
 	t.Helper()
 	require.Equal(t, e.Kind, n.Kind)
 	require.Equal(t, e.Data, n.Data)
@@ -200,8 +199,6 @@ func compareIterator(t *testing.T, expected []astNode, actual ast.Iterator) {
 
 //nolint:funlen
 func TestParser_AST(t *testing.T) {
-	t.Parallel()
-
 	examples := []struct {
 		desc  string
 		input string
@@ -340,7 +337,6 @@ func TestParser_AST(t *testing.T) {
 	for _, e := range examples {
 		e := e
 		t.Run(e.desc, func(t *testing.T) {
-			t.Parallel()
 			p := parser{}
 			p.Reset([]byte(e.input))
 			p.NextExpression()
@@ -354,3 +350,101 @@ func TestParser_AST(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkParseBasicStringWithUnicode(b *testing.B) {
+	p := &parser{}
+	b.Run("4", func(b *testing.B) {
+		input := []byte(`"\u1234\u5678\u9ABC\u1234\u5678\u9ABC"`)
+		b.ReportAllocs()
+		b.SetBytes(int64(len(input)))
+
+		for i := 0; i < b.N; i++ {
+			p.parseBasicString(input)
+		}
+	})
+	b.Run("8", func(b *testing.B) {
+		input := []byte(`"\u12345678\u9ABCDEF0\u12345678\u9ABCDEF0"`)
+		b.ReportAllocs()
+		b.SetBytes(int64(len(input)))
+
+		for i := 0; i < b.N; i++ {
+			p.parseBasicString(input)
+		}
+	})
+}
+
+func BenchmarkParseBasicStringsEasy(b *testing.B) {
+	p := &parser{}
+
+	for _, size := range []int{1, 4, 8, 16, 21} {
+		b.Run(strconv.Itoa(size), func(b *testing.B) {
+			input := []byte(`"` + strings.Repeat("A", size) + `"`)
+
+			b.ReportAllocs()
+			b.SetBytes(int64(len(input)))
+
+			for i := 0; i < b.N; i++ {
+				p.parseBasicString(input)
+			}
+		})
+	}
+}
+
+func TestParser_AST_DateTimes(t *testing.T) {
+	examples := []struct {
+		desc  string
+		input string
+		kind  ast.Kind
+		err   bool
+	}{
+		{
+			desc:  "offset-date-time with delim 'T' and UTC offset",
+			input: `2021-07-21T12:08:05Z`,
+			kind:  ast.DateTime,
+		},
+		{
+			desc:  "offset-date-time with space delim and +8hours offset",
+			input: `2021-07-21 12:08:05+08:00`,
+			kind:  ast.DateTime,
+		},
+		{
+			desc:  "local-date-time with nano second",
+			input: `2021-07-21T12:08:05.666666666`,
+			kind:  ast.LocalDateTime,
+		},
+		{
+			desc:  "local-date-time",
+			input: `2021-07-21T12:08:05`,
+			kind:  ast.LocalDateTime,
+		},
+		{
+			desc:  "local-date",
+			input: `2021-07-21`,
+			kind:  ast.LocalDate,
+		},
+	}
+
+	for _, e := range examples {
+		e := e
+		t.Run(e.desc, func(t *testing.T) {
+			p := parser{}
+			p.Reset([]byte(`A = ` + e.input))
+			p.NextExpression()
+			err := p.Error()
+			if e.err {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+
+				expected := astNode{
+					Kind: ast.KeyValue,
+					Children: []astNode{
+						{Kind: e.kind, Data: []byte(e.input)},
+						{Kind: ast.Key, Data: []byte(`A`)},
+					},
+				}
+				compareNode(t, expected, p.Expression())
+			}
+		})
+	}
+}

scanner.go

@@ -49,13 +49,18 @@ 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++ {
+	for i := 1; i < len(b); {
 		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")
 		}
+		size := utf8ValidNext(b[i:])
+		if size == 0 {
+			return nil, nil, newDecodeError(b[i:i+1], "invalid character")
+		}
+		i += size
 	}
 
 	return nil, nil, newDecodeError(b[len(b):], "unterminated literal string")
@@ -70,10 +75,37 @@ func scanMultilineLiteralString(b []byte) ([]byte, []byte, error) {
 	// 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++ {
-		if b[i] == '\'' && scanFollowsMultilineLiteralStringDelimiter(b[i:]) {
-			return b[:i+3], b[i+3:], nil
+	for i := 3; i < len(b); {
+		if scanFollowsMultilineLiteralStringDelimiter(b[i:]) {
+			i += 3
+
+			// At that point we found 3 apostrophe, and i is the
+			// index of the byte after the third one. The scanner
+			// needs to be eager, because there can be an extra 2
+			// apostrophe that can be accepted at the end of the
+			// string.
+
+			if i >= len(b) || b[i] != '\'' {
+				return b[:i], b[i:], nil
+			}
+			i++
+
+			if i >= len(b) || b[i] != '\'' {
+				return b[:i], b[i:], nil
+			}
+			i++
+
+			if i < len(b) && b[i] == '\'' {
+				return nil, nil, newDecodeError(b[i-3:i+1], "''' not allowed in multiline literal string")
+			}
+
+			return b[:i], b[i:], nil
 		}
+		size := utf8ValidNext(b[i:])
+		if size == 0 {
+			return nil, nil, newDecodeError(b[i:i+1], "invalid character")
+		}
+		i += size
 	}
 
 	return nil, nil, newDecodeError(b[len(b):], `multiline literal string not terminated by '''`)
@@ -106,45 +138,62 @@ func scanWhitespace(b []byte) ([]byte, []byte) {
 }
 
 //nolint:unparam
-func scanComment(b []byte) ([]byte, []byte) {
+func scanComment(b []byte) ([]byte, []byte, error) {
 	// 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++ {
+
+	for i := 1; i < len(b); {
 		if b[i] == '\n' {
-			return b[:i], b[i:]
+			return b[:i], b[i:], nil
 		}
+		if b[i] == '\r' {
+			if i+1 < len(b) && b[i+1] == '\n' {
+				return b[:i+1], b[i+1:], nil
+			}
+			return nil, nil, newDecodeError(b[i:i+1], "invalid character in comment")
+		}
+		size := utf8ValidNext(b[i:])
+		if size == 0 {
+			return nil, nil, newDecodeError(b[i:i+1], "invalid character in comment")
+		}
+
+		i += size
 	}
 
-	return b, nil
+	return b, b[len(b):], nil
 }
 
-func scanBasicString(b []byte) ([]byte, []byte, error) {
+func scanBasicString(b []byte) ([]byte, bool, []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++ {
+	escaped := false
+	i := 1
+
+	for ; 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")
+			return b[:i+1], escaped, b[i+1:], nil
+		case '\n', '\r':
+			return nil, escaped, 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 \\")
+				return nil, escaped, nil, newDecodeError(b[i:i+1], "need a character after \\")
 			}
+			escaped = true
 			i++ // skip the next character
 		}
 	}
 
-	return nil, nil, newDecodeError(b[len(b):], `basic string not terminated by "`)
+	return nil, escaped, nil, newDecodeError(b[len(b):], `basic string not terminated by "`)
 }
 
-func scanMultilineBasicString(b []byte) ([]byte, []byte, error) {
+func scanMultilineBasicString(b []byte) ([]byte, bool, []byte, error) {
 	// ml-basic-string = ml-basic-string-delim [ newline ] ml-basic-body
 	// ml-basic-string-delim
 	// ml-basic-string-delim = 3quotation-mark
@@ -155,19 +204,46 @@ func scanMultilineBasicString(b []byte) ([]byte, []byte, error) {
 	// 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++ {
+
+	escaped := false
+	i := 3
+
+	for ; i < len(b); i++ {
 		switch b[i] {
 		case '"':
 			if scanFollowsMultilineBasicStringDelimiter(b[i:]) {
-				return b[:i+3], b[i+3:], nil
+				i += 3
+
+				// At that point we found 3 apostrophe, and i is the
+				// index of the byte after the third one. The scanner
+				// needs to be eager, because there can be an extra 2
+				// apostrophe that can be accepted at the end of the
+				// string.
+
+				if i >= len(b) || b[i] != '"' {
+					return b[:i], escaped, b[i:], nil
+				}
+				i++
+
+				if i >= len(b) || b[i] != '"' {
+					return b[:i], escaped, b[i:], nil
+				}
+				i++
+
+				if i < len(b) && b[i] == '"' {
+					return nil, escaped, nil, newDecodeError(b[i-3:i+1], `""" not allowed in multiline basic string`)
+				}
+
+				return b[:i], escaped, b[i:], nil
 			}
 		case '\\':
 			if len(b) < i+2 {
-				return nil, nil, newDecodeError(b[len(b):], "need a character after \\")
+				return nil, escaped, nil, newDecodeError(b[len(b):], "need a character after \\")
 			}
+			escaped = true
 			i++ // skip the next character
 		}
 	}
 
-	return nil, nil, newDecodeError(b[len(b):], `multiline basic string not terminated by """`)
+	return nil, escaped, nil, newDecodeError(b[len(b):], `multiline basic string not terminated by """`)
 }

strict.go

@@ -2,6 +2,7 @@ package toml
 
 import (
 	"github.com/pelletier/go-toml/v2/internal/ast"
+	"github.com/pelletier/go-toml/v2/internal/danger"
 	"github.com/pelletier/go-toml/v2/internal/tracker"
 )
 
@@ -14,7 +15,7 @@ type strict struct {
 	missing []decodeError
 }
 
-func (s *strict) EnterTable(node ast.Node) {
+func (s *strict) EnterTable(node *ast.Node) {
 	if !s.Enabled {
 		return
 	}
@@ -22,7 +23,7 @@ func (s *strict) EnterTable(node ast.Node) {
 	s.key.UpdateTable(node)
 }
 
-func (s *strict) EnterArrayTable(node ast.Node) {
+func (s *strict) EnterArrayTable(node *ast.Node) {
 	if !s.Enabled {
 		return
 	}
@@ -30,7 +31,7 @@ func (s *strict) EnterArrayTable(node ast.Node) {
 	s.key.UpdateArrayTable(node)
 }
 
-func (s *strict) EnterKeyValue(node ast.Node) {
+func (s *strict) EnterKeyValue(node *ast.Node) {
 	if !s.Enabled {
 		return
 	}
@@ -38,7 +39,7 @@ func (s *strict) EnterKeyValue(node ast.Node) {
 	s.key.Push(node)
 }
 
-func (s *strict) ExitKeyValue(node ast.Node) {
+func (s *strict) ExitKeyValue(node *ast.Node) {
 	if !s.Enabled {
 		return
 	}
@@ -46,7 +47,7 @@ func (s *strict) ExitKeyValue(node ast.Node) {
 	s.key.Pop(node)
 }
 
-func (s *strict) MissingTable(node ast.Node) {
+func (s *strict) MissingTable(node *ast.Node) {
 	if !s.Enabled {
 		return
 	}
@@ -58,7 +59,7 @@ func (s *strict) MissingTable(node ast.Node) {
 	})
 }
 
-func (s *strict) MissingField(node ast.Node) {
+func (s *strict) MissingField(node *ast.Node) {
 	if !s.Enabled {
 		return
 	}
@@ -86,3 +87,21 @@ func (s *strict) Error(doc []byte) error {
 
 	return err
 }
+
+func keyLocation(node *ast.Node) []byte {
+	k := node.Key()
+
+	hasOne := k.Next()
+	if !hasOne {
+		panic("should not be called with empty key")
+	}
+
+	start := k.Node().Data
+	end := k.Node().Data
+
+	for k.Next() {
+		end = k.Node().Data
+	}
+
+	return danger.BytesRange(start, end)
+}

targets.go

@@ -1,536 +0,0 @@
-package toml
-
-import (
-	"fmt"
-	"math"
-	"reflect"
-	"strings"
-	"sync"
-)
-
-type target interface {
-	// Dereferences the target.
-	get() reflect.Value
-
-	// Store a string at the target.
-	setString(v string)
-
-	// Store a boolean at the target
-	setBool(v bool)
-
-	// Store an int64 at the target
-	setInt64(v int64)
-
-	// Store a float64 at the target
-	setFloat64(v float64)
-
-	// Stores any value at the target
-	set(v reflect.Value)
-}
-
-// 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) {
-	reflect.Value(t).Set(v)
-}
-
-func (t valueTarget) setString(v string) {
-	t.get().SetString(v)
-}
-
-func (t valueTarget) setBool(v bool) {
-	t.get().SetBool(v)
-}
-
-func (t valueTarget) setInt64(v int64) {
-	t.get().SetInt(v)
-}
-
-func (t valueTarget) setFloat64(v float64) {
-	t.get().SetFloat(v)
-}
-
-// 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) {
-	t.x.set(v)
-}
-
-func (t interfaceTarget) setString(v string) {
-	panic("interface targets should always go through set")
-}
-
-func (t interfaceTarget) setBool(v bool) {
-	panic("interface targets should always go through set")
-}
-
-func (t interfaceTarget) setInt64(v int64) {
-	panic("interface targets should always go through set")
-}
-
-func (t interfaceTarget) setFloat64(v float64) {
-	panic("interface targets should always go through set")
-}
-
-// 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) {
-	t.v.SetMapIndex(t.k, v)
-}
-
-func (t mapTarget) setString(v string) {
-	t.set(reflect.ValueOf(v))
-}
-
-func (t mapTarget) setBool(v bool) {
-	t.set(reflect.ValueOf(v))
-}
-
-func (t mapTarget) setInt64(v int64) {
-	t.set(reflect.ValueOf(v))
-}
-
-func (t mapTarget) setFloat64(v float64) {
-	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() {
-			t.set(reflect.MakeSlice(f.Type(), 0, 0))
-			return nil
-		}
-	case reflect.Interface:
-		if f.IsNil() || f.Elem().Type() != sliceInterfaceType {
-			t.set(reflect.MakeSlice(sliceInterfaceType, 0, 0))
-			return nil
-		}
-	case reflect.Ptr:
-		panic("pointer should have already been dereferenced")
-	case reflect.Array:
-		// arrays are always initialized.
-	default:
-		return fmt.Errorf("toml: cannot store array in a %s", f.Kind())
-	}
-
-	return nil
-}
-
-var (
-	sliceInterfaceType     = reflect.TypeOf([]interface{}{})
-	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:
-		t.setString(v)
-	case reflect.Interface:
-		t.set(reflect.ValueOf(v))
-	default:
-		return fmt.Errorf("toml: cannot assign string to a %s", f.Kind())
-	}
-
-	return nil
-}
-
-func setBool(t target, v bool) error {
-	f := t.get()
-
-	switch f.Kind() {
-	case reflect.Bool:
-		t.setBool(v)
-	case reflect.Interface:
-		t.set(reflect.ValueOf(v))
-	default:
-		return fmt.Errorf("toml: cannot assign boolean to a %s", f.Kind())
-	}
-
-	return nil
-}
-
-const (
-	maxInt = int64(^uint(0) >> 1)
-	minInt = -maxInt - 1
-)
-
-//nolint:funlen,gocognit,cyclop
-func setInt64(t target, v int64) error {
-	f := t.get()
-
-	switch f.Kind() {
-	case reflect.Int64:
-		t.setInt64(v)
-	case reflect.Int32:
-		if v < math.MinInt32 || v > math.MaxInt32 {
-			return fmt.Errorf("toml: number %d does not fit in an int32", v)
-		}
-
-		t.set(reflect.ValueOf(int32(v)))
-		return nil
-	case reflect.Int16:
-		if v < math.MinInt16 || v > math.MaxInt16 {
-			return fmt.Errorf("toml: number %d does not fit in an int16", v)
-		}
-
-		t.set(reflect.ValueOf(int16(v)))
-	case reflect.Int8:
-		if v < math.MinInt8 || v > math.MaxInt8 {
-			return fmt.Errorf("toml: number %d does not fit in an int8", v)
-		}
-
-		t.set(reflect.ValueOf(int8(v)))
-	case reflect.Int:
-		if v < minInt || v > maxInt {
-			return fmt.Errorf("toml: number %d does not fit in an int", v)
-		}
-
-		t.set(reflect.ValueOf(int(v)))
-	case reflect.Uint64:
-		if v < 0 {
-			return fmt.Errorf("toml: negative number %d does not fit in an uint64", v)
-		}
-
-		t.set(reflect.ValueOf(uint64(v)))
-	case reflect.Uint32:
-		if v < 0 || v > math.MaxUint32 {
-			return fmt.Errorf("toml: negative number %d does not fit in an uint32", v)
-		}
-
-		t.set(reflect.ValueOf(uint32(v)))
-	case reflect.Uint16:
-		if v < 0 || v > math.MaxUint16 {
-			return fmt.Errorf("toml: negative number %d does not fit in an uint16", v)
-		}
-
-		t.set(reflect.ValueOf(uint16(v)))
-	case reflect.Uint8:
-		if v < 0 || v > math.MaxUint8 {
-			return fmt.Errorf("toml: negative number %d does not fit in an uint8", v)
-		}
-
-		t.set(reflect.ValueOf(uint8(v)))
-	case reflect.Uint:
-		if v < 0 {
-			return fmt.Errorf("toml: negative number %d does not fit in an uint", v)
-		}
-
-		t.set(reflect.ValueOf(uint(v)))
-	case reflect.Interface:
-		t.set(reflect.ValueOf(v))
-	default:
-		return fmt.Errorf("toml: integer cannot be assigned to %s", f.Kind())
-	}
-
-	return nil
-}
-
-func setFloat64(t target, v float64) error {
-	f := t.get()
-
-	switch f.Kind() {
-	case reflect.Float64:
-		t.setFloat64(v)
-	case reflect.Float32:
-		if v > math.MaxFloat32 {
-			return fmt.Errorf("toml: number %f does not fit in a float32", v)
-		}
-
-		t.set(reflect.ValueOf(float32(v)))
-	case reflect.Interface:
-		t.set(reflect.ValueOf(v))
-	default:
-		return fmt.Errorf("toml: float cannot be assigned to %s", f.Kind())
-	}
-
-	return nil
-}
-
-// 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 {
-	f := t.get()
-
-	switch f.Kind() {
-	case reflect.Slice:
-		//nolint:godox
-		// TODO: use the idx function argument and avoid alloc if possible.
-		idx := f.Len()
-
-		t.set(reflect.Append(f, reflect.New(f.Type().Elem()).Elem()))
-
-		return valueTarget(t.get().Index(idx))
-	case reflect.Array:
-		if idx >= f.Len() {
-			return nil
-		}
-
-		return valueTarget(f.Index(idx))
-	case reflect.Interface:
-		// This function is called after ensureValueIndexable, so it's
-		// guaranteed that f contains an initialized slice.
-		ifaceElem := f.Elem()
-		idx := ifaceElem.Len()
-		newElem := reflect.New(ifaceElem.Type().Elem()).Elem()
-		newSlice := reflect.Append(ifaceElem, newElem)
-
-		t.set(newSlice)
-
-		return valueTarget(t.get().Elem().Index(idx))
-	default:
-		// Why ensureValueIndexable let it go through?
-		panic(fmt.Errorf("elementAt received unhandled value type: %s", f.Kind()))
-	}
-}
-
-func (d *decoder) scopeTableTarget(shouldAppend bool, t target, name string) (target, bool, error) {
-	x := t.get()
-
-	switch x.Kind() {
-	// Kinds that need to recurse
-	case reflect.Interface:
-		t := scopeInterface(shouldAppend, t)
-		return d.scopeTableTarget(shouldAppend, t, name)
-	case reflect.Ptr:
-		t := scopePtr(t)
-		return d.scopeTableTarget(shouldAppend, t, name)
-	case reflect.Slice:
-		t := scopeSlice(shouldAppend, t)
-		shouldAppend = false
-		return d.scopeTableTarget(shouldAppend, t, name)
-	case reflect.Array:
-		t, err := d.scopeArray(shouldAppend, t)
-		if err != nil {
-			return t, false, err
-		}
-		shouldAppend = false
-
-		return d.scopeTableTarget(shouldAppend, 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.Sprintf("can't scope on a %s", x.Kind()))
-	}
-}
-
-func scopeInterface(shouldAppend bool, t target) target {
-	initInterface(shouldAppend, t)
-	return interfaceTarget{t}
-}
-
-func scopePtr(t target) target {
-	initPtr(t)
-	return valueTarget(t.get().Elem())
-}
-
-func initPtr(t target) {
-	x := t.get()
-	if !x.IsNil() {
-		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(shouldAppend bool, t target) {
-	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
-	}
-
-	var newElement reflect.Value
-	if shouldAppend {
-		newElement = reflect.MakeSlice(sliceInterfaceType, 0, 0)
-	} else {
-		newElement = reflect.MakeMap(mapStringInterfaceType)
-	}
-
-	t.set(newElement)
-}
-
-func scopeSlice(shouldAppend bool, t target) target {
-	v := t.get()
-
-	if shouldAppend {
-		newElem := reflect.New(v.Type().Elem())
-		newSlice := reflect.Append(v, newElem.Elem())
-
-		t.set(newSlice)
-
-		v = t.get()
-	}
-
-	return valueTarget(v.Index(v.Len() - 1))
-}
-
-func (d *decoder) scopeArray(shouldAppend bool, t target) (target, error) {
-	v := t.get()
-
-	idx := d.arrayIndex(shouldAppend, v)
-
-	if idx >= v.Len() {
-		return nil, fmt.Errorf("toml: impossible to insert element beyond array's size: %d", v.Len())
-	}
-
-	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("toml: cannot convert map key of type %s to expected type %s", k.Type(), 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) {
-	//nolint:godox
-	// 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.Anonymous {
-					walk(v.Field(i))
-				} else if f.PkgPath == "" {
-					// only consider exported fields
-					fieldName, ok := f.Tag.Lookup("toml")
-					if !ok {
-						fieldName = f.Name
-					}
-
-					pathCopy := make([]int, len(path))
-					copy(pathCopy, path)
-
-					fieldPaths[fieldName] = pathCopy
-					// extra copy for the case-insensitive match
-					fieldPaths[strings.ToLower(fieldName)] = pathCopy
-				}
-				path = path[:l]
-			}
-		}
-
-		walk(v)
-
-		globalFieldPathsCache.set(v.Type(), fieldPaths)
-	}
-
-	path, ok := fieldPaths[name]
-	if !ok {
-		path, ok = fieldPaths[strings.ToLower(name)]
-	}
-
-	if !ok {
-		return nil, false, nil
-	}
-
-	return valueTarget(v.FieldByIndex(path)), true, nil
-}

targets_test.go

@@ -1,207 +0,0 @@
-package toml
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestStructTarget_Ensure(t *testing.T) {
-	t.Parallel()
-
-	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, ok := v.Interface().([]string)
-				if !ok {
-					t.Errorf("interface %v should be castable into []string", s)
-					return
-				}
-
-				assert.Equal(t, []string{"foo"}, s)
-			},
-		},
-	}
-
-	for _, e := range examples {
-		e := e
-		t.Run(e.desc, func(t *testing.T) {
-			t.Parallel()
-
-			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) {
-	t.Parallel()
-
-	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 {
-		e := e
-		t.Run(e.desc, func(t *testing.T) {
-			t.Parallel()
-
-			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.Parallel()
-
-	t.Run("slice of strings", func(t *testing.T) {
-		t.Parallel()
-
-		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 := elementAt(x, 0)
-		n.setString("hello")
-		require.Equal(t, []string{"hello"}, d.A)
-
-		n = elementAt(x, 1)
-		n.setString("world")
-		require.Equal(t, []string{"hello", "world"}, d.A)
-	})
-
-	t.Run("slice of interfaces", func(t *testing.T) {
-		t.Parallel()
-
-		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 := elementAt(x, 0)
-		require.NoError(t, setString(n, "hello"))
-		require.Equal(t, []interface{}{"hello"}, d.A)
-
-		n = elementAt(x, 1)
-		require.NoError(t, setString(n, "world"))
-		require.Equal(t, []interface{}{"hello", "world"}, d.A)
-	})
-}
-
-func TestScope_Struct(t *testing.T) {
-	t.Parallel()
-
-	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 {
-		e := e
-		t.Run(e.desc, func(t *testing.T) {
-			t.Parallel()
-
-			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()
-			}
-		})
-	}
-}

testsuite/add.go

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

testsuite/json.go

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

testsuite/parser.go

@@ -0,0 +1,69 @@
+package testsuite
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+
+	"github.com/pelletier/go-toml/v2"
+)
+
+type parser struct{}
+
+func (p parser) Decode(input string) (output string, outputIsError bool, retErr error) {
+	defer func() {
+		if r := recover(); r != nil {
+			switch rr := r.(type) {
+			case error:
+				retErr = rr
+			default:
+				retErr = fmt.Errorf("%s", rr)
+			}
+		}
+	}()
+
+	var v interface{}
+
+	if err := toml.Unmarshal([]byte(input), &v); err != nil {
+		return err.Error(), true, nil
+	}
+
+	j, err := json.MarshalIndent(addTag("", v), "", "  ")
+	if err != nil {
+		return "", false, retErr
+	}
+
+	return string(j), false, retErr
+}
+
+func (p parser) Encode(input string) (output string, outputIsError bool, retErr error) {
+	defer func() {
+		if r := recover(); r != nil {
+			switch rr := r.(type) {
+			case error:
+				retErr = rr
+			default:
+				retErr = fmt.Errorf("%s", rr)
+			}
+		}
+	}()
+
+	var tmp interface{}
+	err := json.Unmarshal([]byte(input), &tmp)
+	if err != nil {
+		return "", false, err
+	}
+
+	rm, err := rmTag(tmp)
+	if err != nil {
+		return err.Error(), true, retErr
+	}
+
+	buf := new(bytes.Buffer)
+	err = toml.NewEncoder(buf).Encode(rm)
+	if err != nil {
+		return err.Error(), true, retErr
+	}
+
+	return buf.String(), false, retErr
+}

testsuite/rm.go

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

testsuite/testsuite.go

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

toml_testgen_support_test.go

@@ -1,14 +1,14 @@
+//go:generate go run ./cmd/tomltestgen/main.go -o toml_testgen_test.go
+
 // 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/pelletier/go-toml/v2/testsuite"
 	"github.com/stretchr/testify/require"
 )
 
@@ -17,10 +17,14 @@ func testgenInvalid(t *testing.T, input string) {
 	t.Logf("Input TOML:\n%s", input)
 
 	doc := map[string]interface{}{}
-	err := toml.Unmarshal([]byte(input), &doc)
+	err := testsuite.Unmarshal([]byte(input), &doc)
 
 	if err == nil {
-		t.Log(json.Marshal(doc))
+		out, err := json.Marshal(doc)
+		if err != nil {
+			panic("could not marshal map to json")
+		}
+		t.Log("JSON output from unmarshal:", string(out))
 		t.Fatalf("test did not fail")
 	}
 }
@@ -29,124 +33,26 @@ func testgenValid(t *testing.T, input string, jsonRef string) {
 	t.Helper()
 	t.Logf("Input TOML:\n%s", input)
 
-	doc := map[string]interface{}{}
+	// TODO: change this to interface{}
+	var doc map[string]interface{}
 
-	err := toml.Unmarshal([]byte(input), &doc)
+	err := testsuite.Unmarshal([]byte(input), &doc)
 	if err != nil {
+		if de, ok := err.(*toml.DecodeError); ok {
+			t.Logf("%s\n%s", err, de)
+		}
 		t.Fatalf("failed parsing toml: %s", err)
 	}
-
-	refDoc := testgenBuildRefDoc(jsonRef)
-
-	require.Equal(t, refDoc, doc)
-
-	out, err := toml.Marshal(doc)
+	j, err := testsuite.ValueToTaggedJSON(doc)
 	require.NoError(t, err)
 
-	doc2 := map[string]interface{}{}
-	err = toml.Unmarshal(out, &doc2)
+	var ref interface{}
+	err = json.Unmarshal([]byte(jsonRef), &ref)
 	require.NoError(t, err)
 
-	require.Equal(t, refDoc, doc2)
-}
-
-func testgenBuildRefDoc(jsonRef string) map[string]interface{} {
-	descTree := map[string]interface{}{}
-
-	err := json.Unmarshal([]byte(jsonRef), &descTree)
-	if err != nil {
-		panic(fmt.Sprintf("reference doc should be valid JSON: %s", err))
-	}
-
-	doc := testGenTranslateDesc(descTree)
-	if doc == nil {
-		return map[string]interface{}{}
-	}
-
-	return doc.(map[string]interface{})
-}
-
-//nolint:funlen,gocognit,cyclop
-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, ok := input.(map[string]interface{})
-	if !ok {
-		panic(fmt.Sprintf("input should be valid map[string]: %v", input))
-	}
-
-	var (
-		dtype  string
-		dvalue interface{}
-	)
-
-	//nolint:nestif
-	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.Sprintf("invalid float '%s': %s", dvalue, err))
-					}
-
-					return v
-				case "integer":
-					v, err := strconv.ParseInt(dvalue.(string), 10, 64)
-					if err != nil {
-						panic(fmt.Sprintf("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.Sprintf("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.Sprintf("unknown type: %s", dtype))
-			}
-		}
-	}
-
-	dest := map[string]interface{}{}
-	for k, v := range d {
-		dest[k] = testGenTranslateDesc(v)
-	}
-
-	return dest
+	var actual interface{}
+	err = json.Unmarshal([]byte(j), &actual)
+	require.NoError(t, err)
+
+	testsuite.CmpJSON(t, "", ref, actual)
 }

types.go

@@ -0,0 +1,14 @@
+package toml
+
+import (
+	"encoding"
+	"reflect"
+	"time"
+)
+
+var timeType = reflect.TypeOf(time.Time{})
+var textMarshalerType = reflect.TypeOf(new(encoding.TextMarshaler)).Elem()
+var textUnmarshalerType = reflect.TypeOf(new(encoding.TextUnmarshaler)).Elem()
+var mapStringInterfaceType = reflect.TypeOf(map[string]interface{}{})
+var sliceInterfaceType = reflect.TypeOf([]interface{}{})
+var stringType = reflect.TypeOf("")

utf8.go

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