Add indent test cases for int8 type

coverage_test.go

@@ -639,7 +639,6 @@ null
   }
 }
 `,
-
 			data: &struct {
 				A *struct {
 					A int `json:"a"`
@@ -981,13 +980,13 @@ null
 				var buf bytes.Buffer
 				enc := NewEncoder(&buf)
 				enc.SetEscapeHTML(htmlEscape)
-				if indent && test.indentExpected != "" {
+				if indent {
 					enc.SetIndent("", "  ")
 				}
 				if err := enc.Encode(test.data); err != nil {
 					t.Fatalf("%s(htmlEscape:%T): %s: %s", test.name, htmlEscape, test.expected, err)
 				}
-				if indent && test.indentExpected != "" {
+				if indent {
 					got := "\n" + buf.String()
 					if got != test.indentExpected {
 						t.Fatalf("%s(htmlEscape:%T): expected %q but got %q", test.name, htmlEscape, test.indentExpected, got)
@@ -1011,13 +1010,19 @@ func TestCoverStructHeadInt8(t *testing.T) {
 	}
 
 	tests := []struct {
-		name     string
+		name           string
-		expected string
+		expected       string
-		data     interface{}
+		indentExpected string
+		data           interface{}
 	}{
 		{
 			name:     "HeadInt8Zero",
 			expected: `{"a":0}`,
+			indentExpected: `
+{
+  "a": 0
+}
+`,
 			data: struct {
 				A int8 `json:"a"`
 			}{},
@@ -1025,6 +1030,11 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "HeadInt8",
 			expected: `{"a":1}`,
+			indentExpected: `
+{
+  "a": 1
+}
+`,
 			data: struct {
 				A int8 `json:"a"`
 			}{A: 1},
@@ -1032,6 +1042,11 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "HeadInt8Ptr",
 			expected: `{"a":1}`,
+			indentExpected: `
+{
+  "a": 1
+}
+`,
 			data: struct {
 				A *int8 `json:"a"`
 			}{A: int8ptr(1)},
@@ -1039,6 +1054,11 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "HeadInt8PtrNil",
 			expected: `{"a":null}`,
+			indentExpected: `
+{
+  "a": null
+}
+`,
 			data: struct {
 				A *int8 `json:"a"`
 			}{A: nil},
@@ -1046,6 +1066,11 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8Zero",
 			expected: `{"a":0}`,
+			indentExpected: `
+{
+  "a": 0
+}
+`,
 			data: &struct {
 				A int8 `json:"a"`
 			}{},
@@ -1053,6 +1078,11 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8",
 			expected: `{"a":1}`,
+			indentExpected: `
+{
+  "a": 1
+}
+`,
 			data: &struct {
 				A int8 `json:"a"`
 			}{A: 1},
@@ -1060,6 +1090,11 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8Ptr",
 			expected: `{"a":1}`,
+			indentExpected: `
+{
+  "a": 1
+}
+`,
 			data: &struct {
 				A *int8 `json:"a"`
 			}{A: int8ptr(1)},
@@ -1067,6 +1102,11 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8PtrNil",
 			expected: `{"a":null}`,
+			indentExpected: `
+{
+  "a": null
+}
+`,
 			data: &struct {
 				A *int8 `json:"a"`
 			}{A: nil},
@@ -1074,6 +1114,9 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8Nil",
 			expected: `null`,
+			indentExpected: `
+null
+`,
 			data: (*struct {
 				A *int8 `json:"a"`
 			})(nil),
@@ -1081,6 +1124,12 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "HeadInt8ZeroMultiFields",
 			expected: `{"a":0,"b":0}`,
+			indentExpected: `
+{
+  "a": 0,
+  "b": 0
+}
+`,
 			data: struct {
 				A int8 `json:"a"`
 				B int8 `json:"b"`
@@ -1089,6 +1138,12 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "HeadInt8MultiFields",
 			expected: `{"a":1,"b":2}`,
+			indentExpected: `
+{
+  "a": 1,
+  "b": 2
+}
+`,
 			data: struct {
 				A int8 `json:"a"`
 				B int8 `json:"b"`
@@ -1097,6 +1152,12 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "HeadInt8PtrMultiFields",
 			expected: `{"a":1,"b":2}`,
+			indentExpected: `
+{
+  "a": 1,
+  "b": 2
+}
+`,
 			data: struct {
 				A *int8 `json:"a"`
 				B *int8 `json:"b"`
@@ -1105,6 +1166,12 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "HeadInt8PtrNilMultiFields",
 			expected: `{"a":null,"b":null}`,
+			indentExpected: `
+{
+  "a": null,
+  "b": null
+}
+`,
 			data: struct {
 				A *int8 `json:"a"`
 				B *int8 `json:"b"`
@@ -1113,6 +1180,12 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8ZeroMultiFields",
 			expected: `{"a":0,"b":0}`,
+			indentExpected: `
+{
+  "a": 0,
+  "b": 0
+}
+`,
 			data: &struct {
 				A int8 `json:"a"`
 				B int8 `json:"b"`
@@ -1121,6 +1194,12 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8MultiFields",
 			expected: `{"a":1,"b":2}`,
+			indentExpected: `
+{
+  "a": 1,
+  "b": 2
+}
+`,
 			data: &struct {
 				A int8 `json:"a"`
 				B int8 `json:"b"`
@@ -1129,6 +1208,12 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8PtrMultiFields",
 			expected: `{"a":1,"b":2}`,
+			indentExpected: `
+{
+  "a": 1,
+  "b": 2
+}
+`,
 			data: &struct {
 				A *int8 `json:"a"`
 				B *int8 `json:"b"`
@@ -1137,6 +1222,12 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8PtrNilMultiFields",
 			expected: `{"a":null,"b":null}`,
+			indentExpected: `
+{
+  "a": null,
+  "b": null
+}
+`,
 			data: &struct {
 				A *int8 `json:"a"`
 				B *int8 `json:"b"`
@@ -1145,6 +1236,9 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8NilMultiFields",
 			expected: `null`,
+			indentExpected: `
+null
+`,
 			data: (*struct {
 				A *int8 `json:"a"`
 				B *int8 `json:"b"`
@@ -1153,6 +1247,13 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "HeadInt8ZeroNotRoot",
 			expected: `{"A":{"a":0}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": 0
+  }
+}
+`,
 			data: struct {
 				A struct {
 					A int8 `json:"a"`
@@ -1162,6 +1263,13 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "HeadInt8NotRoot",
 			expected: `{"A":{"a":1}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": 1
+  }
+}
+`,
 			data: struct {
 				A struct {
 					A int8 `json:"a"`
@@ -1173,6 +1281,13 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "HeadInt8PtrNotRoot",
 			expected: `{"A":{"a":1}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": 1
+  }
+}
+`,
 			data: struct {
 				A struct {
 					A *int8 `json:"a"`
@@ -1184,6 +1299,13 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "HeadInt8PtrNilNotRoot",
 			expected: `{"A":{"a":null}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": null
+  }
+}
+`,
 			data: struct {
 				A struct {
 					A *int8 `json:"a"`
@@ -1193,6 +1315,13 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8ZeroNotRoot",
 			expected: `{"A":{"a":0}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": 0
+  }
+}
+`,
 			data: struct {
 				A *struct {
 					A int8 `json:"a"`
@@ -1204,6 +1333,13 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8NotRoot",
 			expected: `{"A":{"a":1}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": 1
+  }
+}
+`,
 			data: struct {
 				A *struct {
 					A int8 `json:"a"`
@@ -1215,6 +1351,13 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8PtrNotRoot",
 			expected: `{"A":{"a":1}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": 1
+  }
+}
+`,
 			data: struct {
 				A *struct {
 					A *int8 `json:"a"`
@@ -1226,6 +1369,13 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8PtrNilNotRoot",
 			expected: `{"A":{"a":null}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": null
+  }
+}
+`,
 			data: struct {
 				A *struct {
 					A *int8 `json:"a"`
@@ -1237,6 +1387,11 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8NilNotRoot",
 			expected: `{"A":null}`,
+			indentExpected: `
+{
+  "A": null
+}
+`,
 			data: struct {
 				A *struct {
 					A *int8 `json:"a"`
@@ -1246,6 +1401,16 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "HeadInt8ZeroMultiFieldsNotRoot",
 			expected: `{"A":{"a":0},"B":{"b":0}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": 0
+  },
+  "B": {
+    "b": 0
+  }
+}
+`,
 			data: struct {
 				A struct {
 					A int8 `json:"a"`
@@ -1258,6 +1423,16 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "HeadInt8MultiFieldsNotRoot",
 			expected: `{"A":{"a":1},"B":{"b":2}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": 1
+  },
+  "B": {
+    "b": 2
+  }
+}
+`,
 			data: struct {
 				A struct {
 					A int8 `json:"a"`
@@ -1274,6 +1449,16 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "HeadInt8PtrMultiFieldsNotRoot",
 			expected: `{"A":{"a":1},"B":{"b":2}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": 1
+  },
+  "B": {
+    "b": 2
+  }
+}
+`,
 			data: struct {
 				A struct {
 					A *int8 `json:"a"`
@@ -1290,6 +1475,16 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "HeadInt8PtrNilMultiFieldsNotRoot",
 			expected: `{"A":{"a":null},"B":{"b":null}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": null
+  },
+  "B": {
+    "b": null
+  }
+}
+`,
 			data: struct {
 				A struct {
 					A *int8 `json:"a"`
@@ -1306,6 +1501,16 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8ZeroMultiFieldsNotRoot",
 			expected: `{"A":{"a":0},"B":{"b":0}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": 0
+  },
+  "B": {
+    "b": 0
+  }
+}
+`,
 			data: &struct {
 				A struct {
 					A int8 `json:"a"`
@@ -1318,6 +1523,16 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8MultiFieldsNotRoot",
 			expected: `{"A":{"a":1},"B":{"b":2}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": 1
+  },
+  "B": {
+    "b": 2
+  }
+}
+`,
 			data: &struct {
 				A struct {
 					A int8 `json:"a"`
@@ -1334,6 +1549,16 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8PtrMultiFieldsNotRoot",
 			expected: `{"A":{"a":1},"B":{"b":2}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": 1
+  },
+  "B": {
+    "b": 2
+  }
+}
+`,
 			data: &struct {
 				A *struct {
 					A *int8 `json:"a"`
@@ -1350,6 +1575,12 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8PtrNilMultiFieldsNotRoot",
 			expected: `{"A":null,"B":null}`,
+			indentExpected: `
+{
+  "A": null,
+  "B": null
+}
+`,
 			data: &struct {
 				A *struct {
 					A *int8 `json:"a"`
@@ -1362,6 +1593,9 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8NilMultiFieldsNotRoot",
 			expected: `null`,
+			indentExpected: `
+null
+`,
 			data: (*struct {
 				A *struct {
 					A *int8 `json:"a"`
@@ -1374,6 +1608,18 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8DoubleMultiFieldsNotRoot",
 			expected: `{"A":{"a":1,"b":2},"B":{"a":3,"b":4}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": 1,
+    "b": 2
+  },
+  "B": {
+    "a": 3,
+    "b": 4
+  }
+}
+`,
 			data: &struct {
 				A *struct {
 					A int8 `json:"a"`
@@ -1394,6 +1640,12 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8NilDoubleMultiFieldsNotRoot",
 			expected: `{"A":null,"B":null}`,
+			indentExpected: `
+{
+  "A": null,
+  "B": null
+}
+`,
 			data: &struct {
 				A *struct {
 					A int8 `json:"a"`
@@ -1408,6 +1660,9 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8NilDoubleMultiFieldsNotRoot",
 			expected: `null`,
+			indentExpected: `
+null
+`,
 			data: (*struct {
 				A *struct {
 					A int8 `json:"a"`
@@ -1422,6 +1677,18 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8PtrDoubleMultiFieldsNotRoot",
 			expected: `{"A":{"a":1,"b":2},"B":{"a":3,"b":4}}`,
+			indentExpected: `
+{
+  "A": {
+    "a": 1,
+    "b": 2
+  },
+  "B": {
+    "a": 3,
+    "b": 4
+  }
+}
+`,
 			data: &struct {
 				A *struct {
 					A *int8 `json:"a"`
@@ -1442,6 +1709,12 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8PtrNilDoubleMultiFieldsNotRoot",
 			expected: `{"A":null,"B":null}`,
+			indentExpected: `
+{
+  "A": null,
+  "B": null
+}
+`,
 			data: &struct {
 				A *struct {
 					A *int8 `json:"a"`
@@ -1456,6 +1729,9 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrHeadInt8PtrNilDoubleMultiFieldsNotRoot",
 			expected: `null`,
+			indentExpected: `
+null
+`,
 			data: (*struct {
 				A *struct {
 					A *int8 `json:"a"`
@@ -1470,6 +1746,12 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "AnonymousHeadInt8",
 			expected: `{"a":1,"b":2}`,
+			indentExpected: `
+{
+  "a": 1,
+  "b": 2
+}
+`,
 			data: struct {
 				structInt8
 				B int8 `json:"b"`
@@ -1481,6 +1763,12 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrAnonymousHeadInt8",
 			expected: `{"a":1,"b":2}`,
+			indentExpected: `
+{
+  "a": 1,
+  "b": 2
+}
+`,
 			data: struct {
 				*structInt8
 				B int8 `json:"b"`
@@ -1492,6 +1780,11 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "NilPtrAnonymousHeadInt8",
 			expected: `{"b":2}`,
+			indentExpected: `
+{
+  "b": 2
+}
+`,
 			data: struct {
 				*structInt8
 				B int8 `json:"b"`
@@ -1503,6 +1796,12 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "AnonymousHeadInt8Ptr",
 			expected: `{"a":1,"b":2}`,
+			indentExpected: `
+{
+  "a": 1,
+  "b": 2
+}
+`,
 			data: struct {
 				structInt8Ptr
 				B *int8 `json:"b"`
@@ -1514,6 +1813,12 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "AnonymousHeadInt8PtrNil",
 			expected: `{"a":null,"b":2}`,
+			indentExpected: `
+{
+  "a": null,
+  "b": 2
+}
+`,
 			data: struct {
 				structInt8Ptr
 				B *int8 `json:"b"`
@@ -1525,6 +1830,12 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrAnonymousHeadInt8Ptr",
 			expected: `{"a":1,"b":2}`,
+			indentExpected: `
+{
+  "a": 1,
+  "b": 2
+}
+`,
 			data: struct {
 				*structInt8Ptr
 				B *int8 `json:"b"`
@@ -1536,6 +1847,11 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "NilPtrAnonymousHeadInt8Ptr",
 			expected: `{"b":2}`,
+			indentExpected: `
+{
+  "b": 2
+}
+`,
 			data: struct {
 				*structInt8Ptr
 				B *int8 `json:"b"`
@@ -1547,6 +1863,11 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "AnonymousHeadInt8Only",
 			expected: `{"a":1}`,
+			indentExpected: `
+{
+  "a": 1
+}
+`,
 			data: struct {
 				structInt8
 			}{
@@ -1556,6 +1877,11 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrAnonymousHeadInt8Only",
 			expected: `{"a":1}`,
+			indentExpected: `
+{
+  "a": 1
+}
+`,
 			data: struct {
 				*structInt8
 			}{
@@ -1565,6 +1891,9 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "NilPtrAnonymousHeadInt8Only",
 			expected: `{}`,
+			indentExpected: `
+{}
+`,
 			data: struct {
 				*structInt8
 			}{
@@ -1574,6 +1903,11 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "AnonymousHeadInt8PtrOnly",
 			expected: `{"a":1}`,
+			indentExpected: `
+{
+  "a": 1
+}
+`,
 			data: struct {
 				structInt8Ptr
 			}{
@@ -1583,6 +1917,11 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "AnonymousHeadInt8PtrNilOnly",
 			expected: `{"a":null}`,
+			indentExpected: `
+{
+  "a": null
+}
+`,
 			data: struct {
 				structInt8Ptr
 			}{
@@ -1592,6 +1931,11 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "PtrAnonymousHeadInt8PtrOnly",
 			expected: `{"a":1}`,
+			indentExpected: `
+{
+  "a": 1
+}
+`,
 			data: struct {
 				*structInt8Ptr
 			}{
@@ -1601,6 +1945,9 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		{
 			name:     "NilPtrAnonymousHeadInt8PtrOnly",
 			expected: `{}`,
+			indentExpected: `
+{}
+`,
 			data: struct {
 				*structInt8Ptr
 			}{
@@ -1609,15 +1956,27 @@ func TestCoverStructHeadInt8(t *testing.T) {
 		},
 	}
 	for _, test := range tests {
-		for _, htmlEscape := range []bool{true, false} {
+		for _, indent := range []bool{true, false} {
-			var buf bytes.Buffer
+			for _, htmlEscape := range []bool{true, false} {
-			enc := NewEncoder(&buf)
+				var buf bytes.Buffer
-			enc.SetEscapeHTML(htmlEscape)
+				enc := NewEncoder(&buf)
-			if err := enc.Encode(test.data); err != nil {
+				enc.SetEscapeHTML(htmlEscape)
-				t.Fatalf("%s(htmlEscape:%T): %s: %s", test.name, htmlEscape, test.expected, err)
+				if indent {
-			}
+					enc.SetIndent("", "  ")
-			if strings.TrimRight(buf.String(), "\n") != test.expected {
+				}
-				t.Fatalf("%s(htmlEscape:%T): expected %q but got %q", test.name, htmlEscape, test.expected, buf.String())
+				if err := enc.Encode(test.data); err != nil {
+					t.Fatalf("%s(htmlEscape:%T): %s: %s", test.name, htmlEscape, test.expected, err)
+				}
+				if indent {
+					got := "\n" + buf.String()
+					if got != test.indentExpected {
+						t.Fatalf("%s(htmlEscape:%T): expected %q but got %q", test.name, htmlEscape, test.indentExpected, got)
+					}
+				} else {
+					if strings.TrimRight(buf.String(), "\n") != test.expected {
+						t.Fatalf("%s(htmlEscape:%T): expected %q but got %q", test.name, htmlEscape, test.expected, buf.String())
+					}
+				}
 			}
 		}
 	}

encode_vm.go

@@ -5713,13 +5713,11 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, b []byte, code *opcode) ([]byte
 		case opStructFieldHeadInt8Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				b = e.encodeIndent(b, code.indent)
 				b = encodeNull(b)
 				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
-				b = encodeIndentComma(b)
 				b = e.encodeIndent(b, code.indent+1)
 				b = append(b, code.key...)
 				b = append(b, ' ')
@@ -5727,19 +5725,26 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, b []byte, code *opcode) ([]byte
 				b = encodeIndentComma(b)
 				code = code.next
 			}
+		case opStructFieldPtrHeadInt8OnlyIndent, opStructFieldHeadInt8OnlyIndent:
+			p := load(ctxptr, code.idx)
+			b = append(b, '{', '\n')
+			b = e.encodeIndent(b, code.indent+1)
+			b = append(b, code.key...)
+			b = append(b, ' ')
+			b = appendInt(b, int64(e.ptrToInt8(p)))
+			b = encodeIndentComma(b)
+			code = code.next
 		case opStructEscapedFieldPtrHeadInt8Indent:
 			store(ctxptr, code.idx, e.ptrToPtr(load(ctxptr, code.idx)))
 			fallthrough
 		case opStructEscapedFieldHeadInt8Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				b = e.encodeIndent(b, code.indent)
 				b = encodeNull(b)
 				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
-				b = encodeIndentComma(b)
 				b = e.encodeIndent(b, code.indent+1)
 				b = append(b, code.escapedKey...)
 				b = append(b, ' ')
@@ -5747,6 +5752,289 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, b []byte, code *opcode) ([]byte
 				b = encodeIndentComma(b)
 				code = code.next
 			}
+		case opStructEscapedFieldPtrHeadInt8OnlyIndent, opStructEscapedFieldHeadInt8OnlyIndent:
+			p := load(ctxptr, code.idx)
+			b = append(b, '{', '\n')
+			b = e.encodeIndent(b, code.indent+1)
+			b = append(b, code.escapedKey...)
+			b = append(b, ' ')
+			b = appendInt(b, int64(e.ptrToInt8(p)))
+			b = encodeIndentComma(b)
+			code = code.next
+		case opStructFieldPtrHeadInt8PtrIndent:
+			store(ctxptr, code.idx, e.ptrToPtr(load(ctxptr, code.idx)))
+			fallthrough
+		case opStructFieldHeadInt8PtrIndent:
+			p := load(ctxptr, code.idx)
+			if p == 0 {
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
+				code = code.end.next
+				break
+			} else {
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = append(b, code.key...)
+				b = append(b, ' ')
+				p = e.ptrToPtr(p)
+				if p == 0 {
+					b = encodeNull(b)
+				} else {
+					b = appendInt(b, int64(e.ptrToInt8(p+code.offset)))
+				}
+			}
+			b = encodeIndentComma(b)
+			code = code.next
+		case opStructFieldPtrHeadInt8PtrOnlyIndent:
+			p := load(ctxptr, code.idx)
+			if p == 0 {
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
+				code = code.end.next
+				break
+			}
+			store(ctxptr, code.idx, e.ptrToPtr(p))
+			fallthrough
+		case opStructFieldHeadInt8PtrOnlyIndent:
+			p := load(ctxptr, code.idx)
+			b = append(b, '{', '\n')
+			b = e.encodeIndent(b, code.indent+1)
+			b = append(b, code.key...)
+			b = append(b, ' ')
+			if p == 0 {
+				b = encodeNull(b)
+			} else {
+				b = appendInt(b, int64(e.ptrToInt8(p+code.offset)))
+			}
+			b = encodeIndentComma(b)
+			code = code.next
+		case opStructEscapedFieldPtrHeadInt8PtrIndent:
+			store(ctxptr, code.idx, e.ptrToPtr(load(ctxptr, code.idx)))
+			fallthrough
+		case opStructEscapedFieldHeadInt8PtrIndent:
+			p := load(ctxptr, code.idx)
+			if p == 0 {
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
+				code = code.end.next
+				break
+			} else {
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = append(b, code.escapedKey...)
+				b = append(b, ' ')
+				p = e.ptrToPtr(p)
+				if p == 0 {
+					b = encodeNull(b)
+				} else {
+					b = appendInt(b, int64(e.ptrToInt8(p+code.offset)))
+				}
+			}
+			b = encodeIndentComma(b)
+			code = code.next
+		case opStructEscapedFieldPtrHeadInt8PtrOnlyIndent:
+			p := load(ctxptr, code.idx)
+			if p == 0 {
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
+				code = code.end.next
+				break
+			}
+			store(ctxptr, code.idx, e.ptrToPtr(p))
+			fallthrough
+		case opStructEscapedFieldHeadInt8PtrOnlyIndent:
+			p := load(ctxptr, code.idx)
+			b = append(b, '{', '\n')
+			b = e.encodeIndent(b, code.indent+1)
+			b = append(b, code.escapedKey...)
+			b = append(b, ' ')
+			if p == 0 {
+				b = encodeNull(b)
+			} else {
+				b = appendInt(b, int64(e.ptrToInt8(p+code.offset)))
+			}
+			b = encodeIndentComma(b)
+			code = code.next
+		case opStructFieldHeadInt8NPtrIndent:
+			p := load(ctxptr, code.idx)
+			if p == 0 {
+				b = encodeNull(b)
+			} else {
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = append(b, code.key...)
+				b = append(b, ' ')
+				for i := 0; i < code.ptrNum; i++ {
+					if p == 0 {
+						break
+					}
+					p = e.ptrToPtr(p)
+				}
+				if p == 0 {
+					b = encodeNull(b)
+				} else {
+					b = appendInt(b, int64(e.ptrToInt8(p+code.offset)))
+				}
+			}
+			b = encodeIndentComma(b)
+			code = code.next
+		case opStructEscapedFieldHeadInt8NPtrIndent:
+			p := load(ctxptr, code.idx)
+			if p == 0 {
+				b = encodeNull(b)
+			} else {
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = append(b, code.escapedKey...)
+				b = append(b, ' ')
+				for i := 0; i < code.ptrNum; i++ {
+					if p == 0 {
+						break
+					}
+					p = e.ptrToPtr(p)
+				}
+				if p == 0 {
+					b = encodeNull(b)
+				} else {
+					b = appendInt(b, int64(e.ptrToInt8(p+code.offset)))
+				}
+			}
+			b = encodeIndentComma(b)
+			code = code.next
+		case opStructFieldPtrAnonymousHeadInt8Indent:
+			store(ctxptr, code.idx, e.ptrToPtr(load(ctxptr, code.idx)))
+			fallthrough
+		case opStructFieldAnonymousHeadInt8Indent:
+			ptr := load(ctxptr, code.idx)
+			if ptr == 0 {
+				code = code.end.next
+			} else {
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, code.key...)
+				b = append(b, ' ')
+				b = appendInt(b, int64(e.ptrToInt8(ptr+code.offset)))
+				b = encodeIndentComma(b)
+				code = code.next
+			}
+		case opStructEscapedFieldPtrAnonymousHeadInt8Indent:
+			store(ctxptr, code.idx, e.ptrToPtr(load(ctxptr, code.idx)))
+			fallthrough
+		case opStructEscapedFieldAnonymousHeadInt8Indent:
+			ptr := load(ctxptr, code.idx)
+			if ptr == 0 {
+				code = code.end.next
+			} else {
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, code.escapedKey...)
+				b = append(b, ' ')
+				b = appendInt(b, int64(e.ptrToInt8(ptr+code.offset)))
+				b = encodeIndentComma(b)
+				code = code.next
+			}
+		case opStructFieldPtrAnonymousHeadInt8OnlyIndent, opStructFieldAnonymousHeadInt8OnlyIndent:
+			ptr := load(ctxptr, code.idx)
+			if ptr == 0 {
+				code = code.end.next
+			} else {
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, code.key...)
+				b = append(b, ' ')
+				b = appendInt(b, int64(e.ptrToInt8(ptr+code.offset)))
+				b = encodeIndentComma(b)
+				code = code.next
+			}
+		case opStructEscapedFieldPtrAnonymousHeadInt8OnlyIndent, opStructEscapedFieldAnonymousHeadInt8OnlyIndent:
+			ptr := load(ctxptr, code.idx)
+			if ptr == 0 {
+				code = code.end.next
+			} else {
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, code.escapedKey...)
+				b = append(b, ' ')
+				b = appendInt(b, int64(e.ptrToInt8(ptr+code.offset)))
+				b = encodeIndentComma(b)
+				code = code.next
+			}
+		case opStructFieldPtrAnonymousHeadInt8PtrIndent:
+			store(ctxptr, code.idx, e.ptrToPtr(load(ctxptr, code.idx)))
+			fallthrough
+		case opStructFieldAnonymousHeadInt8PtrIndent:
+			p := load(ctxptr, code.idx)
+			if p == 0 {
+				code = code.end.next
+				break
+			}
+			b = e.encodeIndent(b, code.indent)
+			b = append(b, code.key...)
+			b = append(b, ' ')
+			p = e.ptrToPtr(p)
+			if p == 0 {
+				b = encodeNull(b)
+			} else {
+				b = appendInt(b, int64(e.ptrToInt8(p+code.offset)))
+			}
+			b = encodeIndentComma(b)
+			code = code.next
+		case opStructEscapedFieldPtrAnonymousHeadInt8PtrIndent:
+			store(ctxptr, code.idx, e.ptrToPtr(load(ctxptr, code.idx)))
+			fallthrough
+		case opStructEscapedFieldAnonymousHeadInt8PtrIndent:
+			p := load(ctxptr, code.idx)
+			if p == 0 {
+				code = code.end.next
+				break
+			}
+			b = e.encodeIndent(b, code.indent)
+			b = append(b, code.escapedKey...)
+			b = append(b, ' ')
+			p = e.ptrToPtr(p)
+			if p == 0 {
+				b = encodeNull(b)
+			} else {
+				b = appendInt(b, int64(e.ptrToInt8(p+code.offset)))
+			}
+			b = encodeIndentComma(b)
+			code = code.next
+		case opStructFieldPtrAnonymousHeadInt8PtrOnlyIndent:
+			p := load(ctxptr, code.idx)
+			if p == 0 {
+				code = code.end.next
+				break
+			}
+			store(ctxptr, code.idx, e.ptrToPtr(p))
+			fallthrough
+		case opStructFieldAnonymousHeadInt8PtrOnlyIndent:
+			p := load(ctxptr, code.idx)
+			b = e.encodeIndent(b, code.indent)
+			b = append(b, code.key...)
+			b = append(b, ' ')
+			if p == 0 {
+				b = encodeNull(b)
+			} else {
+				b = appendInt(b, int64(e.ptrToInt8(p+code.offset)))
+			}
+			b = encodeIndentComma(b)
+			code = code.next
+		case opStructEscapedFieldPtrAnonymousHeadInt8PtrOnlyIndent:
+			p := load(ctxptr, code.idx)
+			if p == 0 {
+				code = code.end.next
+				break
+			}
+			store(ctxptr, code.idx, e.ptrToPtr(p))
+			fallthrough
+		case opStructEscapedFieldAnonymousHeadInt8PtrOnlyIndent:
+			p := load(ctxptr, code.idx)
+			b = e.encodeIndent(b, code.indent)
+			b = append(b, code.escapedKey...)
+			b = append(b, ' ')
+			if p == 0 {
+				b = encodeNull(b)
+			} else {
+				b = appendInt(b, int64(e.ptrToInt8(p+code.offset)))
+			}
+			b = encodeIndentComma(b)
+			code = code.next
 		case opStructFieldPtrHeadInt16Indent:
 			store(ctxptr, code.idx, e.ptrToPtr(load(ctxptr, code.idx)))
 			fallthrough
@@ -14696,6 +14984,32 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, b []byte, code *opcode) ([]byte
 			b = appendInt(b, int64(e.ptrToInt8(ptr+code.offset)))
 			b = e.appendStructEndIndent(b, code.indent-1)
 			code = code.next
+		case opStructEndInt8PtrIndent:
+			b = e.encodeIndent(b, code.indent)
+			b = append(b, code.key...)
+			b = append(b, ' ')
+			ptr := load(ctxptr, code.headIdx)
+			p := e.ptrToPtr(ptr + code.offset)
+			if p == 0 {
+				b = encodeNull(b)
+			} else {
+				b = appendInt(b, int64(e.ptrToInt8(p)))
+			}
+			b = e.appendStructEndIndent(b, code.indent-1)
+			code = code.next
+		case opStructEscapedEndInt8PtrIndent:
+			b = e.encodeIndent(b, code.indent)
+			b = append(b, code.escapedKey...)
+			b = append(b, ' ')
+			ptr := load(ctxptr, code.headIdx)
+			p := e.ptrToPtr(ptr + code.offset)
+			if p == 0 {
+				b = encodeNull(b)
+			} else {
+				b = appendInt(b, int64(e.ptrToInt8(p)))
+			}
+			b = e.appendStructEndIndent(b, code.indent-1)
+			code = code.next
 		case opStructEndInt16Indent:
 			b = e.encodeIndent(b, code.indent)
 			b = append(b, code.key...)