Decode: improve errors on integers and strings

unmarshaler.go

@@ -149,12 +149,16 @@ type errorContext struct {
 }
 
 func (d *decoder) typeMismatchError(toml string, target reflect.Type) error {
+	return fmt.Errorf("toml: %s", d.typeMismatchString(toml, target))
+}
+
+func (d *decoder) typeMismatchString(toml string, target reflect.Type) string {
 	if d.errorContext != nil && d.errorContext.Struct != nil {
 		ctx := d.errorContext
 		f := ctx.Struct.FieldByIndex(ctx.Field)
-		return fmt.Errorf("toml: cannot decode TOML %s into struct field %s.%s of type %s", toml, ctx.Struct, f.Name, f.Type)
+		return fmt.Sprintf("cannot decode TOML %s into struct field %s.%s of type %s", toml, ctx.Struct, f.Name, f.Type)
 	}
-	return fmt.Errorf("toml: cannot decode TOML %s into a Go value of type %s", toml, target)
+	return fmt.Sprintf("cannot decode TOML %s into a Go value of type %s", toml, target)
 }
 
 func (d *decoder) expr() *unstable.Node {
@@ -963,7 +967,7 @@ func (d *decoder) unmarshalInteger(value *unstable.Node, v reflect.Value) error
 	case reflect.Interface:
 		r = reflect.ValueOf(i)
 	default:
-		return d.typeMismatchError("integer", v.Type())
+		return unstable.NewParserError(d.p.Raw(value.Raw), d.typeMismatchString("integer", v.Type()))
 	}
 
 	if !r.Type().AssignableTo(v.Type()) {
@@ -982,7 +986,7 @@ func (d *decoder) unmarshalString(value *unstable.Node, v reflect.Value) error {
 	case reflect.Interface:
 		v.Set(reflect.ValueOf(string(value.Data)))
 	default:
-		return unstable.NewParserError(d.p.Raw(value.Raw), "cannot store TOML string into a Go %s", v.Kind())
+		return unstable.NewParserError(d.p.Raw(value.Raw), d.typeMismatchString("string", v.Type()))
 	}
 
 	return nil

unmarshaler_test.go

@@ -2048,6 +2048,68 @@ func TestUnmarshalErrors(t *testing.T) {
 	require.Equal(t, "toml: cannot decode TOML integer into struct field toml_test.mystruct.Bar of type string", err.Error())
 }
 
+func TestUnmarshalStringInvalidStructField(t *testing.T) {
+	type Server struct {
+		Path string
+		Port int
+	}
+
+	type Cfg struct {
+		Server Server
+	}
+
+	var cfg Cfg
+
+	data := `[server]
+path = "/my/path"
+port = "bad"
+`
+
+	file := strings.NewReader(data)
+	err := toml.NewDecoder(file).Decode(&cfg)
+	require.Error(t, err)
+
+	x := err.(*toml.DecodeError)
+	require.Equal(t, "toml: cannot decode TOML string into struct field toml_test.Server.Port of type int", x.Error())
+	expected := `1| [server]
+2| path = "/my/path"
+3| port = "bad"
+ |        ~~~~~ cannot decode TOML string into struct field toml_test.Server.Port of type int`
+
+	require.Equal(t, expected, x.String())
+}
+
+func TestUnmarshalIntegerInvalidStructField(t *testing.T) {
+	type Server struct {
+		Path string
+		Port int
+	}
+
+	type Cfg struct {
+		Server Server
+	}
+
+	var cfg Cfg
+
+	data := `[server]
+path = 100
+port = 50
+`
+
+	file := strings.NewReader(data)
+	err := toml.NewDecoder(file).Decode(&cfg)
+	require.Error(t, err)
+
+	x := err.(*toml.DecodeError)
+	require.Equal(t, "toml: cannot decode TOML integer into struct field toml_test.Server.Path of type string", x.Error())
+	expected := `1| [server]
+2| path = 100
+ |        ~~~ cannot decode TOML integer into struct field toml_test.Server.Path of type string
+3| port = 50`
+
+	require.Equal(t, expected, x.String())
+}
+
 func TestUnmarshalInvalidTarget(t *testing.T) {
 	x := "foo"
 	err := toml.Unmarshal([]byte{}, x)

unstable/parser.go

@@ -1013,6 +1013,7 @@ func (p *Parser) parseIntOrFloatOrDateTime(b []byte) (reference, []byte, error)
 		return p.builder.Push(Node{
 			Kind: Float,
 			Data: b[:3],
+			Raw:  p.Range(b[:3]),
 		}), b[3:], nil
 	case 'n':
 		if !scanFollowsNan(b) {
@@ -1022,6 +1023,7 @@ func (p *Parser) parseIntOrFloatOrDateTime(b []byte) (reference, []byte, error)
 		return p.builder.Push(Node{
 			Kind: Float,
 			Data: b[:3],
+			Raw:  p.Range(b[:3]),
 		}), b[3:], nil
 	case '+', '-':
 		return p.scanIntOrFloat(b)
@@ -1146,6 +1148,7 @@ func (p *Parser) scanIntOrFloat(b []byte) (reference, []byte, error) {
 		return p.builder.Push(Node{
 			Kind: Integer,
 			Data: b[:i],
+			Raw:  p.Range(b[:i]),
 		}), b[i:], nil
 	}
 
@@ -1169,6 +1172,7 @@ func (p *Parser) scanIntOrFloat(b []byte) (reference, []byte, error) {
 				return p.builder.Push(Node{
 					Kind: Float,
 					Data: b[:i+3],
+					Raw:  p.Range(b[:i+3]),
 				}), b[i+3:], nil
 			}
 
@@ -1180,6 +1184,7 @@ func (p *Parser) scanIntOrFloat(b []byte) (reference, []byte, error) {
 				return p.builder.Push(Node{
 					Kind: Float,
 					Data: b[:i+3],
+					Raw:  p.Range(b[:i+3]),
 				}), b[i+3:], nil
 			}
 
@@ -1202,6 +1207,7 @@ func (p *Parser) scanIntOrFloat(b []byte) (reference, []byte, error) {
 	return p.builder.Push(Node{
 		Kind: kind,
 		Data: b[:i],
+		Raw:  p.Range(b[:i]),
 	}), b[i:], nil
 }
 

unstable/parser_test.go

@@ -569,9 +569,9 @@ key5 = [ # Next to start of inline array.
 	// ---
 	// 1:1->1:1 (0->0)           | KeyValue []
 	// 1:1->1:1 (0->0)           |   Array []
-	// 1:1->1:1 (0->0)           |     Integer [1]
-	// 1:1->1:1 (0->0)           |     Integer [2]
-	// 1:1->1:1 (0->0)           |     Integer [3]
+	// 19:11->19:12 (396->397)   |     Integer [1]
+	// 19:14->19:15 (399->400)   |     Integer [2]
+	// 19:17->19:18 (402->403)   |     Integer [3]
 	// 19:1->19:6 (386->391)     |   Key [array]
 	// 19:21->19:46 (406->431)   | Comment [# Next to one-line array.]
 	// ---
@@ -583,12 +583,12 @@ key5 = [ # Next to start of inline array.
 	// 1:1->1:1 (0->0)           |   Array []
 	// 23:10->23:42 (483->515)   |     Comment [# Next to start of inline array.]
 	// 24:3->24:38 (518->553)    |       Comment [# Second line before array content.]
-	// 1:1->1:1 (0->0)           |     Integer [1]
+	// 25:3->25:4 (556->557)     |     Integer [1]
 	// 25:6->25:30 (559->583)    |     Comment [# Next to first element.]
 	// 26:3->26:25 (586->608)    |       Comment [# After first element.]
 	// 27:3->27:27 (611->635)    |       Comment [# Before second element.]
-	// 1:1->1:1 (0->0)           |     Integer [2]
-	// 1:1->1:1 (0->0)           |     Integer [3]
+	// 28:3->28:4 (638->639)     |     Integer [2]
+	// 29:3->29:4 (643->644)     |     Integer [3]
 	// 29:6->29:28 (646->668)    |     Comment [# Next to last element]
 	// 30:3->30:24 (671->692)    |       Comment [# After last element.]
 	// 23:1->23:5 (474->478)     |   Key [key5]