Fix implicit declaration

parser.go

@@ -10,10 +10,11 @@ import (
 )
 
 type parser struct {
-	flow         chan token
-	tree         *TomlTree
-	tokensBuffer []token
-	currentGroup string
+	flow          chan token
+	tree          *TomlTree
+	tokensBuffer  []token
+	currentGroup  string
+	seenGroupKeys []string
 }
 
 type parserStateFn func(*parser) parserStateFn
@@ -87,9 +88,12 @@ func parseGroup(p *parser) parserStateFn {
 	if key.typ != tokenKeyGroup {
 		panic(fmt.Sprintf("unexpected token %s, was expecting a key group", key))
 	}
-	if p.tree.Has(key.val) {
-		panic("duplicated tables")
+	for _, item := range p.seenGroupKeys {
+		if item == key.val {
+			panic("duplicated tables")
+		}
 	}
+	p.seenGroupKeys = append(p.seenGroupKeys, key.val)
 	p.tree.createSubTree(key.val)
 	p.assume(tokenRightBracket)
 	p.currentGroup = key.val
@@ -192,10 +196,11 @@ func parseArray(p *parser) []interface{} {
 func parse(flow chan token) *TomlTree {
 	result := make(TomlTree)
 	parser := &parser{
-		flow:         flow,
-		tree:         &result,
-		tokensBuffer: make([]token, 0),
-		currentGroup: "",
+		flow:          flow,
+		tree:          &result,
+		tokensBuffer:  make([]token, 0),
+		currentGroup:  "",
+		seenGroupKeys: make([]string, 0),
 	}
 	parser.run()
 	return parser.tree

parser_test.go

@@ -12,9 +12,15 @@ func assertTree(t *testing.T, tree *TomlTree, err error, ref map[string]interfac
 		return
 	}
 	for k, v := range ref {
-		if fmt.Sprintf("%v", tree.Get(k)) != fmt.Sprintf("%v", v) {
-			t.Log("was expecting", v, "at", k, "but got", tree.Get(k))
-			t.Error()
+		node := tree.Get(k)
+		switch node.(type) {
+		case *TomlTree:
+			assertTree(t, node.(*TomlTree), err, v.(map[string]interface{}))
+		default:
+			if fmt.Sprintf("%v", node) != fmt.Sprintf("%v", v) {
+				t.Log("was expecting", v, "at", k, "but got", node)
+				t.Error()
+			}
 		}
 	}
 }
@@ -225,6 +231,20 @@ func TestEmptyIntermediateTable(t *testing.T) {
 	}
 }
 
+func TestImplicitDeclarationBefore(t *testing.T) {
+	tree, err := Load("[a.b.c]\nanswer = 42\n[a]\nbetter = 43")
+	assertTree(t, tree, err, map[string]interface{}{
+		"a": map[string]interface{}{
+			"b": map[string]interface{}{
+				"c": map[string]interface{}{
+					"answer": int64(42),
+				},
+			},
+			"better": int64(43),
+		},
+	})
+}
+
 func TestFloatsWithoutLeadingZeros(t *testing.T) {
 	_, err := Load("a = .42")
 	if err.Error() != "cannot start float with a dot" {