plugin/metrics: Switch to using promhttp instead of deprecated Handler (#1312)

prometheus.Handler is deprecated according to the godoc for the package so
instead we're using promhttp.

Additionally, we are exposing the Registry that metrics is using so other
plugins that are not inside of coredns can read the registry. Otherwise, if
we kept using the Default one, there's no way to access that from outside
of the coredns repo since it is vendored.

vendor/github.com/mailru/easyjson/benchmark/codec_test.go

@@ -0,0 +1,279 @@
+// +build use_codec
+
+package benchmark
+
+import (
+	"testing"
+
+	"github.com/ugorji/go/codec"
+)
+
+func BenchmarkCodec_Unmarshal_M(b *testing.B) {
+	var h codec.Handle = new(codec.JsonHandle)
+	dec := codec.NewDecoderBytes(nil, h)
+
+	b.SetBytes(int64(len(largeStructText)))
+	for i := 0; i < b.N; i++ {
+		var s LargeStruct
+		dec.ResetBytes(largeStructText)
+		if err := dec.Decode(&s); err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkCodec_Unmarshal_S(b *testing.B) {
+	var h codec.Handle = new(codec.JsonHandle)
+	dec := codec.NewDecoderBytes(nil, h)
+
+	b.SetBytes(int64(len(smallStructText)))
+	for i := 0; i < b.N; i++ {
+		var s LargeStruct
+		dec.ResetBytes(smallStructText)
+		if err := dec.Decode(&s); err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkCodec_Marshal_S(b *testing.B) {
+	var h codec.Handle = new(codec.JsonHandle)
+
+	var out []byte
+	enc := codec.NewEncoderBytes(&out, h)
+
+	var l int64
+	for i := 0; i < b.N; i++ {
+		enc.ResetBytes(&out)
+		if err := enc.Encode(&smallStructData); err != nil {
+			b.Error(err)
+		}
+		l = int64(len(out))
+		out = nil
+	}
+
+	b.SetBytes(l)
+}
+
+func BenchmarkCodec_Marshal_M(b *testing.B) {
+	var h codec.Handle = new(codec.JsonHandle)
+
+	var out []byte
+	enc := codec.NewEncoderBytes(&out, h)
+
+	var l int64
+	for i := 0; i < b.N; i++ {
+		enc.ResetBytes(&out)
+		if err := enc.Encode(&largeStructData); err != nil {
+			b.Error(err)
+		}
+		l = int64(len(out))
+		out = nil
+	}
+
+	b.SetBytes(l)
+}
+
+func BenchmarkCodec_Marshal_L(b *testing.B) {
+	var h codec.Handle = new(codec.JsonHandle)
+
+	var out []byte
+	enc := codec.NewEncoderBytes(&out, h)
+
+	var l int64
+	for i := 0; i < b.N; i++ {
+		enc.ResetBytes(&out)
+		if err := enc.Encode(&xlStructData); err != nil {
+			b.Error(err)
+		}
+		l = int64(len(out))
+		out = nil
+	}
+
+	b.SetBytes(l)
+}
+
+func BenchmarkCodec_Marshal_S_Reuse(b *testing.B) {
+	var h codec.Handle = new(codec.JsonHandle)
+
+	var out []byte
+	enc := codec.NewEncoderBytes(&out, h)
+
+	var l int64
+	for i := 0; i < b.N; i++ {
+		enc.ResetBytes(&out)
+		if err := enc.Encode(&smallStructData); err != nil {
+			b.Error(err)
+		}
+		l = int64(len(out))
+		out = out[:0]
+	}
+
+	b.SetBytes(l)
+}
+
+func BenchmarkCodec_Marshal_M_Reuse(b *testing.B) {
+	var h codec.Handle = new(codec.JsonHandle)
+
+	var out []byte
+	enc := codec.NewEncoderBytes(&out, h)
+
+	var l int64
+	for i := 0; i < b.N; i++ {
+		enc.ResetBytes(&out)
+		if err := enc.Encode(&largeStructData); err != nil {
+			b.Error(err)
+		}
+		l = int64(len(out))
+		out = out[:0]
+	}
+
+	b.SetBytes(l)
+}
+
+func BenchmarkCodec_Marshal_L_Reuse(b *testing.B) {
+	var h codec.Handle = new(codec.JsonHandle)
+
+	var out []byte
+	enc := codec.NewEncoderBytes(&out, h)
+
+	var l int64
+	for i := 0; i < b.N; i++ {
+		enc.ResetBytes(&out)
+		if err := enc.Encode(&xlStructData); err != nil {
+			b.Error(err)
+		}
+		l = int64(len(out))
+		out = out[:0]
+	}
+
+	b.SetBytes(l)
+}
+
+func BenchmarkCodec_Marshal_S_Parallel(b *testing.B) {
+	var l int64
+
+	b.RunParallel(func(pb *testing.PB) {
+		var out []byte
+
+		var h codec.Handle = new(codec.JsonHandle)
+		enc := codec.NewEncoderBytes(&out, h)
+
+		for pb.Next() {
+			enc.ResetBytes(&out)
+			if err := enc.Encode(&smallStructData); err != nil {
+				b.Error(err)
+			}
+			l = int64(len(out))
+			out = nil
+		}
+	})
+
+	b.SetBytes(l)
+}
+
+func BenchmarkCodec_Marshal_M_Parallel(b *testing.B) {
+	var l int64
+
+	b.RunParallel(func(pb *testing.PB) {
+		var h codec.Handle = new(codec.JsonHandle)
+
+		var out []byte
+		enc := codec.NewEncoderBytes(&out, h)
+
+		for pb.Next() {
+			enc.ResetBytes(&out)
+			if err := enc.Encode(&largeStructData); err != nil {
+				b.Error(err)
+			}
+			l = int64(len(out))
+			out = nil
+		}
+	})
+	b.SetBytes(l)
+}
+
+func BenchmarkCodec_Marshal_L_Parallel(b *testing.B) {
+	var l int64
+
+	b.RunParallel(func(pb *testing.PB) {
+		var h codec.Handle = new(codec.JsonHandle)
+
+		var out []byte
+		enc := codec.NewEncoderBytes(&out, h)
+
+		for pb.Next() {
+			enc.ResetBytes(&out)
+			if err := enc.Encode(&xlStructData); err != nil {
+				b.Error(err)
+			}
+			l = int64(len(out))
+			out = nil
+		}
+	})
+	b.SetBytes(l)
+}
+
+func BenchmarkCodec_Marshal_S_Parallel_Reuse(b *testing.B) {
+	var l int64
+
+	b.RunParallel(func(pb *testing.PB) {
+		var out []byte
+
+		var h codec.Handle = new(codec.JsonHandle)
+		enc := codec.NewEncoderBytes(&out, h)
+
+		for pb.Next() {
+			enc.ResetBytes(&out)
+			if err := enc.Encode(&smallStructData); err != nil {
+				b.Error(err)
+			}
+			l = int64(len(out))
+			out = out[:0]
+		}
+	})
+
+	b.SetBytes(l)
+}
+
+func BenchmarkCodec_Marshal_M_Parallel_Reuse(b *testing.B) {
+	var l int64
+
+	b.RunParallel(func(pb *testing.PB) {
+		var h codec.Handle = new(codec.JsonHandle)
+
+		var out []byte
+		enc := codec.NewEncoderBytes(&out, h)
+
+		for pb.Next() {
+			enc.ResetBytes(&out)
+			if err := enc.Encode(&largeStructData); err != nil {
+				b.Error(err)
+			}
+			l = int64(len(out))
+			out = out[:0]
+		}
+	})
+	b.SetBytes(l)
+}
+
+func BenchmarkCodec_Marshal_L_Parallel_Reuse(b *testing.B) {
+	var l int64
+
+	b.RunParallel(func(pb *testing.PB) {
+		var h codec.Handle = new(codec.JsonHandle)
+
+		var out []byte
+		enc := codec.NewEncoderBytes(&out, h)
+
+		for pb.Next() {
+			enc.ResetBytes(&out)
+			if err := enc.Encode(&xlStructData); err != nil {
+				b.Error(err)
+			}
+			l = int64(len(out))
+			out = out[:0]
+		}
+	})
+	b.SetBytes(l)
+}

vendor/github.com/mailru/easyjson/benchmark/data.go

@@ -0,0 +1,148 @@
+// Package benchmark provides a simple benchmark for easyjson against default serialization and ffjson.
+// The data example is taken from https://dev.twitter.com/rest/reference/get/search/tweets
+package benchmark
+
+import (
+	"io/ioutil"
+)
+
+var largeStructText, _ = ioutil.ReadFile("example.json")
+var xlStructData XLStruct
+
+func init() {
+	for i := 0; i < 50; i++ {
+		xlStructData.Data = append(xlStructData.Data, largeStructData)
+	}
+}
+
+var smallStructText = []byte(`{"hashtags":[{"indices":[5, 10],"text":"some-text"}],"urls":[],"user_mentions":[]}`)
+var smallStructData = Entities{
+	Hashtags:     []Hashtag{{Indices: []int{5, 10}, Text: "some-text"}},
+	Urls:         []*string{},
+	UserMentions: []*string{},
+}
+
+type SearchMetadata struct {
+	CompletedIn float64 `json:"completed_in"`
+	Count       int     `json:"count"`
+	MaxID       int64   `json:"max_id"`
+	MaxIDStr    string  `json:"max_id_str"`
+	NextResults string  `json:"next_results"`
+	Query       string  `json:"query"`
+	RefreshURL  string  `json:"refresh_url"`
+	SinceID     int64   `json:"since_id"`
+	SinceIDStr  string  `json:"since_id_str"`
+}
+
+type Hashtag struct {
+	Indices []int  `json:"indices"`
+	Text    string `json:"text"`
+}
+
+//easyjson:json
+type Entities struct {
+	Hashtags     []Hashtag `json:"hashtags"`
+	Urls         []*string `json:"urls"`
+	UserMentions []*string `json:"user_mentions"`
+}
+
+type UserEntityDescription struct {
+	Urls []*string `json:"urls"`
+}
+
+type URL struct {
+	ExpandedURL *string `json:"expanded_url"`
+	Indices     []int   `json:"indices"`
+	URL         string  `json:"url"`
+}
+
+type UserEntityURL struct {
+	Urls []URL `json:"urls"`
+}
+
+type UserEntities struct {
+	Description UserEntityDescription `json:"description"`
+	URL         UserEntityURL         `json:"url"`
+}
+
+type User struct {
+	ContributorsEnabled            bool         `json:"contributors_enabled"`
+	CreatedAt                      string       `json:"created_at"`
+	DefaultProfile                 bool         `json:"default_profile"`
+	DefaultProfileImage            bool         `json:"default_profile_image"`
+	Description                    string       `json:"description"`
+	Entities                       UserEntities `json:"entities"`
+	FavouritesCount                int          `json:"favourites_count"`
+	FollowRequestSent              *string      `json:"follow_request_sent"`
+	FollowersCount                 int          `json:"followers_count"`
+	Following                      *string      `json:"following"`
+	FriendsCount                   int          `json:"friends_count"`
+	GeoEnabled                     bool         `json:"geo_enabled"`
+	ID                             int          `json:"id"`
+	IDStr                          string       `json:"id_str"`
+	IsTranslator                   bool         `json:"is_translator"`
+	Lang                           string       `json:"lang"`
+	ListedCount                    int          `json:"listed_count"`
+	Location                       string       `json:"location"`
+	Name                           string       `json:"name"`
+	Notifications                  *string      `json:"notifications"`
+	ProfileBackgroundColor         string       `json:"profile_background_color"`
+	ProfileBackgroundImageURL      string       `json:"profile_background_image_url"`
+	ProfileBackgroundImageURLHTTPS string       `json:"profile_background_image_url_https"`
+	ProfileBackgroundTile          bool         `json:"profile_background_tile"`
+	ProfileImageURL                string       `json:"profile_image_url"`
+	ProfileImageURLHTTPS           string       `json:"profile_image_url_https"`
+	ProfileLinkColor               string       `json:"profile_link_color"`
+	ProfileSidebarBorderColor      string       `json:"profile_sidebar_border_color"`
+	ProfileSidebarFillColor        string       `json:"profile_sidebar_fill_color"`
+	ProfileTextColor               string       `json:"profile_text_color"`
+	ProfileUseBackgroundImage      bool         `json:"profile_use_background_image"`
+	Protected                      bool         `json:"protected"`
+	ScreenName                     string       `json:"screen_name"`
+	ShowAllInlineMedia             bool         `json:"show_all_inline_media"`
+	StatusesCount                  int          `json:"statuses_count"`
+	TimeZone                       string       `json:"time_zone"`
+	URL                            *string      `json:"url"`
+	UtcOffset                      int          `json:"utc_offset"`
+	Verified                       bool         `json:"verified"`
+}
+
+type StatusMetadata struct {
+	IsoLanguageCode string `json:"iso_language_code"`
+	ResultType      string `json:"result_type"`
+}
+
+type Status struct {
+	Contributors         *string        `json:"contributors"`
+	Coordinates          *string        `json:"coordinates"`
+	CreatedAt            string         `json:"created_at"`
+	Entities             Entities       `json:"entities"`
+	Favorited            bool           `json:"favorited"`
+	Geo                  *string        `json:"geo"`
+	ID                   int64          `json:"id"`
+	IDStr                string         `json:"id_str"`
+	InReplyToScreenName  *string        `json:"in_reply_to_screen_name"`
+	InReplyToStatusID    *string        `json:"in_reply_to_status_id"`
+	InReplyToStatusIDStr *string        `json:"in_reply_to_status_id_str"`
+	InReplyToUserID      *string        `json:"in_reply_to_user_id"`
+	InReplyToUserIDStr   *string        `json:"in_reply_to_user_id_str"`
+	Metadata             StatusMetadata `json:"metadata"`
+	Place                *string        `json:"place"`
+	RetweetCount         int            `json:"retweet_count"`
+	Retweeted            bool           `json:"retweeted"`
+	Source               string         `json:"source"`
+	Text                 string         `json:"text"`
+	Truncated            bool           `json:"truncated"`
+	User                 User           `json:"user"`
+}
+
+//easyjson:json
+type LargeStruct struct {
+	SearchMetadata SearchMetadata `json:"search_metadata"`
+	Statuses       []Status       `json:"statuses"`
+}
+
+//easyjson:json
+type XLStruct struct {
+	Data []LargeStruct
+}

vendor/github.com/mailru/easyjson/benchmark/data_var.go

@@ -0,0 +1,350 @@
+package benchmark
+
+var largeStructData = LargeStruct{
+	SearchMetadata: SearchMetadata{
+		CompletedIn: 0.035,
+		Count:       4,
+		MaxID:       250126199840518145,
+		MaxIDStr:    "250126199840518145",
+		NextResults: "?max_id=249279667666817023&q=%23freebandnames&count=4&include_entities=1&result_type=mixed",
+		Query:       "%23freebandnames",
+		RefreshURL:  "?since_id=250126199840518145&q=%23freebandnames&result_type=mixed&include_entities=1",
+		SinceID:     24012619984051000,
+		SinceIDStr:  "24012619984051000",
+	},
+	Statuses: []Status{
+		{
+			Contributors: nil,
+			Coordinates:  nil,
+			CreatedAt:    "Mon Sep 24 03:35:21 +0000 2012",
+			Entities: Entities{
+				Hashtags: []Hashtag{{
+					Indices: []int{20, 34},
+					Text:    "freebandnames"},
+				},
+				Urls:         []*string{},
+				UserMentions: []*string{},
+			},
+			Favorited:            false,
+			Geo:                  nil,
+			ID:                   250075927172759552,
+			IDStr:                "250075927172759552",
+			InReplyToScreenName:  nil,
+			InReplyToStatusID:    nil,
+			InReplyToStatusIDStr: nil,
+			InReplyToUserID:      nil,
+			InReplyToUserIDStr:   nil,
+			Metadata: StatusMetadata{
+				IsoLanguageCode: "en",
+				ResultType:      "recent",
+			},
+			Place:        nil,
+			RetweetCount: 0,
+			Retweeted:    false,
+			Source:       "<a href=\"//itunes.apple.com/us/app/twitter/id409789998?mt=12%5C%22\" rel=\"\\\"nofollow\\\"\">Twitter for Mac</a>",
+			Text:         "Aggressive Ponytail #freebandnames",
+			Truncated:    false,
+			User: User{
+				ContributorsEnabled: false,
+				CreatedAt:           "Mon Apr 26 06:01:55 +0000 2010",
+				DefaultProfile:      true,
+				DefaultProfileImage: false,
+				Description:         "Born 330 Live 310",
+				Entities: UserEntities{
+					Description: UserEntityDescription{
+						Urls: []*string{},
+					},
+					URL: UserEntityURL{
+						Urls: []URL{{
+							ExpandedURL: nil,
+							Indices:     []int{0, 0},
+							URL:         "",
+						}},
+					},
+				},
+				FavouritesCount:                0,
+				FollowRequestSent:              nil,
+				FollowersCount:                 70,
+				Following:                      nil,
+				FriendsCount:                   110,
+				GeoEnabled:                     true,
+				ID:                             137238150,
+				IDStr:                          "137238150",
+				IsTranslator:                   false,
+				Lang:                           "en",
+				ListedCount:                    2,
+				Location:                       "LA, CA",
+				Name:                           "Sean Cummings",
+				Notifications:                  nil,
+				ProfileBackgroundColor:         "C0DEED",
+				ProfileBackgroundImageURL:      "http://a0.twimg.com/images/themes/theme1/bg.png",
+				ProfileBackgroundImageURLHTTPS: "https://si0.twimg.com/images/themes/theme1/bg.png",
+				ProfileBackgroundTile:          false,
+				ProfileImageURL:                "http://a0.twimg.com/profile_images/2359746665/1v6zfgqo8g0d3mk7ii5s_normal.jpeg",
+				ProfileImageURLHTTPS:           "https://si0.twimg.com/profile_images/2359746665/1v6zfgqo8g0d3mk7ii5s_normal.jpeg",
+				ProfileLinkColor:               "0084B4",
+				ProfileSidebarBorderColor:      "C0DEED",
+				ProfileSidebarFillColor:        "DDEEF6",
+				ProfileTextColor:               "333333",
+				ProfileUseBackgroundImage:      true,
+				Protected:                      false,
+				ScreenName:                     "sean_cummings",
+				ShowAllInlineMedia:             false,
+				StatusesCount:                  579,
+				TimeZone:                       "Pacific Time (US & Canada)",
+				URL:                            nil,
+				UtcOffset:                      -28800,
+				Verified:                       false,
+			},
+		},
+		{
+			Contributors: nil,
+			Coordinates:  nil,
+			CreatedAt:    "Fri Sep 21 23:40:54 +0000 2012",
+			Entities: Entities{
+				Hashtags: []Hashtag{{
+					Indices: []int{20, 34},
+					Text:    "FreeBandNames",
+				}},
+				Urls:         []*string{},
+				UserMentions: []*string{},
+			},
+			Favorited:            false,
+			Geo:                  nil,
+			ID:                   249292149810667520,
+			IDStr:                "249292149810667520",
+			InReplyToScreenName:  nil,
+			InReplyToStatusID:    nil,
+			InReplyToStatusIDStr: nil,
+			InReplyToUserID:      nil,
+			InReplyToUserIDStr:   nil,
+			Metadata: StatusMetadata{
+				IsoLanguageCode: "pl",
+				ResultType:      "recent",
+			},
+			Place:        nil,
+			RetweetCount: 0,
+			Retweeted:    false,
+			Source:       "web",
+			Text:         "Thee Namaste Nerdz. #FreeBandNames",
+			Truncated:    false,
+			User: User{
+				ContributorsEnabled: false,
+				CreatedAt:           "Tue Apr 07 19:05:07 +0000 2009",
+				DefaultProfile:      false,
+				DefaultProfileImage: false,
+				Description:         "You will come to Durham, North Carolina. I will sell you some records then, here in Durham, North Carolina. Fun will happen.",
+				Entities: UserEntities{
+					Description: UserEntityDescription{Urls: []*string{}},
+					URL: UserEntityURL{
+						Urls: []URL{{
+							ExpandedURL: nil,
+							Indices:     []int{0, 32},
+							URL:         "http://bullcityrecords.com/wnng/"}},
+					},
+				},
+				FavouritesCount:                8,
+				FollowRequestSent:              nil,
+				FollowersCount:                 2052,
+				Following:                      nil,
+				FriendsCount:                   348,
+				GeoEnabled:                     false,
+				ID:                             29516238,
+				IDStr:                          "29516238",
+				IsTranslator:                   false,
+				Lang:                           "en",
+				ListedCount:                    118,
+				Location:                       "Durham, NC",
+				Name:                           "Chaz Martenstein",
+				Notifications:                  nil,
+				ProfileBackgroundColor:         "9AE4E8",
+				ProfileBackgroundImageURL:      "http://a0.twimg.com/profile_background_images/9423277/background_tile.bmp",
+				ProfileBackgroundImageURLHTTPS: "https://si0.twimg.com/profile_background_images/9423277/background_tile.bmp",
+				ProfileBackgroundTile:          true,
+				ProfileImageURL:                "http://a0.twimg.com/profile_images/447958234/Lichtenstein_normal.jpg",
+				ProfileImageURLHTTPS:           "https://si0.twimg.com/profile_images/447958234/Lichtenstein_normal.jpg",
+				ProfileLinkColor:               "0084B4",
+				ProfileSidebarBorderColor:      "BDDCAD",
+				ProfileSidebarFillColor:        "DDFFCC",
+				ProfileTextColor:               "333333",
+				ProfileUseBackgroundImage:      true,
+				Protected:                      false,
+				ScreenName:                     "bullcityrecords",
+				ShowAllInlineMedia:             true,
+				StatusesCount:                  7579,
+				TimeZone:                       "Eastern Time (US & Canada)",
+				URL:                            nil,
+				UtcOffset:                      -18000,
+				Verified:                       false,
+			},
+		},
+		Status{
+			Contributors: nil,
+			Coordinates:  nil,
+			CreatedAt:    "Fri Sep 21 23:30:20 +0000 2012",
+			Entities: Entities{
+				Hashtags: []Hashtag{{
+					Indices: []int{29, 43},
+					Text:    "freebandnames",
+				}},
+				Urls:         []*string{},
+				UserMentions: []*string{},
+			},
+			Favorited:            false,
+			Geo:                  nil,
+			ID:                   249289491129438208,
+			IDStr:                "249289491129438208",
+			InReplyToScreenName:  nil,
+			InReplyToStatusID:    nil,
+			InReplyToStatusIDStr: nil,
+			InReplyToUserID:      nil,
+			InReplyToUserIDStr:   nil,
+			Metadata: StatusMetadata{
+				IsoLanguageCode: "en",
+				ResultType:      "recent",
+			},
+			Place:        nil,
+			RetweetCount: 0,
+			Retweeted:    false,
+			Source:       "web",
+			Text:         "Mexican Heaven, Mexican Hell #freebandnames",
+			Truncated:    false,
+			User: User{
+				ContributorsEnabled: false,
+				CreatedAt:           "Tue Sep 01 21:21:35 +0000 2009",
+				DefaultProfile:      false,
+				DefaultProfileImage: false,
+				Description:         "Science Fiction Writer, sort of. Likes Superheroes, Mole People, Alt. Timelines.",
+				Entities: UserEntities{
+					Description: UserEntityDescription{
+						Urls: nil,
+					},
+					URL: UserEntityURL{
+						Urls: []URL{{
+							ExpandedURL: nil,
+							Indices:     []int{0, 0},
+							URL:         "",
+						}},
+					},
+				},
+				FavouritesCount:                19,
+				FollowRequestSent:              nil,
+				FollowersCount:                 63,
+				Following:                      nil,
+				FriendsCount:                   63,
+				GeoEnabled:                     false,
+				ID:                             70789458,
+				IDStr:                          "70789458",
+				IsTranslator:                   false,
+				Lang:                           "en",
+				ListedCount:                    1,
+				Location:                       "Kingston New York",
+				Name:                           "Thomas John Wakeman",
+				Notifications:                  nil,
+				ProfileBackgroundColor:         "352726",
+				ProfileBackgroundImageURL:      "http://a0.twimg.com/images/themes/theme5/bg.gif",
+				ProfileBackgroundImageURLHTTPS: "https://si0.twimg.com/images/themes/theme5/bg.gif",
+				ProfileBackgroundTile:          false,
+				ProfileImageURL:                "http://a0.twimg.com/profile_images/2219333930/Froggystyle_normal.png",
+				ProfileImageURLHTTPS:           "https://si0.twimg.com/profile_images/2219333930/Froggystyle_normal.png",
+				ProfileLinkColor:               "D02B55",
+				ProfileSidebarBorderColor:      "829D5E",
+				ProfileSidebarFillColor:        "99CC33",
+				ProfileTextColor:               "3E4415",
+				ProfileUseBackgroundImage:      true,
+				Protected:                      false,
+				ScreenName:                     "MonkiesFist",
+				ShowAllInlineMedia:             false,
+				StatusesCount:                  1048,
+				TimeZone:                       "Eastern Time (US & Canada)",
+				URL:                            nil,
+				UtcOffset:                      -18000,
+				Verified:                       false,
+			},
+		},
+		Status{
+			Contributors: nil,
+			Coordinates:  nil,
+			CreatedAt:    "Fri Sep 21 22:51:18 +0000 2012",
+			Entities: Entities{
+				Hashtags: []Hashtag{{
+					Indices: []int{20, 34},
+					Text:    "freebandnames",
+				}},
+				Urls:         []*string{},
+				UserMentions: []*string{},
+			},
+			Favorited:            false,
+			Geo:                  nil,
+			ID:                   249279667666817024,
+			IDStr:                "249279667666817024",
+			InReplyToScreenName:  nil,
+			InReplyToStatusID:    nil,
+			InReplyToStatusIDStr: nil,
+			InReplyToUserID:      nil,
+			InReplyToUserIDStr:   nil,
+			Metadata: StatusMetadata{
+				IsoLanguageCode: "en",
+				ResultType:      "recent",
+			},
+			Place:        nil,
+			RetweetCount: 0,
+			Retweeted:    false,
+			Source:       "<a href=\"//twitter.com/download/iphone%5C%22\" rel=\"\\\"nofollow\\\"\">Twitter for iPhone</a>",
+			Text:         "The Foolish Mortals #freebandnames",
+			Truncated:    false,
+			User: User{
+				ContributorsEnabled: false,
+				CreatedAt:           "Mon May 04 00:05:00 +0000 2009",
+				DefaultProfile:      false,
+				DefaultProfileImage: false,
+				Description:         "Cartoonist, Illustrator, and T-Shirt connoisseur",
+				Entities: UserEntities{
+					Description: UserEntityDescription{
+						Urls: []*string{},
+					},
+					URL: UserEntityURL{
+						Urls: []URL{{
+							ExpandedURL: nil,
+							Indices:     []int{0, 24},
+							URL:         "http://www.omnitarian.me",
+						}},
+					},
+				},
+				FavouritesCount:                647,
+				FollowRequestSent:              nil,
+				FollowersCount:                 608,
+				Following:                      nil,
+				FriendsCount:                   249,
+				GeoEnabled:                     false,
+				ID:                             37539828,
+				IDStr:                          "37539828",
+				IsTranslator:                   false,
+				Lang:                           "en",
+				ListedCount:                    52,
+				Location:                       "Wisconsin, USA",
+				Name:                           "Marty Elmer",
+				Notifications:                  nil,
+				ProfileBackgroundColor:         "EEE3C4",
+				ProfileBackgroundImageURL:      "http://a0.twimg.com/profile_background_images/106455659/rect6056-9.png",
+				ProfileBackgroundImageURLHTTPS: "https://si0.twimg.com/profile_background_images/106455659/rect6056-9.png",
+				ProfileBackgroundTile:          true,
+				ProfileImageURL:                "http://a0.twimg.com/profile_images/1629790393/shrinker_2000_trans_normal.png",
+				ProfileImageURLHTTPS:           "https://si0.twimg.com/profile_images/1629790393/shrinker_2000_trans_normal.png",
+				ProfileLinkColor:               "3B2A26",
+				ProfileSidebarBorderColor:      "615A44",
+				ProfileSidebarFillColor:        "BFAC83",
+				ProfileTextColor:               "000000",
+				ProfileUseBackgroundImage:      true,
+				Protected:                      false,
+				ScreenName:                     "Omnitarian",
+				ShowAllInlineMedia:             true,
+				StatusesCount:                  3575,
+				TimeZone:                       "Central Time (US & Canada)",
+				URL:                            nil,
+				UtcOffset:                      -21600,
+				Verified:                       false,
+			},
+		},
+	},
+}

vendor/github.com/mailru/easyjson/benchmark/default_test.go

@@ -0,0 +1,118 @@
+// +build !use_easyjson,!use_ffjson,!use_codec,!use_jsoniter
+
+package benchmark
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func BenchmarkStd_Unmarshal_M(b *testing.B) {
+	b.SetBytes(int64(len(largeStructText)))
+	for i := 0; i < b.N; i++ {
+		var s LargeStruct
+		err := json.Unmarshal(largeStructText, &s)
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkStd_Unmarshal_S(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		var s Entities
+		err := json.Unmarshal(smallStructText, &s)
+		if err != nil {
+			b.Error(err)
+		}
+	}
+	b.SetBytes(int64(len(smallStructText)))
+}
+
+func BenchmarkStd_Marshal_M(b *testing.B) {
+	var l int64
+	for i := 0; i < b.N; i++ {
+		data, err := json.Marshal(&largeStructData)
+		if err != nil {
+			b.Error(err)
+		}
+		l = int64(len(data))
+	}
+	b.SetBytes(l)
+}
+
+func BenchmarkStd_Marshal_L(b *testing.B) {
+	var l int64
+	for i := 0; i < b.N; i++ {
+		data, err := json.Marshal(&xlStructData)
+		if err != nil {
+			b.Error(err)
+		}
+		l = int64(len(data))
+	}
+	b.SetBytes(l)
+}
+
+func BenchmarkStd_Marshal_M_Parallel(b *testing.B) {
+	var l int64
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			data, err := json.Marshal(&largeStructData)
+			if err != nil {
+				b.Error(err)
+			}
+			l = int64(len(data))
+		}
+	})
+	b.SetBytes(l)
+}
+
+func BenchmarkStd_Marshal_L_Parallel(b *testing.B) {
+	var l int64
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			data, err := json.Marshal(&xlStructData)
+			if err != nil {
+				b.Error(err)
+			}
+			l = int64(len(data))
+		}
+	})
+	b.SetBytes(l)
+}
+
+func BenchmarkStd_Marshal_S(b *testing.B) {
+	var l int64
+	for i := 0; i < b.N; i++ {
+		data, err := json.Marshal(&smallStructData)
+		if err != nil {
+			b.Error(err)
+		}
+		l = int64(len(data))
+	}
+	b.SetBytes(l)
+}
+
+func BenchmarkStd_Marshal_S_Parallel(b *testing.B) {
+	var l int64
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			data, err := json.Marshal(&smallStructData)
+			if err != nil {
+				b.Error(err)
+			}
+			l = int64(len(data))
+		}
+	})
+	b.SetBytes(l)
+}
+
+func BenchmarkStd_Marshal_M_ToWriter(b *testing.B) {
+	enc := json.NewEncoder(&DummyWriter{})
+	for i := 0; i < b.N; i++ {
+		err := enc.Encode(&largeStructData)
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}

vendor/github.com/mailru/easyjson/benchmark/dummy_test.go

@@ -0,0 +1,11 @@
+package benchmark
+
+import (
+	"testing"
+)
+
+type DummyWriter struct{}
+
+func (w DummyWriter) Write(data []byte) (int, error) { return len(data), nil }
+
+func TestToSuppressNoTestsWarning(t *testing.T) {}

vendor/github.com/mailru/easyjson/benchmark/easyjson_test.go

@@ -0,0 +1,184 @@
+// +build use_easyjson
+
+package benchmark
+
+import (
+	"testing"
+
+	"github.com/mailru/easyjson"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+func BenchmarkEJ_Unmarshal_M(b *testing.B) {
+	b.SetBytes(int64(len(largeStructText)))
+	for i := 0; i < b.N; i++ {
+		var s LargeStruct
+		err := s.UnmarshalJSON(largeStructText)
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkEJ_Unmarshal_S(b *testing.B) {
+	b.SetBytes(int64(len(smallStructText)))
+
+	for i := 0; i < b.N; i++ {
+		var s Entities
+		err := s.UnmarshalJSON(smallStructText)
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkEJ_Marshal_M(b *testing.B) {
+	var l int64
+	for i := 0; i < b.N; i++ {
+		data, err := easyjson.Marshal(&largeStructData)
+		if err != nil {
+			b.Error(err)
+		}
+		l = int64(len(data))
+	}
+	b.SetBytes(l)
+}
+
+func BenchmarkEJ_Marshal_L(b *testing.B) {
+	var l int64
+	for i := 0; i < b.N; i++ {
+		data, err := easyjson.Marshal(&xlStructData)
+		if err != nil {
+			b.Error(err)
+		}
+		l = int64(len(data))
+	}
+	b.SetBytes(l)
+}
+
+func BenchmarkEJ_Marshal_L_ToWriter(b *testing.B) {
+	var l int64
+	out := &DummyWriter{}
+	for i := 0; i < b.N; i++ {
+		w := jwriter.Writer{}
+		xlStructData.MarshalEasyJSON(&w)
+		if w.Error != nil {
+			b.Error(w.Error)
+		}
+
+		l = int64(w.Size())
+		w.DumpTo(out)
+	}
+	b.SetBytes(l)
+
+}
+func BenchmarkEJ_Marshal_M_Parallel(b *testing.B) {
+	b.SetBytes(int64(len(largeStructText)))
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_, err := largeStructData.MarshalJSON()
+			if err != nil {
+				b.Error(err)
+			}
+		}
+	})
+}
+
+func BenchmarkEJ_Marshal_M_ToWriter(b *testing.B) {
+	var l int64
+	out := &DummyWriter{}
+	for i := 0; i < b.N; i++ {
+		w := jwriter.Writer{}
+		largeStructData.MarshalEasyJSON(&w)
+		if w.Error != nil {
+			b.Error(w.Error)
+		}
+
+		l = int64(w.Size())
+		w.DumpTo(out)
+	}
+	b.SetBytes(l)
+
+}
+func BenchmarkEJ_Marshal_M_ToWriter_Parallel(b *testing.B) {
+	out := &DummyWriter{}
+
+	b.RunParallel(func(pb *testing.PB) {
+		var l int64
+		for pb.Next() {
+			w := jwriter.Writer{}
+			largeStructData.MarshalEasyJSON(&w)
+			if w.Error != nil {
+				b.Error(w.Error)
+			}
+
+			l = int64(w.Size())
+			w.DumpTo(out)
+		}
+		if l > 0 {
+			b.SetBytes(l)
+		}
+	})
+
+}
+
+func BenchmarkEJ_Marshal_L_Parallel(b *testing.B) {
+	var l int64
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			data, err := xlStructData.MarshalJSON()
+			if err != nil {
+				b.Error(err)
+			}
+			l = int64(len(data))
+		}
+	})
+	b.SetBytes(l)
+}
+
+func BenchmarkEJ_Marshal_L_ToWriter_Parallel(b *testing.B) {
+	out := &DummyWriter{}
+	b.RunParallel(func(pb *testing.PB) {
+		var l int64
+		for pb.Next() {
+			w := jwriter.Writer{}
+
+			xlStructData.MarshalEasyJSON(&w)
+			if w.Error != nil {
+				b.Error(w.Error)
+			}
+			l = int64(w.Size())
+			w.DumpTo(out)
+		}
+		if l > 0 {
+			b.SetBytes(l)
+		}
+	})
+}
+
+func BenchmarkEJ_Marshal_S(b *testing.B) {
+	var l int64
+	for i := 0; i < b.N; i++ {
+		data, err := smallStructData.MarshalJSON()
+		if err != nil {
+			b.Error(err)
+		}
+		l = int64(len(data))
+	}
+	b.SetBytes(l)
+}
+
+func BenchmarkEJ_Marshal_S_Parallel(b *testing.B) {
+	var l int64
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			data, err := smallStructData.MarshalJSON()
+			if err != nil {
+				b.Error(err)
+			}
+			l = int64(len(data))
+		}
+	})
+	b.SetBytes(l)
+}

vendor/github.com/mailru/easyjson/benchmark/example.json

@@ -0,0 +1,415 @@
+{
+  "statuses": [
+    {
+      "coordinates": null,
+      "favorited": false,
+      "truncated": false,
+      "created_at": "Mon Sep 24 03:35:21 +0000 2012",
+      "id_str": "250075927172759552",
+      "entities": {
+        "urls": [
+ 
+        ],
+        "hashtags": [
+          {
+            "text": "freebandnames",
+            "indices": [
+              20,
+              34
+            ]
+          }
+        ],
+        "user_mentions": [
+ 
+        ]
+      },
+      "in_reply_to_user_id_str": null,
+      "contributors": null,
+      "text": "Aggressive Ponytail #freebandnames",
+      "metadata": {
+        "iso_language_code": "en",
+        "result_type": "recent"
+      },
+      "retweet_count": 0,
+      "in_reply_to_status_id_str": null,
+      "id": 250075927172759552,
+      "geo": null,
+      "retweeted": false,
+      "in_reply_to_user_id": null,
+      "place": null,
+      "user": {
+        "profile_sidebar_fill_color": "DDEEF6",
+        "profile_sidebar_border_color": "C0DEED",
+        "profile_background_tile": false,
+        "name": "Sean Cummings",
+        "profile_image_url": "http://a0.twimg.com/profile_images/2359746665/1v6zfgqo8g0d3mk7ii5s_normal.jpeg",
+        "created_at": "Mon Apr 26 06:01:55 +0000 2010",
+        "location": "LA, CA",
+        "follow_request_sent": null,
+        "profile_link_color": "0084B4",
+        "is_translator": false,
+        "id_str": "137238150",
+        "entities": {
+          "url": {
+            "urls": [
+              {
+                "expanded_url": null,
+                "url": "",
+                "indices": [
+                  0,
+                  0
+                ]
+              }
+            ]
+          },
+          "description": {
+            "urls": [
+ 
+            ]
+          }
+        },
+        "default_profile": true,
+        "contributors_enabled": false,
+        "favourites_count": 0,
+        "url": null,
+        "profile_image_url_https": "https://si0.twimg.com/profile_images/2359746665/1v6zfgqo8g0d3mk7ii5s_normal.jpeg",
+        "utc_offset": -28800,
+        "id": 137238150,
+        "profile_use_background_image": true,
+        "listed_count": 2,
+        "profile_text_color": "333333",
+        "lang": "en",
+        "followers_count": 70,
+        "protected": false,
+        "notifications": null,
+        "profile_background_image_url_https": "https://si0.twimg.com/images/themes/theme1/bg.png",
+        "profile_background_color": "C0DEED",
+        "verified": false,
+        "geo_enabled": true,
+        "time_zone": "Pacific Time (US & Canada)",
+        "description": "Born 330 Live 310",
+        "default_profile_image": false,
+        "profile_background_image_url": "http://a0.twimg.com/images/themes/theme1/bg.png",
+        "statuses_count": 579,
+        "friends_count": 110,
+        "following": null,
+        "show_all_inline_media": false,
+        "screen_name": "sean_cummings"
+      },
+      "in_reply_to_screen_name": null,
+      "source": "<a href=\"//itunes.apple.com/us/app/twitter/id409789998?mt=12%5C%22\" rel=\"\\\"nofollow\\\"\">Twitter for Mac</a>",
+      "in_reply_to_status_id": null
+    },
+    {
+      "coordinates": null,
+      "favorited": false,
+      "truncated": false,
+      "created_at": "Fri Sep 21 23:40:54 +0000 2012",
+      "id_str": "249292149810667520",
+      "entities": {
+        "urls": [
+ 
+        ],
+        "hashtags": [
+          {
+            "text": "FreeBandNames",
+            "indices": [
+              20,
+              34
+            ]
+          }
+        ],
+        "user_mentions": [
+ 
+        ]
+      },
+      "in_reply_to_user_id_str": null,
+      "contributors": null,
+      "text": "Thee Namaste Nerdz. #FreeBandNames",
+      "metadata": {
+        "iso_language_code": "pl",
+        "result_type": "recent"
+      },
+      "retweet_count": 0,
+      "in_reply_to_status_id_str": null,
+      "id": 249292149810667520,
+      "geo": null,
+      "retweeted": false,
+      "in_reply_to_user_id": null,
+      "place": null,
+      "user": {
+        "profile_sidebar_fill_color": "DDFFCC",
+        "profile_sidebar_border_color": "BDDCAD",
+        "profile_background_tile": true,
+        "name": "Chaz Martenstein",
+        "profile_image_url": "http://a0.twimg.com/profile_images/447958234/Lichtenstein_normal.jpg",
+        "created_at": "Tue Apr 07 19:05:07 +0000 2009",
+        "location": "Durham, NC",
+        "follow_request_sent": null,
+        "profile_link_color": "0084B4",
+        "is_translator": false,
+        "id_str": "29516238",
+        "entities": {
+          "url": {
+            "urls": [
+              {
+                "expanded_url": null,
+                "url": "http://bullcityrecords.com/wnng/",
+                "indices": [
+                  0,
+                  32
+                ]
+              }
+            ]
+          },
+          "description": {
+            "urls": [
+ 
+            ]
+          }
+        },
+        "default_profile": false,
+        "contributors_enabled": false,
+        "favourites_count": 8,
+        "url": "http://bullcityrecords.com/wnng/",
+        "profile_image_url_https": "https://si0.twimg.com/profile_images/447958234/Lichtenstein_normal.jpg",
+        "utc_offset": -18000,
+        "id": 29516238,
+        "profile_use_background_image": true,
+        "listed_count": 118,
+        "profile_text_color": "333333",
+        "lang": "en",
+        "followers_count": 2052,
+        "protected": false,
+        "notifications": null,
+        "profile_background_image_url_https": "https://si0.twimg.com/profile_background_images/9423277/background_tile.bmp",
+        "profile_background_color": "9AE4E8",
+        "verified": false,
+        "geo_enabled": false,
+        "time_zone": "Eastern Time (US & Canada)",
+        "description": "You will come to Durham, North Carolina. I will sell you some records then, here in Durham, North Carolina. Fun will happen.",
+        "default_profile_image": false,
+        "profile_background_image_url": "http://a0.twimg.com/profile_background_images/9423277/background_tile.bmp",
+        "statuses_count": 7579,
+        "friends_count": 348,
+        "following": null,
+        "show_all_inline_media": true,
+        "screen_name": "bullcityrecords"
+      },
+      "in_reply_to_screen_name": null,
+      "source": "web",
+      "in_reply_to_status_id": null
+    },
+    {
+      "coordinates": null,
+      "favorited": false,
+      "truncated": false,
+      "created_at": "Fri Sep 21 23:30:20 +0000 2012",
+      "id_str": "249289491129438208",
+      "entities": {
+        "urls": [
+ 
+        ],
+        "hashtags": [
+          {
+            "text": "freebandnames",
+            "indices": [
+              29,
+              43
+            ]
+          }
+        ],
+        "user_mentions": [
+ 
+        ]
+      },
+      "in_reply_to_user_id_str": null,
+      "contributors": null,
+      "text": "Mexican Heaven, Mexican Hell #freebandnames",
+      "metadata": {
+        "iso_language_code": "en",
+        "result_type": "recent"
+      },
+      "retweet_count": 0,
+      "in_reply_to_status_id_str": null,
+      "id": 249289491129438208,
+      "geo": null,
+      "retweeted": false,
+      "in_reply_to_user_id": null,
+      "place": null,
+      "user": {
+        "profile_sidebar_fill_color": "99CC33",
+        "profile_sidebar_border_color": "829D5E",
+        "profile_background_tile": false,
+        "name": "Thomas John Wakeman",
+        "profile_image_url": "http://a0.twimg.com/profile_images/2219333930/Froggystyle_normal.png",
+        "created_at": "Tue Sep 01 21:21:35 +0000 2009",
+        "location": "Kingston New York",
+        "follow_request_sent": null,
+        "profile_link_color": "D02B55",
+        "is_translator": false,
+        "id_str": "70789458",
+        "entities": {
+          "url": {
+            "urls": [
+              {
+                "expanded_url": null,
+                "url": "",
+                "indices": [
+                  0,
+                  0
+                ]
+              }
+            ]
+          },
+          "description": {
+            "urls": [
+ 
+            ]
+          }
+        },
+        "default_profile": false,
+        "contributors_enabled": false,
+        "favourites_count": 19,
+        "url": null,
+        "profile_image_url_https": "https://si0.twimg.com/profile_images/2219333930/Froggystyle_normal.png",
+        "utc_offset": -18000,
+        "id": 70789458,
+        "profile_use_background_image": true,
+        "listed_count": 1,
+        "profile_text_color": "3E4415",
+        "lang": "en",
+        "followers_count": 63,
+        "protected": false,
+        "notifications": null,
+        "profile_background_image_url_https": "https://si0.twimg.com/images/themes/theme5/bg.gif",
+        "profile_background_color": "352726",
+        "verified": false,
+        "geo_enabled": false,
+        "time_zone": "Eastern Time (US & Canada)",
+        "description": "Science Fiction Writer, sort of. Likes Superheroes, Mole People, Alt. Timelines.",
+        "default_profile_image": false,
+        "profile_background_image_url": "http://a0.twimg.com/images/themes/theme5/bg.gif",
+        "statuses_count": 1048,
+        "friends_count": 63,
+        "following": null,
+        "show_all_inline_media": false,
+        "screen_name": "MonkiesFist"
+      },
+      "in_reply_to_screen_name": null,
+      "source": "web",
+      "in_reply_to_status_id": null
+    },
+    {
+      "coordinates": null,
+      "favorited": false,
+      "truncated": false,
+      "created_at": "Fri Sep 21 22:51:18 +0000 2012",
+      "id_str": "249279667666817024",
+      "entities": {
+        "urls": [
+ 
+        ],
+        "hashtags": [
+          {
+            "text": "freebandnames",
+            "indices": [
+              20,
+              34
+            ]
+          }
+        ],
+        "user_mentions": [
+ 
+        ]
+      },
+      "in_reply_to_user_id_str": null,
+      "contributors": null,
+      "text": "The Foolish Mortals #freebandnames",
+      "metadata": {
+        "iso_language_code": "en",
+        "result_type": "recent"
+      },
+      "retweet_count": 0,
+      "in_reply_to_status_id_str": null,
+      "id": 249279667666817024,
+      "geo": null,
+      "retweeted": false,
+      "in_reply_to_user_id": null,
+      "place": null,
+      "user": {
+        "profile_sidebar_fill_color": "BFAC83",
+        "profile_sidebar_border_color": "615A44",
+        "profile_background_tile": true,
+        "name": "Marty Elmer",
+        "profile_image_url": "http://a0.twimg.com/profile_images/1629790393/shrinker_2000_trans_normal.png",
+        "created_at": "Mon May 04 00:05:00 +0000 2009",
+        "location": "Wisconsin, USA",
+        "follow_request_sent": null,
+        "profile_link_color": "3B2A26",
+        "is_translator": false,
+        "id_str": "37539828",
+        "entities": {
+          "url": {
+            "urls": [
+              {
+                "expanded_url": null,
+                "url": "http://www.omnitarian.me",
+                "indices": [
+                  0,
+                  24
+                ]
+              }
+            ]
+          },
+          "description": {
+            "urls": [
+ 
+            ]
+          }
+        },
+        "default_profile": false,
+        "contributors_enabled": false,
+        "favourites_count": 647,
+        "url": "http://www.omnitarian.me",
+        "profile_image_url_https": "https://si0.twimg.com/profile_images/1629790393/shrinker_2000_trans_normal.png",
+        "utc_offset": -21600,
+        "id": 37539828,
+        "profile_use_background_image": true,
+        "listed_count": 52,
+        "profile_text_color": "000000",
+        "lang": "en",
+        "followers_count": 608,
+        "protected": false,
+        "notifications": null,
+        "profile_background_image_url_https": "https://si0.twimg.com/profile_background_images/106455659/rect6056-9.png",
+        "profile_background_color": "EEE3C4",
+        "verified": false,
+        "geo_enabled": false,
+        "time_zone": "Central Time (US & Canada)",
+        "description": "Cartoonist, Illustrator, and T-Shirt connoisseur",
+        "default_profile_image": false,
+        "profile_background_image_url": "http://a0.twimg.com/profile_background_images/106455659/rect6056-9.png",
+        "statuses_count": 3575,
+        "friends_count": 249,
+        "following": null,
+        "show_all_inline_media": true,
+        "screen_name": "Omnitarian"
+      },
+      "in_reply_to_screen_name": null,
+      "source": "<a href=\"//twitter.com/download/iphone%5C%22\" rel=\"\\\"nofollow\\\"\">Twitter for iPhone</a>",
+      "in_reply_to_status_id": null
+    }
+  ],
+  "search_metadata": {
+    "max_id": 250126199840518145,
+    "since_id": 24012619984051000,
+    "refresh_url": "?since_id=250126199840518145&q=%23freebandnames&result_type=mixed&include_entities=1",
+    "next_results": "?max_id=249279667666817023&q=%23freebandnames&count=4&include_entities=1&result_type=mixed",
+    "count": 4,
+    "completed_in": 0.035,
+    "since_id_str": "24012619984051000",
+    "query": "%23freebandnames",
+    "max_id_str": "250126199840518145"
+  }
+}

vendor/github.com/mailru/easyjson/benchmark/ffjson_test.go

@@ -0,0 +1,190 @@
+// +build use_ffjson
+
+package benchmark
+
+import (
+	"testing"
+
+	"github.com/pquerna/ffjson/ffjson"
+)
+
+func BenchmarkFF_Unmarshal_M(b *testing.B) {
+	b.SetBytes(int64(len(largeStructText)))
+	for i := 0; i < b.N; i++ {
+		var s LargeStruct
+		err := ffjson.UnmarshalFast(largeStructText, &s)
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkFF_Unmarshal_S(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		var s Entities
+		err := ffjson.UnmarshalFast(smallStructText, &s)
+		if err != nil {
+			b.Error(err)
+		}
+	}
+	b.SetBytes(int64(len(smallStructText)))
+}
+
+func BenchmarkFF_Marshal_M(b *testing.B) {
+	var l int64
+	for i := 0; i < b.N; i++ {
+		data, err := ffjson.MarshalFast(&largeStructData)
+		if err != nil {
+			b.Error(err)
+		}
+		l = int64(len(data))
+	}
+	b.SetBytes(l)
+}
+
+func BenchmarkFF_Marshal_S(b *testing.B) {
+	var l int64
+	for i := 0; i < b.N; i++ {
+		data, err := ffjson.MarshalFast(&smallStructData)
+		if err != nil {
+			b.Error(err)
+		}
+		l = int64(len(data))
+	}
+	b.SetBytes(l)
+}
+
+func BenchmarkFF_Marshal_M_Pool(b *testing.B) {
+	var l int64
+	for i := 0; i < b.N; i++ {
+		data, err := ffjson.MarshalFast(&largeStructData)
+		if err != nil {
+			b.Error(err)
+		}
+		l = int64(len(data))
+		ffjson.Pool(data)
+	}
+	b.SetBytes(l)
+}
+
+func BenchmarkFF_Marshal_L(b *testing.B) {
+	var l int64
+	for i := 0; i < b.N; i++ {
+		data, err := ffjson.MarshalFast(&xlStructData)
+		if err != nil {
+			b.Error(err)
+		}
+		l = int64(len(data))
+	}
+	b.SetBytes(l)
+}
+
+func BenchmarkFF_Marshal_L_Pool(b *testing.B) {
+	var l int64
+	for i := 0; i < b.N; i++ {
+		data, err := ffjson.MarshalFast(&xlStructData)
+		if err != nil {
+			b.Error(err)
+		}
+		l = int64(len(data))
+		ffjson.Pool(data)
+	}
+	b.SetBytes(l)
+}
+
+func BenchmarkFF_Marshal_L_Pool_Parallel(b *testing.B) {
+	var l int64
+	for i := 0; i < b.N; i++ {
+		data, err := ffjson.MarshalFast(&xlStructData)
+		if err != nil {
+			b.Error(err)
+		}
+		l = int64(len(data))
+		ffjson.Pool(data)
+	}
+	b.SetBytes(l)
+}
+func BenchmarkFF_Marshal_M_Pool_Parallel(b *testing.B) {
+	var l int64
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			data, err := ffjson.MarshalFast(&largeStructData)
+			if err != nil {
+				b.Error(err)
+			}
+			l = int64(len(data))
+			ffjson.Pool(data)
+		}
+	})
+	b.SetBytes(l)
+}
+
+func BenchmarkFF_Marshal_S_Pool(b *testing.B) {
+	var l int64
+	for i := 0; i < b.N; i++ {
+		data, err := ffjson.MarshalFast(&smallStructData)
+		if err != nil {
+			b.Error(err)
+		}
+		l = int64(len(data))
+		ffjson.Pool(data)
+	}
+	b.SetBytes(l)
+}
+
+func BenchmarkFF_Marshal_S_Pool_Parallel(b *testing.B) {
+	var l int64
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			data, err := ffjson.MarshalFast(&smallStructData)
+			if err != nil {
+				b.Error(err)
+			}
+			l = int64(len(data))
+			ffjson.Pool(data)
+		}
+	})
+	b.SetBytes(l)
+}
+
+func BenchmarkFF_Marshal_S_Parallel(b *testing.B) {
+	var l int64
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			data, err := ffjson.MarshalFast(&smallStructData)
+			if err != nil {
+				b.Error(err)
+			}
+			l = int64(len(data))
+		}
+	})
+	b.SetBytes(l)
+}
+
+func BenchmarkFF_Marshal_M_Parallel(b *testing.B) {
+	var l int64
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			data, err := ffjson.MarshalFast(&largeStructData)
+			if err != nil {
+				b.Error(err)
+			}
+			l = int64(len(data))
+		}
+	})
+	b.SetBytes(l)
+}
+
+func BenchmarkFF_Marshal_L_Parallel(b *testing.B) {
+	var l int64
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			data, err := ffjson.MarshalFast(&xlStructData)
+			if err != nil {
+				b.Error(err)
+			}
+			l = int64(len(data))
+		}
+	})
+	b.SetBytes(l)
+}

vendor/github.com/mailru/easyjson/benchmark/jsoniter_test.go

@@ -0,0 +1,119 @@
+// +build use_jsoniter
+
+package benchmark
+
+import (
+	"testing"
+
+	jsoniter "github.com/json-iterator/go"
+)
+
+func BenchmarkJI_Unmarshal_M(b *testing.B) {
+	b.SetBytes(int64(len(largeStructText)))
+	for i := 0; i < b.N; i++ {
+		var s LargeStruct
+		err := jsoniter.Unmarshal(largeStructText, &s)
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkJI_Unmarshal_S(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		var s Entities
+		err := jsoniter.Unmarshal(smallStructText, &s)
+		if err != nil {
+			b.Error(err)
+		}
+	}
+	b.SetBytes(int64(len(smallStructText)))
+}
+
+func BenchmarkJI_Marshal_M(b *testing.B) {
+	var l int64
+	for i := 0; i < b.N; i++ {
+		data, err := jsoniter.Marshal(&largeStructData)
+		if err != nil {
+			b.Error(err)
+		}
+		l = int64(len(data))
+	}
+	b.SetBytes(l)
+}
+
+func BenchmarkJI_Marshal_L(b *testing.B) {
+	var l int64
+	for i := 0; i < b.N; i++ {
+		data, err := jsoniter.Marshal(&xlStructData)
+		if err != nil {
+			b.Error(err)
+		}
+		l = int64(len(data))
+	}
+	b.SetBytes(l)
+}
+
+func BenchmarkJI_Marshal_M_Parallel(b *testing.B) {
+	var l int64
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			data, err := jsoniter.Marshal(&largeStructData)
+			if err != nil {
+				b.Error(err)
+			}
+			l = int64(len(data))
+		}
+	})
+	b.SetBytes(l)
+}
+
+func BenchmarkJI_Marshal_L_Parallel(b *testing.B) {
+	var l int64
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			data, err := jsoniter.Marshal(&xlStructData)
+			if err != nil {
+				b.Error(err)
+			}
+			l = int64(len(data))
+		}
+	})
+	b.SetBytes(l)
+}
+
+func BenchmarkJI_Marshal_S(b *testing.B) {
+	var l int64
+	for i := 0; i < b.N; i++ {
+		data, err := jsoniter.Marshal(&smallStructData)
+		if err != nil {
+			b.Error(err)
+		}
+		l = int64(len(data))
+	}
+	b.SetBytes(l)
+}
+
+func BenchmarkJI_Marshal_S_Parallel(b *testing.B) {
+	var l int64
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			data, err := jsoniter.Marshal(&smallStructData)
+			if err != nil {
+				b.Error(err)
+			}
+			l = int64(len(data))
+		}
+	})
+	b.SetBytes(l)
+}
+
+func BenchmarkJI_Marshal_M_ToWriter(b *testing.B) {
+	enc := jsoniter.NewEncoder(&DummyWriter{})
+	for i := 0; i < b.N; i++ {
+		err := enc.Encode(&largeStructData)
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}

vendor/github.com/mailru/easyjson/benchmark/ujson.sh

@@ -0,0 +1,7 @@
+#/bin/bash
+
+echo -n "Python ujson module, DECODE: "
+python -m timeit -s "import ujson; data = open('`dirname $0`/example.json', 'r').read()" 'ujson.loads(data)'
+
+echo -n "Python ujson module, ENCODE: "
+python -m timeit -s "import ujson; data = open('`dirname $0`/example.json', 'r').read(); obj = ujson.loads(data)" 'ujson.dumps(obj)'

vendor/github.com/mailru/easyjson/bootstrap/bootstrap.go

@@ -0,0 +1,188 @@
+// Package bootstrap implements the bootstrapping logic: generation of a .go file to
+// launch the actual generator and launching the generator itself.
+//
+// The package may be preferred to a command-line utility if generating the serializers
+// from golang code is required.
+package bootstrap
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+)
+
+const genPackage = "github.com/mailru/easyjson/gen"
+const pkgWriter = "github.com/mailru/easyjson/jwriter"
+const pkgLexer = "github.com/mailru/easyjson/jlexer"
+
+type Generator struct {
+	PkgPath, PkgName string
+	Types            []string
+
+	NoStdMarshalers bool
+	SnakeCase       bool
+	LowerCamelCase  bool
+	OmitEmpty       bool
+
+	OutName   string
+	BuildTags string
+
+	StubsOnly  bool
+	LeaveTemps bool
+	NoFormat   bool
+}
+
+// writeStub outputs an initial stubs for marshalers/unmarshalers so that the package
+// using marshalers/unmarshales compiles correctly for boostrapping code.
+func (g *Generator) writeStub() error {
+	f, err := os.Create(g.OutName)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	if g.BuildTags != "" {
+		fmt.Fprintln(f, "// +build ", g.BuildTags)
+		fmt.Fprintln(f)
+	}
+	fmt.Fprintln(f, "// TEMPORARY AUTOGENERATED FILE: easyjson stub code to make the package")
+	fmt.Fprintln(f, "// compilable during generation.")
+	fmt.Fprintln(f)
+	fmt.Fprintln(f, "package ", g.PkgName)
+
+	if len(g.Types) > 0 {
+		fmt.Fprintln(f)
+		fmt.Fprintln(f, "import (")
+		fmt.Fprintln(f, `  "`+pkgWriter+`"`)
+		fmt.Fprintln(f, `  "`+pkgLexer+`"`)
+		fmt.Fprintln(f, ")")
+	}
+
+	sort.Strings(g.Types)
+	for _, t := range g.Types {
+		fmt.Fprintln(f)
+		if !g.NoStdMarshalers {
+			fmt.Fprintln(f, "func (", t, ") MarshalJSON() ([]byte, error) { return nil, nil }")
+			fmt.Fprintln(f, "func (*", t, ") UnmarshalJSON([]byte) error { return nil }")
+		}
+
+		fmt.Fprintln(f, "func (", t, ") MarshalEasyJSON(w *jwriter.Writer) {}")
+		fmt.Fprintln(f, "func (*", t, ") UnmarshalEasyJSON(l *jlexer.Lexer) {}")
+		fmt.Fprintln(f)
+		fmt.Fprintln(f, "type EasyJSON_exporter_"+t+" *"+t)
+	}
+	return nil
+}
+
+// writeMain creates a .go file that launches the generator if 'go run'.
+func (g *Generator) writeMain() (path string, err error) {
+	f, err := ioutil.TempFile(filepath.Dir(g.OutName), "easyjson-bootstrap")
+	if err != nil {
+		return "", err
+	}
+
+	fmt.Fprintln(f, "// +build ignore")
+	fmt.Fprintln(f)
+	fmt.Fprintln(f, "// TEMPORARY AUTOGENERATED FILE: easyjson bootstapping code to launch")
+	fmt.Fprintln(f, "// the actual generator.")
+	fmt.Fprintln(f)
+	fmt.Fprintln(f, "package main")
+	fmt.Fprintln(f)
+	fmt.Fprintln(f, "import (")
+	fmt.Fprintln(f, `  "fmt"`)
+	fmt.Fprintln(f, `  "os"`)
+	fmt.Fprintln(f)
+	fmt.Fprintf(f, "  %q\n", genPackage)
+	if len(g.Types) > 0 {
+		fmt.Fprintln(f)
+		fmt.Fprintf(f, "  pkg %q\n", g.PkgPath)
+	}
+	fmt.Fprintln(f, ")")
+	fmt.Fprintln(f)
+	fmt.Fprintln(f, "func main() {")
+	fmt.Fprintf(f, "  g := gen.NewGenerator(%q)\n", filepath.Base(g.OutName))
+	fmt.Fprintf(f, "  g.SetPkg(%q, %q)\n", g.PkgName, g.PkgPath)
+	if g.BuildTags != "" {
+		fmt.Fprintf(f, "  g.SetBuildTags(%q)\n", g.BuildTags)
+	}
+	if g.SnakeCase {
+		fmt.Fprintln(f, "  g.UseSnakeCase()")
+	}
+	if g.LowerCamelCase {
+		fmt.Fprintln(f, "  g.UseLowerCamelCase()")
+	}
+	if g.OmitEmpty {
+		fmt.Fprintln(f, "  g.OmitEmpty()")
+	}
+	if g.NoStdMarshalers {
+		fmt.Fprintln(f, "  g.NoStdMarshalers()")
+	}
+
+	sort.Strings(g.Types)
+	for _, v := range g.Types {
+		fmt.Fprintln(f, "  g.Add(pkg.EasyJSON_exporter_"+v+"(nil))")
+	}
+
+	fmt.Fprintln(f, "  if err := g.Run(os.Stdout); err != nil {")
+	fmt.Fprintln(f, "    fmt.Fprintln(os.Stderr, err)")
+	fmt.Fprintln(f, "    os.Exit(1)")
+	fmt.Fprintln(f, "  }")
+	fmt.Fprintln(f, "}")
+
+	src := f.Name()
+	if err := f.Close(); err != nil {
+		return src, err
+	}
+
+	dest := src + ".go"
+	return dest, os.Rename(src, dest)
+}
+
+func (g *Generator) Run() error {
+	if err := g.writeStub(); err != nil {
+		return err
+	}
+	if g.StubsOnly {
+		return nil
+	}
+
+	path, err := g.writeMain()
+	if err != nil {
+		return err
+	}
+	if !g.LeaveTemps {
+		defer os.Remove(path)
+	}
+
+	f, err := os.Create(g.OutName + ".tmp")
+	if err != nil {
+		return err
+	}
+	if !g.LeaveTemps {
+		defer os.Remove(f.Name()) // will not remove after rename
+	}
+
+	cmd := exec.Command("go", "run", "-tags", g.BuildTags, path)
+	cmd.Stdout = f
+	cmd.Stderr = os.Stderr
+	if err = cmd.Run(); err != nil {
+		return err
+	}
+
+	f.Close()
+
+	if !g.NoFormat {
+		cmd = exec.Command("gofmt", "-w", f.Name())
+		cmd.Stderr = os.Stderr
+		cmd.Stdout = os.Stdout
+
+		if err = cmd.Run(); err != nil {
+			return err
+		}
+	}
+
+	return os.Rename(f.Name(), g.OutName)
+}

vendor/github.com/mailru/easyjson/easyjson/main.go

@@ -0,0 +1,106 @@
+package main
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/mailru/easyjson/bootstrap"
+	// Reference the gen package to be friendly to vendoring tools,
+	// as it is an indirect dependency.
+	// (The temporary bootstrapping code uses it.)
+	_ "github.com/mailru/easyjson/gen"
+	"github.com/mailru/easyjson/parser"
+)
+
+var buildTags = flag.String("build_tags", "", "build tags to add to generated file")
+var snakeCase = flag.Bool("snake_case", false, "use snake_case names instead of CamelCase by default")
+var lowerCamelCase = flag.Bool("lower_camel_case", false, "use lowerCamelCase names instead of CamelCase by default")
+var noStdMarshalers = flag.Bool("no_std_marshalers", false, "don't generate MarshalJSON/UnmarshalJSON funcs")
+var omitEmpty = flag.Bool("omit_empty", false, "omit empty fields by default")
+var allStructs = flag.Bool("all", false, "generate marshaler/unmarshalers for all structs in a file")
+var leaveTemps = flag.Bool("leave_temps", false, "do not delete temporary files")
+var stubs = flag.Bool("stubs", false, "only generate stubs for marshaler/unmarshaler funcs")
+var noformat = flag.Bool("noformat", false, "do not run 'gofmt -w' on output file")
+var specifiedName = flag.String("output_filename", "", "specify the filename of the output")
+var processPkg = flag.Bool("pkg", false, "process the whole package instead of just the given file")
+
+func generate(fname string) (err error) {
+	fInfo, err := os.Stat(fname)
+	if err != nil {
+		return err
+	}
+
+	p := parser.Parser{AllStructs: *allStructs}
+	if err := p.Parse(fname, fInfo.IsDir()); err != nil {
+		return fmt.Errorf("Error parsing %v: %v", fname, err)
+	}
+
+	var outName string
+	if fInfo.IsDir() {
+		outName = filepath.Join(fname, p.PkgName+"_easyjson.go")
+	} else {
+		if s := strings.TrimSuffix(fname, ".go"); s == fname {
+			return errors.New("Filename must end in '.go'")
+		} else {
+			outName = s + "_easyjson.go"
+		}
+	}
+
+	if *specifiedName != "" {
+		outName = *specifiedName
+	}
+
+	var trimmedBuildTags string
+	if *buildTags != "" {
+		trimmedBuildTags = strings.TrimSpace(*buildTags)
+	}
+
+	g := bootstrap.Generator{
+		BuildTags:       trimmedBuildTags,
+		PkgPath:         p.PkgPath,
+		PkgName:         p.PkgName,
+		Types:           p.StructNames,
+		SnakeCase:       *snakeCase,
+		LowerCamelCase:  *lowerCamelCase,
+		NoStdMarshalers: *noStdMarshalers,
+		OmitEmpty:       *omitEmpty,
+		LeaveTemps:      *leaveTemps,
+		OutName:         outName,
+		StubsOnly:       *stubs,
+		NoFormat:        *noformat,
+	}
+
+	if err := g.Run(); err != nil {
+		return fmt.Errorf("Bootstrap failed: %v", err)
+	}
+	return nil
+}
+
+func main() {
+	flag.Parse()
+
+	files := flag.Args()
+
+	gofile := os.Getenv("GOFILE")
+	if *processPkg {
+		gofile = filepath.Dir(gofile)
+	}
+
+	if len(files) == 0 && gofile != "" {
+		files = []string{gofile}
+	} else if len(files) == 0 {
+		flag.Usage()
+		os.Exit(1)
+	}
+
+	for _, fname := range files {
+		if err := generate(fname); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+	}
+}

vendor/github.com/mailru/easyjson/gen/decoder.go

@@ -0,0 +1,489 @@
+package gen
+
+import (
+	"encoding"
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strings"
+	"unicode"
+
+	"github.com/mailru/easyjson"
+)
+
+// Target this byte size for initial slice allocation to reduce garbage collection.
+const minSliceBytes = 64
+
+func (g *Generator) getDecoderName(t reflect.Type) string {
+	return g.functionName("decode", t)
+}
+
+var primitiveDecoders = map[reflect.Kind]string{
+	reflect.String:  "in.String()",
+	reflect.Bool:    "in.Bool()",
+	reflect.Int:     "in.Int()",
+	reflect.Int8:    "in.Int8()",
+	reflect.Int16:   "in.Int16()",
+	reflect.Int32:   "in.Int32()",
+	reflect.Int64:   "in.Int64()",
+	reflect.Uint:    "in.Uint()",
+	reflect.Uint8:   "in.Uint8()",
+	reflect.Uint16:  "in.Uint16()",
+	reflect.Uint32:  "in.Uint32()",
+	reflect.Uint64:  "in.Uint64()",
+	reflect.Float32: "in.Float32()",
+	reflect.Float64: "in.Float64()",
+}
+
+var primitiveStringDecoders = map[reflect.Kind]string{
+	reflect.String:  "in.String()",
+	reflect.Int:     "in.IntStr()",
+	reflect.Int8:    "in.Int8Str()",
+	reflect.Int16:   "in.Int16Str()",
+	reflect.Int32:   "in.Int32Str()",
+	reflect.Int64:   "in.Int64Str()",
+	reflect.Uint:    "in.UintStr()",
+	reflect.Uint8:   "in.Uint8Str()",
+	reflect.Uint16:  "in.Uint16Str()",
+	reflect.Uint32:  "in.Uint32Str()",
+	reflect.Uint64:  "in.Uint64Str()",
+	reflect.Uintptr: "in.UintptrStr()",
+}
+
+var customDecoders = map[string]string{
+	"json.Number":    "in.JsonNumber()",
+}
+
+// genTypeDecoder generates decoding code for the type t, but uses unmarshaler interface if implemented by t.
+func (g *Generator) genTypeDecoder(t reflect.Type, out string, tags fieldTags, indent int) error {
+	ws := strings.Repeat("  ", indent)
+
+	unmarshalerIface := reflect.TypeOf((*easyjson.Unmarshaler)(nil)).Elem()
+	if reflect.PtrTo(t).Implements(unmarshalerIface) {
+		fmt.Fprintln(g.out, ws+"("+out+").UnmarshalEasyJSON(in)")
+		return nil
+	}
+
+	unmarshalerIface = reflect.TypeOf((*json.Unmarshaler)(nil)).Elem()
+	if reflect.PtrTo(t).Implements(unmarshalerIface) {
+		fmt.Fprintln(g.out, ws+"if data := in.Raw(); in.Ok() {")
+		fmt.Fprintln(g.out, ws+"  in.AddError( ("+out+").UnmarshalJSON(data) )")
+		fmt.Fprintln(g.out, ws+"}")
+		return nil
+	}
+
+	unmarshalerIface = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
+	if reflect.PtrTo(t).Implements(unmarshalerIface) {
+		fmt.Fprintln(g.out, ws+"if data := in.UnsafeBytes(); in.Ok() {")
+		fmt.Fprintln(g.out, ws+"  in.AddError( ("+out+").UnmarshalText(data) )")
+		fmt.Fprintln(g.out, ws+"}")
+		return nil
+	}
+
+	err := g.genTypeDecoderNoCheck(t, out, tags, indent)
+	return err
+}
+
+// genTypeDecoderNoCheck generates decoding code for the type t.
+func (g *Generator) genTypeDecoderNoCheck(t reflect.Type, out string, tags fieldTags, indent int) error {
+	ws := strings.Repeat("  ", indent)
+	// Check whether type is primitive, needs to be done after interface check.
+	if dec := customDecoders[t.String()]; dec != ""  {
+		fmt.Fprintln(g.out, ws+out+" = "+dec)
+		return nil
+	} else if dec := primitiveStringDecoders[t.Kind()]; dec != "" && tags.asString {
+		fmt.Fprintln(g.out, ws+out+" = "+g.getType(t)+"("+dec+")")
+		return nil
+	} else if dec := primitiveDecoders[t.Kind()]; dec != "" {
+		fmt.Fprintln(g.out, ws+out+" = "+g.getType(t)+"("+dec+")")
+		return nil
+	}
+
+	switch t.Kind() {
+	case reflect.Slice:
+		tmpVar := g.uniqueVarName()
+		elem := t.Elem()
+
+		if elem.Kind() == reflect.Uint8 {
+			fmt.Fprintln(g.out, ws+"if in.IsNull() {")
+			fmt.Fprintln(g.out, ws+"  in.Skip()")
+			fmt.Fprintln(g.out, ws+"  "+out+" = nil")
+			fmt.Fprintln(g.out, ws+"} else {")
+			fmt.Fprintln(g.out, ws+"  "+out+" = in.Bytes()")
+			fmt.Fprintln(g.out, ws+"}")
+
+		} else {
+
+			capacity := minSliceBytes / elem.Size()
+			if capacity == 0 {
+				capacity = 1
+			}
+
+			fmt.Fprintln(g.out, ws+"if in.IsNull() {")
+			fmt.Fprintln(g.out, ws+"  in.Skip()")
+			fmt.Fprintln(g.out, ws+"  "+out+" = nil")
+			fmt.Fprintln(g.out, ws+"} else {")
+			fmt.Fprintln(g.out, ws+"  in.Delim('[')")
+			fmt.Fprintln(g.out, ws+"  if "+out+" == nil {")
+			fmt.Fprintln(g.out, ws+"    if !in.IsDelim(']') {")
+			fmt.Fprintln(g.out, ws+"      "+out+" = make("+g.getType(t)+", 0, "+fmt.Sprint(capacity)+")")
+			fmt.Fprintln(g.out, ws+"    } else {")
+			fmt.Fprintln(g.out, ws+"      "+out+" = "+g.getType(t)+"{}")
+			fmt.Fprintln(g.out, ws+"    }")
+			fmt.Fprintln(g.out, ws+"  } else { ")
+			fmt.Fprintln(g.out, ws+"    "+out+" = ("+out+")[:0]")
+			fmt.Fprintln(g.out, ws+"  }")
+			fmt.Fprintln(g.out, ws+"  for !in.IsDelim(']') {")
+			fmt.Fprintln(g.out, ws+"    var "+tmpVar+" "+g.getType(elem))
+
+			if err := g.genTypeDecoder(elem, tmpVar, tags, indent+2); err != nil {
+				return err
+			}
+
+			fmt.Fprintln(g.out, ws+"    "+out+" = append("+out+", "+tmpVar+")")
+			fmt.Fprintln(g.out, ws+"    in.WantComma()")
+			fmt.Fprintln(g.out, ws+"  }")
+			fmt.Fprintln(g.out, ws+"  in.Delim(']')")
+			fmt.Fprintln(g.out, ws+"}")
+		}
+
+	case reflect.Array:
+		iterVar := g.uniqueVarName()
+		elem := t.Elem()
+
+		if elem.Kind() == reflect.Uint8 {
+			fmt.Fprintln(g.out, ws+"if in.IsNull() {")
+			fmt.Fprintln(g.out, ws+"  in.Skip()")
+			fmt.Fprintln(g.out, ws+"} else {")
+			fmt.Fprintln(g.out, ws+"  copy("+out+"[:], in.Bytes())")
+			fmt.Fprintln(g.out, ws+"}")
+
+		} else {
+
+			length := t.Len()
+
+			fmt.Fprintln(g.out, ws+"if in.IsNull() {")
+			fmt.Fprintln(g.out, ws+"  in.Skip()")
+			fmt.Fprintln(g.out, ws+"} else {")
+			fmt.Fprintln(g.out, ws+"  in.Delim('[')")
+			fmt.Fprintln(g.out, ws+"  "+iterVar+" := 0")
+			fmt.Fprintln(g.out, ws+"  for !in.IsDelim(']') {")
+			fmt.Fprintln(g.out, ws+"    if "+iterVar+" < "+fmt.Sprint(length)+" {")
+
+			if err := g.genTypeDecoder(elem, out+"["+iterVar+"]", tags, indent+3); err != nil {
+				return err
+			}
+
+			fmt.Fprintln(g.out, ws+"      "+iterVar+"++")
+			fmt.Fprintln(g.out, ws+"    } else {")
+			fmt.Fprintln(g.out, ws+"      in.SkipRecursive()")
+			fmt.Fprintln(g.out, ws+"    }")
+			fmt.Fprintln(g.out, ws+"    in.WantComma()")
+			fmt.Fprintln(g.out, ws+"  }")
+			fmt.Fprintln(g.out, ws+"  in.Delim(']')")
+			fmt.Fprintln(g.out, ws+"}")
+		}
+
+	case reflect.Struct:
+		dec := g.getDecoderName(t)
+		g.addType(t)
+
+		fmt.Fprintln(g.out, ws+dec+"(in, &"+out+")")
+
+	case reflect.Ptr:
+		fmt.Fprintln(g.out, ws+"if in.IsNull() {")
+		fmt.Fprintln(g.out, ws+"  in.Skip()")
+		fmt.Fprintln(g.out, ws+"  "+out+" = nil")
+		fmt.Fprintln(g.out, ws+"} else {")
+		fmt.Fprintln(g.out, ws+"  if "+out+" == nil {")
+		fmt.Fprintln(g.out, ws+"    "+out+" = new("+g.getType(t.Elem())+")")
+		fmt.Fprintln(g.out, ws+"  }")
+
+		if err := g.genTypeDecoder(t.Elem(), "*"+out, tags, indent+1); err != nil {
+			return err
+		}
+
+		fmt.Fprintln(g.out, ws+"}")
+
+	case reflect.Map:
+		key := t.Key()
+		keyDec, ok := primitiveStringDecoders[key.Kind()]
+		if !ok {
+			return fmt.Errorf("map type %v not supported: only string and integer keys are allowed", key)
+		}
+		elem := t.Elem()
+		tmpVar := g.uniqueVarName()
+
+		fmt.Fprintln(g.out, ws+"if in.IsNull() {")
+		fmt.Fprintln(g.out, ws+"  in.Skip()")
+		fmt.Fprintln(g.out, ws+"} else {")
+		fmt.Fprintln(g.out, ws+"  in.Delim('{')")
+		fmt.Fprintln(g.out, ws+"  if !in.IsDelim('}') {")
+		fmt.Fprintln(g.out, ws+"  "+out+" = make("+g.getType(t)+")")
+		fmt.Fprintln(g.out, ws+"  } else {")
+		fmt.Fprintln(g.out, ws+"  "+out+" = nil")
+		fmt.Fprintln(g.out, ws+"  }")
+
+		fmt.Fprintln(g.out, ws+"  for !in.IsDelim('}') {")
+		fmt.Fprintln(g.out, ws+"    key := "+g.getType(key)+"("+keyDec+")")
+		fmt.Fprintln(g.out, ws+"    in.WantColon()")
+		fmt.Fprintln(g.out, ws+"    var "+tmpVar+" "+g.getType(elem))
+
+		if err := g.genTypeDecoder(elem, tmpVar, tags, indent+2); err != nil {
+			return err
+		}
+
+		fmt.Fprintln(g.out, ws+"    ("+out+")[key] = "+tmpVar)
+		fmt.Fprintln(g.out, ws+"    in.WantComma()")
+		fmt.Fprintln(g.out, ws+"  }")
+		fmt.Fprintln(g.out, ws+"  in.Delim('}')")
+		fmt.Fprintln(g.out, ws+"}")
+
+	case reflect.Interface:
+		if t.NumMethod() != 0 {
+			return fmt.Errorf("interface type %v not supported: only interface{} is allowed", t)
+		}
+		fmt.Fprintln(g.out, ws+"if m, ok := "+out+".(easyjson.Unmarshaler); ok {")
+		fmt.Fprintln(g.out, ws+"m.UnmarshalEasyJSON(in)")
+		fmt.Fprintln(g.out, ws+"} else if m, ok := "+out+".(json.Unmarshaler); ok {")
+		fmt.Fprintln(g.out, ws+"_ = m.UnmarshalJSON(in.Raw())")
+		fmt.Fprintln(g.out, ws+"} else {")
+		fmt.Fprintln(g.out, ws+"  "+out+" = in.Interface()")
+		fmt.Fprintln(g.out, ws+"}")
+	default:
+		return fmt.Errorf("don't know how to decode %v", t)
+	}
+	return nil
+
+}
+
+func (g *Generator) genStructFieldDecoder(t reflect.Type, f reflect.StructField) error {
+	jsonName := g.fieldNamer.GetJSONFieldName(t, f)
+	tags := parseFieldTags(f)
+
+	if tags.omit {
+		return nil
+	}
+
+	fmt.Fprintf(g.out, "    case %q:\n", jsonName)
+	if err := g.genTypeDecoder(f.Type, "out."+f.Name, tags, 3); err != nil {
+		return err
+	}
+
+	if tags.required {
+		fmt.Fprintf(g.out, "%sSet = true\n", f.Name)
+	}
+
+	return nil
+}
+
+func (g *Generator) genRequiredFieldSet(t reflect.Type, f reflect.StructField) {
+	tags := parseFieldTags(f)
+
+	if !tags.required {
+		return
+	}
+
+	fmt.Fprintf(g.out, "var %sSet bool\n", f.Name)
+}
+
+func (g *Generator) genRequiredFieldCheck(t reflect.Type, f reflect.StructField) {
+	jsonName := g.fieldNamer.GetJSONFieldName(t, f)
+	tags := parseFieldTags(f)
+
+	if !tags.required {
+		return
+	}
+
+	g.imports["fmt"] = "fmt"
+
+	fmt.Fprintf(g.out, "if !%sSet {\n", f.Name)
+	fmt.Fprintf(g.out, "    in.AddError(fmt.Errorf(\"key '%s' is required\"))\n", jsonName)
+	fmt.Fprintf(g.out, "}\n")
+}
+
+func mergeStructFields(fields1, fields2 []reflect.StructField) (fields []reflect.StructField) {
+	used := map[string]bool{}
+	for _, f := range fields2 {
+		used[f.Name] = true
+		fields = append(fields, f)
+	}
+
+	for _, f := range fields1 {
+		if !used[f.Name] {
+			fields = append(fields, f)
+		}
+	}
+	return
+}
+
+func getStructFields(t reflect.Type) ([]reflect.StructField, error) {
+	if t.Kind() != reflect.Struct {
+		return nil, fmt.Errorf("got %v; expected a struct", t)
+	}
+
+	var efields []reflect.StructField
+	for i := 0; i < t.NumField(); i++ {
+		f := t.Field(i)
+		if !f.Anonymous {
+			continue
+		}
+
+		t1 := f.Type
+		if t1.Kind() == reflect.Ptr {
+			t1 = t1.Elem()
+		}
+
+		fs, err := getStructFields(t1)
+		if err != nil {
+			return nil, fmt.Errorf("error processing embedded field: %v", err)
+		}
+		efields = mergeStructFields(efields, fs)
+	}
+
+	var fields []reflect.StructField
+	for i := 0; i < t.NumField(); i++ {
+		f := t.Field(i)
+		if f.Anonymous {
+			continue
+		}
+
+		c := []rune(f.Name)[0]
+		if unicode.IsUpper(c) {
+			fields = append(fields, f)
+		}
+	}
+	return mergeStructFields(efields, fields), nil
+}
+
+func (g *Generator) genDecoder(t reflect.Type) error {
+	switch t.Kind() {
+	case reflect.Slice, reflect.Array, reflect.Map:
+		return g.genSliceArrayDecoder(t)
+	default:
+		return g.genStructDecoder(t)
+	}
+}
+
+func (g *Generator) genSliceArrayDecoder(t reflect.Type) error {
+	switch t.Kind() {
+	case reflect.Slice, reflect.Array, reflect.Map:
+	default:
+		return fmt.Errorf("cannot generate encoder/decoder for %v, not a slice/array/map type", t)
+	}
+
+	fname := g.getDecoderName(t)
+	typ := g.getType(t)
+
+	fmt.Fprintln(g.out, "func "+fname+"(in *jlexer.Lexer, out *"+typ+") {")
+	fmt.Fprintln(g.out, " isTopLevel := in.IsStart()")
+	err := g.genTypeDecoderNoCheck(t, "*out", fieldTags{}, 1)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintln(g.out, "  if isTopLevel {")
+	fmt.Fprintln(g.out, "    in.Consumed()")
+	fmt.Fprintln(g.out, "  }")
+	fmt.Fprintln(g.out, "}")
+
+	return nil
+}
+
+func (g *Generator) genStructDecoder(t reflect.Type) error {
+	if t.Kind() != reflect.Struct {
+		return fmt.Errorf("cannot generate encoder/decoder for %v, not a struct type", t)
+	}
+
+	fname := g.getDecoderName(t)
+	typ := g.getType(t)
+
+	fmt.Fprintln(g.out, "func "+fname+"(in *jlexer.Lexer, out *"+typ+") {")
+	fmt.Fprintln(g.out, "  isTopLevel := in.IsStart()")
+	fmt.Fprintln(g.out, "  if in.IsNull() {")
+	fmt.Fprintln(g.out, "    if isTopLevel {")
+	fmt.Fprintln(g.out, "      in.Consumed()")
+	fmt.Fprintln(g.out, "    }")
+	fmt.Fprintln(g.out, "    in.Skip()")
+	fmt.Fprintln(g.out, "    return")
+	fmt.Fprintln(g.out, "  }")
+
+	// Init embedded pointer fields.
+	for i := 0; i < t.NumField(); i++ {
+		f := t.Field(i)
+		if !f.Anonymous || f.Type.Kind() != reflect.Ptr {
+			continue
+		}
+		fmt.Fprintln(g.out, "  out."+f.Name+" = new("+g.getType(f.Type.Elem())+")")
+	}
+
+	fs, err := getStructFields(t)
+	if err != nil {
+		return fmt.Errorf("cannot generate decoder for %v: %v", t, err)
+	}
+
+	for _, f := range fs {
+		g.genRequiredFieldSet(t, f)
+	}
+
+	fmt.Fprintln(g.out, "  in.Delim('{')")
+	fmt.Fprintln(g.out, "  for !in.IsDelim('}') {")
+	fmt.Fprintln(g.out, "    key := in.UnsafeString()")
+	fmt.Fprintln(g.out, "    in.WantColon()")
+	fmt.Fprintln(g.out, "    if in.IsNull() {")
+	fmt.Fprintln(g.out, "       in.Skip()")
+	fmt.Fprintln(g.out, "       in.WantComma()")
+	fmt.Fprintln(g.out, "       continue")
+	fmt.Fprintln(g.out, "    }")
+
+	fmt.Fprintln(g.out, "    switch key {")
+	for _, f := range fs {
+		if err := g.genStructFieldDecoder(t, f); err != nil {
+			return err
+		}
+	}
+
+	fmt.Fprintln(g.out, "    default:")
+	fmt.Fprintln(g.out, "      in.SkipRecursive()")
+	fmt.Fprintln(g.out, "    }")
+	fmt.Fprintln(g.out, "    in.WantComma()")
+	fmt.Fprintln(g.out, "  }")
+	fmt.Fprintln(g.out, "  in.Delim('}')")
+	fmt.Fprintln(g.out, "  if isTopLevel {")
+	fmt.Fprintln(g.out, "    in.Consumed()")
+	fmt.Fprintln(g.out, "  }")
+
+	for _, f := range fs {
+		g.genRequiredFieldCheck(t, f)
+	}
+
+	fmt.Fprintln(g.out, "}")
+
+	return nil
+}
+
+func (g *Generator) genStructUnmarshaler(t reflect.Type) error {
+	switch t.Kind() {
+	case reflect.Slice, reflect.Array, reflect.Map, reflect.Struct:
+	default:
+		return fmt.Errorf("cannot generate encoder/decoder for %v, not a struct/slice/array/map type", t)
+	}
+
+	fname := g.getDecoderName(t)
+	typ := g.getType(t)
+
+	if !g.noStdMarshalers {
+		fmt.Fprintln(g.out, "// UnmarshalJSON supports json.Unmarshaler interface")
+		fmt.Fprintln(g.out, "func (v *"+typ+") UnmarshalJSON(data []byte) error {")
+		fmt.Fprintln(g.out, "  r := jlexer.Lexer{Data: data}")
+		fmt.Fprintln(g.out, "  "+fname+"(&r, v)")
+		fmt.Fprintln(g.out, "  return r.Error()")
+		fmt.Fprintln(g.out, "}")
+	}
+
+	fmt.Fprintln(g.out, "// UnmarshalEasyJSON supports easyjson.Unmarshaler interface")
+	fmt.Fprintln(g.out, "func (v *"+typ+") UnmarshalEasyJSON(l *jlexer.Lexer) {")
+	fmt.Fprintln(g.out, "  "+fname+"(l, v)")
+	fmt.Fprintln(g.out, "}")
+
+	return nil
+}

vendor/github.com/mailru/easyjson/gen/encoder.go

@@ -0,0 +1,369 @@
+package gen
+
+import (
+	"encoding"
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/mailru/easyjson"
+)
+
+func (g *Generator) getEncoderName(t reflect.Type) string {
+	return g.functionName("encode", t)
+}
+
+var primitiveEncoders = map[reflect.Kind]string{
+	reflect.String:  "out.String(string(%v))",
+	reflect.Bool:    "out.Bool(bool(%v))",
+	reflect.Int:     "out.Int(int(%v))",
+	reflect.Int8:    "out.Int8(int8(%v))",
+	reflect.Int16:   "out.Int16(int16(%v))",
+	reflect.Int32:   "out.Int32(int32(%v))",
+	reflect.Int64:   "out.Int64(int64(%v))",
+	reflect.Uint:    "out.Uint(uint(%v))",
+	reflect.Uint8:   "out.Uint8(uint8(%v))",
+	reflect.Uint16:  "out.Uint16(uint16(%v))",
+	reflect.Uint32:  "out.Uint32(uint32(%v))",
+	reflect.Uint64:  "out.Uint64(uint64(%v))",
+	reflect.Float32: "out.Float32(float32(%v))",
+	reflect.Float64: "out.Float64(float64(%v))",
+}
+
+var primitiveStringEncoders = map[reflect.Kind]string{
+	reflect.String:  "out.String(string(%v))",
+	reflect.Int:     "out.IntStr(int(%v))",
+	reflect.Int8:    "out.Int8Str(int8(%v))",
+	reflect.Int16:   "out.Int16Str(int16(%v))",
+	reflect.Int32:   "out.Int32Str(int32(%v))",
+	reflect.Int64:   "out.Int64Str(int64(%v))",
+	reflect.Uint:    "out.UintStr(uint(%v))",
+	reflect.Uint8:   "out.Uint8Str(uint8(%v))",
+	reflect.Uint16:  "out.Uint16Str(uint16(%v))",
+	reflect.Uint32:  "out.Uint32Str(uint32(%v))",
+	reflect.Uint64:  "out.Uint64Str(uint64(%v))",
+	reflect.Uintptr: "out.UintptrStr(uintptr(%v))",
+}
+
+// fieldTags contains parsed version of json struct field tags.
+type fieldTags struct {
+	name string
+
+	omit        bool
+	omitEmpty   bool
+	noOmitEmpty bool
+	asString    bool
+	required    bool
+}
+
+// parseFieldTags parses the json field tag into a structure.
+func parseFieldTags(f reflect.StructField) fieldTags {
+	var ret fieldTags
+
+	for i, s := range strings.Split(f.Tag.Get("json"), ",") {
+		switch {
+		case i == 0 && s == "-":
+			ret.omit = true
+		case i == 0:
+			ret.name = s
+		case s == "omitempty":
+			ret.omitEmpty = true
+		case s == "!omitempty":
+			ret.noOmitEmpty = true
+		case s == "string":
+			ret.asString = true
+		case s == "required":
+			ret.required = true
+		}
+	}
+
+	return ret
+}
+
+// genTypeEncoder generates code that encodes in of type t into the writer, but uses marshaler interface if implemented by t.
+func (g *Generator) genTypeEncoder(t reflect.Type, in string, tags fieldTags, indent int) error {
+	ws := strings.Repeat("  ", indent)
+
+	marshalerIface := reflect.TypeOf((*easyjson.Marshaler)(nil)).Elem()
+	if reflect.PtrTo(t).Implements(marshalerIface) {
+		fmt.Fprintln(g.out, ws+"("+in+").MarshalEasyJSON(out)")
+		return nil
+	}
+
+	marshalerIface = reflect.TypeOf((*json.Marshaler)(nil)).Elem()
+	if reflect.PtrTo(t).Implements(marshalerIface) {
+		fmt.Fprintln(g.out, ws+"out.Raw( ("+in+").MarshalJSON() )")
+		return nil
+	}
+
+	marshalerIface = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
+	if reflect.PtrTo(t).Implements(marshalerIface) {
+		fmt.Fprintln(g.out, ws+"out.RawText( ("+in+").MarshalText() )")
+		return nil
+	}
+
+	err := g.genTypeEncoderNoCheck(t, in, tags, indent)
+	return err
+}
+
+// genTypeEncoderNoCheck generates code that encodes in of type t into the writer.
+func (g *Generator) genTypeEncoderNoCheck(t reflect.Type, in string, tags fieldTags, indent int) error {
+	ws := strings.Repeat("  ", indent)
+
+	// Check whether type is primitive, needs to be done after interface check.
+	if enc := primitiveStringEncoders[t.Kind()]; enc != "" && tags.asString {
+		fmt.Fprintf(g.out, ws+enc+"\n", in)
+		return nil
+	} else if enc := primitiveEncoders[t.Kind()]; enc != "" {
+		fmt.Fprintf(g.out, ws+enc+"\n", in)
+		return nil
+	}
+
+	switch t.Kind() {
+	case reflect.Slice:
+		elem := t.Elem()
+		iVar := g.uniqueVarName()
+		vVar := g.uniqueVarName()
+
+		if t.Elem().Kind() == reflect.Uint8 {
+			fmt.Fprintln(g.out, ws+"out.Base64Bytes("+in+")")
+		} else {
+			fmt.Fprintln(g.out, ws+"if "+in+" == nil && (out.Flags & jwriter.NilSliceAsEmpty) == 0 {")
+			fmt.Fprintln(g.out, ws+`  out.RawString("null")`)
+			fmt.Fprintln(g.out, ws+"} else {")
+			fmt.Fprintln(g.out, ws+"  out.RawByte('[')")
+			fmt.Fprintln(g.out, ws+"  for "+iVar+", "+vVar+" := range "+in+" {")
+			fmt.Fprintln(g.out, ws+"    if "+iVar+" > 0 {")
+			fmt.Fprintln(g.out, ws+"      out.RawByte(',')")
+			fmt.Fprintln(g.out, ws+"    }")
+
+			if err := g.genTypeEncoder(elem, vVar, tags, indent+2); err != nil {
+				return err
+			}
+
+			fmt.Fprintln(g.out, ws+"  }")
+			fmt.Fprintln(g.out, ws+"  out.RawByte(']')")
+			fmt.Fprintln(g.out, ws+"}")
+		}
+
+	case reflect.Array:
+		elem := t.Elem()
+		iVar := g.uniqueVarName()
+
+		if t.Elem().Kind() == reflect.Uint8 {
+			fmt.Fprintln(g.out, ws+"out.Base64Bytes("+in+"[:])")
+		} else {
+			fmt.Fprintln(g.out, ws+"out.RawByte('[')")
+			fmt.Fprintln(g.out, ws+"for "+iVar+" := range "+in+" {")
+			fmt.Fprintln(g.out, ws+"  if "+iVar+" > 0 {")
+			fmt.Fprintln(g.out, ws+"    out.RawByte(',')")
+			fmt.Fprintln(g.out, ws+"  }")
+
+			if err := g.genTypeEncoder(elem, in+"["+iVar+"]", tags, indent+1); err != nil {
+				return err
+			}
+
+			fmt.Fprintln(g.out, ws+"}")
+			fmt.Fprintln(g.out, ws+"out.RawByte(']')")
+		}
+
+	case reflect.Struct:
+		enc := g.getEncoderName(t)
+		g.addType(t)
+
+		fmt.Fprintln(g.out, ws+enc+"(out, "+in+")")
+
+	case reflect.Ptr:
+		fmt.Fprintln(g.out, ws+"if "+in+" == nil {")
+		fmt.Fprintln(g.out, ws+`  out.RawString("null")`)
+		fmt.Fprintln(g.out, ws+"} else {")
+
+		if err := g.genTypeEncoder(t.Elem(), "*"+in, tags, indent+1); err != nil {
+			return err
+		}
+
+		fmt.Fprintln(g.out, ws+"}")
+
+	case reflect.Map:
+		key := t.Key()
+		keyEnc, ok := primitiveStringEncoders[key.Kind()]
+		if !ok {
+			return fmt.Errorf("map key type %v not supported: only string and integer keys are allowed", key)
+		}
+		tmpVar := g.uniqueVarName()
+
+		fmt.Fprintln(g.out, ws+"if "+in+" == nil && (out.Flags & jwriter.NilMapAsEmpty) == 0 {")
+		fmt.Fprintln(g.out, ws+"  out.RawString(`null`)")
+		fmt.Fprintln(g.out, ws+"} else {")
+		fmt.Fprintln(g.out, ws+"  out.RawByte('{')")
+		fmt.Fprintln(g.out, ws+"  "+tmpVar+"First := true")
+		fmt.Fprintln(g.out, ws+"  for "+tmpVar+"Name, "+tmpVar+"Value := range "+in+" {")
+		fmt.Fprintln(g.out, ws+"    if !"+tmpVar+"First { out.RawByte(',') }")
+		fmt.Fprintln(g.out, ws+"    "+tmpVar+"First = false")
+		fmt.Fprintln(g.out, ws+"    "+fmt.Sprintf(keyEnc, tmpVar+"Name"))
+		fmt.Fprintln(g.out, ws+"    out.RawByte(':')")
+
+		if err := g.genTypeEncoder(t.Elem(), tmpVar+"Value", tags, indent+2); err != nil {
+			return err
+		}
+
+		fmt.Fprintln(g.out, ws+"  }")
+		fmt.Fprintln(g.out, ws+"  out.RawByte('}')")
+		fmt.Fprintln(g.out, ws+"}")
+
+	case reflect.Interface:
+		if t.NumMethod() != 0 {
+			return fmt.Errorf("interface type %v not supported: only interface{} is allowed", t)
+		}
+		fmt.Fprintln(g.out, ws+"if m, ok := "+in+".(easyjson.Marshaler); ok {")
+		fmt.Fprintln(g.out, ws+"  m.MarshalEasyJSON(out)")
+		fmt.Fprintln(g.out, ws+"} else if m, ok := "+in+".(json.Marshaler); ok {")
+		fmt.Fprintln(g.out, ws+"  out.Raw(m.MarshalJSON())")
+		fmt.Fprintln(g.out, ws+"} else {")
+		fmt.Fprintln(g.out, ws+"  out.Raw(json.Marshal("+in+"))")
+		fmt.Fprintln(g.out, ws+"}")
+
+	default:
+		return fmt.Errorf("don't know how to encode %v", t)
+	}
+	return nil
+}
+
+func (g *Generator) notEmptyCheck(t reflect.Type, v string) string {
+	optionalIface := reflect.TypeOf((*easyjson.Optional)(nil)).Elem()
+	if reflect.PtrTo(t).Implements(optionalIface) {
+		return "(" + v + ").IsDefined()"
+	}
+
+	switch t.Kind() {
+	case reflect.Slice, reflect.Map:
+		return "len(" + v + ") != 0"
+	case reflect.Interface, reflect.Ptr:
+		return v + " != nil"
+	case reflect.Bool:
+		return v
+	case reflect.String:
+		return v + ` != ""`
+	case reflect.Float32, reflect.Float64,
+		reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+
+		return v + " != 0"
+
+	default:
+		// note: Array types don't have a useful empty value
+		return "true"
+	}
+}
+
+func (g *Generator) genStructFieldEncoder(t reflect.Type, f reflect.StructField) error {
+	jsonName := g.fieldNamer.GetJSONFieldName(t, f)
+	tags := parseFieldTags(f)
+
+	if tags.omit {
+		return nil
+	}
+	if !tags.omitEmpty && !g.omitEmpty || tags.noOmitEmpty {
+		fmt.Fprintln(g.out, "  if !first { out.RawByte(',') }")
+		fmt.Fprintln(g.out, "  first = false")
+		fmt.Fprintf(g.out, "  out.RawString(%q)\n", strconv.Quote(jsonName)+":")
+		return g.genTypeEncoder(f.Type, "in."+f.Name, tags, 1)
+	}
+
+	fmt.Fprintln(g.out, "  if", g.notEmptyCheck(f.Type, "in."+f.Name), "{")
+	fmt.Fprintln(g.out, "    if !first { out.RawByte(',') }")
+	fmt.Fprintln(g.out, "    first = false")
+
+	fmt.Fprintf(g.out, "    out.RawString(%q)\n", strconv.Quote(jsonName)+":")
+	if err := g.genTypeEncoder(f.Type, "in."+f.Name, tags, 2); err != nil {
+		return err
+	}
+	fmt.Fprintln(g.out, "  }")
+	return nil
+}
+
+func (g *Generator) genEncoder(t reflect.Type) error {
+	switch t.Kind() {
+	case reflect.Slice, reflect.Array, reflect.Map:
+		return g.genSliceArrayMapEncoder(t)
+	default:
+		return g.genStructEncoder(t)
+	}
+}
+
+func (g *Generator) genSliceArrayMapEncoder(t reflect.Type) error {
+	switch t.Kind() {
+	case reflect.Slice, reflect.Array, reflect.Map:
+	default:
+		return fmt.Errorf("cannot generate encoder/decoder for %v, not a slice/array/map type", t)
+	}
+
+	fname := g.getEncoderName(t)
+	typ := g.getType(t)
+
+	fmt.Fprintln(g.out, "func "+fname+"(out *jwriter.Writer, in "+typ+") {")
+	err := g.genTypeEncoderNoCheck(t, "in", fieldTags{}, 1)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintln(g.out, "}")
+	return nil
+}
+
+func (g *Generator) genStructEncoder(t reflect.Type) error {
+	if t.Kind() != reflect.Struct {
+		return fmt.Errorf("cannot generate encoder/decoder for %v, not a struct type", t)
+	}
+
+	fname := g.getEncoderName(t)
+	typ := g.getType(t)
+
+	fmt.Fprintln(g.out, "func "+fname+"(out *jwriter.Writer, in "+typ+") {")
+	fmt.Fprintln(g.out, "  out.RawByte('{')")
+	fmt.Fprintln(g.out, "  first := true")
+	fmt.Fprintln(g.out, "  _ = first")
+
+	fs, err := getStructFields(t)
+	if err != nil {
+		return fmt.Errorf("cannot generate encoder for %v: %v", t, err)
+	}
+	for _, f := range fs {
+		if err := g.genStructFieldEncoder(t, f); err != nil {
+			return err
+		}
+	}
+
+	fmt.Fprintln(g.out, "  out.RawByte('}')")
+	fmt.Fprintln(g.out, "}")
+
+	return nil
+}
+
+func (g *Generator) genStructMarshaler(t reflect.Type) error {
+	switch t.Kind() {
+	case reflect.Slice, reflect.Array, reflect.Map, reflect.Struct:
+	default:
+		return fmt.Errorf("cannot generate encoder/decoder for %v, not a struct/slice/array/map type", t)
+	}
+
+	fname := g.getEncoderName(t)
+	typ := g.getType(t)
+
+	if !g.noStdMarshalers {
+		fmt.Fprintln(g.out, "// MarshalJSON supports json.Marshaler interface")
+		fmt.Fprintln(g.out, "func (v "+typ+") MarshalJSON() ([]byte, error) {")
+		fmt.Fprintln(g.out, "  w := jwriter.Writer{}")
+		fmt.Fprintln(g.out, "  "+fname+"(&w, v)")
+		fmt.Fprintln(g.out, "  return w.Buffer.BuildBytes(), w.Error")
+		fmt.Fprintln(g.out, "}")
+	}
+
+	fmt.Fprintln(g.out, "// MarshalEasyJSON supports easyjson.Marshaler interface")
+	fmt.Fprintln(g.out, "func (v "+typ+") MarshalEasyJSON(w *jwriter.Writer) {")
+	fmt.Fprintln(g.out, "  "+fname+"(w, v)")
+	fmt.Fprintln(g.out, "}")
+
+	return nil
+}

vendor/github.com/mailru/easyjson/gen/generator.go

@@ -0,0 +1,523 @@
+package gen
+
+import (
+	"bytes"
+	"fmt"
+	"hash/fnv"
+	"io"
+	"path"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"unicode"
+)
+
+const pkgWriter = "github.com/mailru/easyjson/jwriter"
+const pkgLexer = "github.com/mailru/easyjson/jlexer"
+const pkgEasyJSON = "github.com/mailru/easyjson"
+
+// FieldNamer defines a policy for generating names for struct fields.
+type FieldNamer interface {
+	GetJSONFieldName(t reflect.Type, f reflect.StructField) string
+}
+
+// Generator generates the requested marshaler/unmarshalers.
+type Generator struct {
+	out *bytes.Buffer
+
+	pkgName    string
+	pkgPath    string
+	buildTags  string
+	hashString string
+
+	varCounter int
+
+	noStdMarshalers bool
+	omitEmpty       bool
+	fieldNamer      FieldNamer
+
+	// package path to local alias map for tracking imports
+	imports map[string]string
+
+	// types that marshalers were requested for by user
+	marshalers map[reflect.Type]bool
+
+	// types that encoders were already generated for
+	typesSeen map[reflect.Type]bool
+
+	// types that encoders were requested for (e.g. by encoders of other types)
+	typesUnseen []reflect.Type
+
+	// function name to relevant type maps to track names of de-/encoders in
+	// case of a name clash or unnamed structs
+	functionNames map[string]reflect.Type
+}
+
+// NewGenerator initializes and returns a Generator.
+func NewGenerator(filename string) *Generator {
+	ret := &Generator{
+		imports: map[string]string{
+			pkgWriter:       "jwriter",
+			pkgLexer:        "jlexer",
+			pkgEasyJSON:     "easyjson",
+			"encoding/json": "json",
+		},
+		fieldNamer:    DefaultFieldNamer{},
+		marshalers:    make(map[reflect.Type]bool),
+		typesSeen:     make(map[reflect.Type]bool),
+		functionNames: make(map[string]reflect.Type),
+	}
+
+	// Use a file-unique prefix on all auxiliary funcs to avoid
+	// name clashes.
+	hash := fnv.New32()
+	hash.Write([]byte(filename))
+	ret.hashString = fmt.Sprintf("%x", hash.Sum32())
+
+	return ret
+}
+
+// SetPkg sets the name and path of output package.
+func (g *Generator) SetPkg(name, path string) {
+	g.pkgName = name
+	g.pkgPath = path
+}
+
+// SetBuildTags sets build tags for the output file.
+func (g *Generator) SetBuildTags(tags string) {
+	g.buildTags = tags
+}
+
+// SetFieldNamer sets field naming strategy.
+func (g *Generator) SetFieldNamer(n FieldNamer) {
+	g.fieldNamer = n
+}
+
+// UseSnakeCase sets snake_case field naming strategy.
+func (g *Generator) UseSnakeCase() {
+	g.fieldNamer = SnakeCaseFieldNamer{}
+}
+
+// UseLowerCamelCase sets lowerCamelCase field naming strategy.
+func (g *Generator) UseLowerCamelCase() {
+	g.fieldNamer = LowerCamelCaseFieldNamer{}
+}
+
+// NoStdMarshalers instructs not to generate standard MarshalJSON/UnmarshalJSON
+// methods (only the custom interface).
+func (g *Generator) NoStdMarshalers() {
+	g.noStdMarshalers = true
+}
+
+// OmitEmpty triggers `json=",omitempty"` behaviour by default.
+func (g *Generator) OmitEmpty() {
+	g.omitEmpty = true
+}
+
+// addTypes requests to generate encoding/decoding funcs for the given type.
+func (g *Generator) addType(t reflect.Type) {
+	if g.typesSeen[t] {
+		return
+	}
+	for _, t1 := range g.typesUnseen {
+		if t1 == t {
+			return
+		}
+	}
+	g.typesUnseen = append(g.typesUnseen, t)
+}
+
+// Add requests to generate marshaler/unmarshalers and encoding/decoding
+// funcs for the type of given object.
+func (g *Generator) Add(obj interface{}) {
+	t := reflect.TypeOf(obj)
+	if t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	g.addType(t)
+	g.marshalers[t] = true
+}
+
+// printHeader prints package declaration and imports.
+func (g *Generator) printHeader() {
+	if g.buildTags != "" {
+		fmt.Println("// +build ", g.buildTags)
+		fmt.Println()
+	}
+	fmt.Println("// Code generated by easyjson for marshaling/unmarshaling. DO NOT EDIT.")
+	fmt.Println()
+	fmt.Println("package ", g.pkgName)
+	fmt.Println()
+
+	byAlias := map[string]string{}
+	var aliases []string
+	for path, alias := range g.imports {
+		aliases = append(aliases, alias)
+		byAlias[alias] = path
+	}
+
+	sort.Strings(aliases)
+	fmt.Println("import (")
+	for _, alias := range aliases {
+		fmt.Printf("  %s %q\n", alias, byAlias[alias])
+	}
+
+	fmt.Println(")")
+	fmt.Println("")
+	fmt.Println("// suppress unused package warning")
+	fmt.Println("var (")
+	fmt.Println("   _ *json.RawMessage")
+	fmt.Println("   _ *jlexer.Lexer")
+	fmt.Println("   _ *jwriter.Writer")
+	fmt.Println("   _ easyjson.Marshaler")
+	fmt.Println(")")
+
+	fmt.Println()
+}
+
+// Run runs the generator and outputs generated code to out.
+func (g *Generator) Run(out io.Writer) error {
+	g.out = &bytes.Buffer{}
+
+	for len(g.typesUnseen) > 0 {
+		t := g.typesUnseen[len(g.typesUnseen)-1]
+		g.typesUnseen = g.typesUnseen[:len(g.typesUnseen)-1]
+		g.typesSeen[t] = true
+
+		if err := g.genDecoder(t); err != nil {
+			return err
+		}
+		if err := g.genEncoder(t); err != nil {
+			return err
+		}
+
+		if !g.marshalers[t] {
+			continue
+		}
+
+		if err := g.genStructMarshaler(t); err != nil {
+			return err
+		}
+		if err := g.genStructUnmarshaler(t); err != nil {
+			return err
+		}
+	}
+	g.printHeader()
+	_, err := out.Write(g.out.Bytes())
+	return err
+}
+
+// fixes vendored paths
+func fixPkgPathVendoring(pkgPath string) string {
+	const vendor = "/vendor/"
+	if i := strings.LastIndex(pkgPath, vendor); i != -1 {
+		return pkgPath[i+len(vendor):]
+	}
+	return pkgPath
+}
+
+func fixAliasName(alias string) string {
+	alias = strings.Replace(
+		strings.Replace(alias, ".", "_", -1),
+		"-",
+		"_",
+		-1,
+	)
+
+	if alias[0] == 'v' { // to void conflicting with var names, say v1
+		alias = "_" + alias
+	}
+	return alias
+}
+
+// pkgAlias creates and returns and import alias for a given package.
+func (g *Generator) pkgAlias(pkgPath string) string {
+	pkgPath = fixPkgPathVendoring(pkgPath)
+	if alias := g.imports[pkgPath]; alias != "" {
+		return alias
+	}
+
+	for i := 0; ; i++ {
+		alias := fixAliasName(path.Base(pkgPath))
+		if i > 0 {
+			alias += fmt.Sprint(i)
+		}
+
+		exists := false
+		for _, v := range g.imports {
+			if v == alias {
+				exists = true
+				break
+			}
+		}
+
+		if !exists {
+			g.imports[pkgPath] = alias
+			return alias
+		}
+	}
+}
+
+// getType return the textual type name of given type that can be used in generated code.
+func (g *Generator) getType(t reflect.Type) string {
+	if t.Name() == "" {
+		switch t.Kind() {
+		case reflect.Ptr:
+			return "*" + g.getType(t.Elem())
+		case reflect.Slice:
+			return "[]" + g.getType(t.Elem())
+		case reflect.Array:
+			return "[" + strconv.Itoa(t.Len()) + "]" + g.getType(t.Elem())
+		case reflect.Map:
+			return "map[" + g.getType(t.Key()) + "]" + g.getType(t.Elem())
+		}
+	}
+
+	if t.Name() == "" || t.PkgPath() == "" {
+		if t.Kind() == reflect.Struct {
+			// the fields of an anonymous struct can have named types,
+			// and t.String() will not be sufficient because it does not
+			// remove the package name when it matches g.pkgPath.
+			// so we convert by hand
+			nf := t.NumField()
+			lines := make([]string, 0, nf)
+			for i := 0; i < nf; i++ {
+				f := t.Field(i)
+				line := f.Name + " " + g.getType(f.Type)
+				t := f.Tag
+				if t != "" {
+					line += " " + escapeTag(t)
+				}
+				lines = append(lines, line)
+			}
+			return strings.Join([]string{"struct { ", strings.Join(lines, "; "), " }"}, "")
+		}
+		return t.String()
+	} else if t.PkgPath() == g.pkgPath {
+		return t.Name()
+	}
+	return g.pkgAlias(t.PkgPath()) + "." + t.Name()
+}
+
+// escape a struct field tag string back to source code
+func escapeTag(tag reflect.StructTag) string {
+	t := string(tag)
+	if strings.ContainsRune(t, '`') {
+		// there are ` in the string; we can't use ` to enclose the string
+		return strconv.Quote(t)
+	}
+	return "`" + t + "`"
+}
+
+// uniqueVarName returns a file-unique name that can be used for generated variables.
+func (g *Generator) uniqueVarName() string {
+	g.varCounter++
+	return fmt.Sprint("v", g.varCounter)
+}
+
+// safeName escapes unsafe characters in pkg/type name and returns a string that can be used
+// in encoder/decoder names for the type.
+func (g *Generator) safeName(t reflect.Type) string {
+	name := t.PkgPath()
+	if t.Name() == "" {
+		name += "anonymous"
+	} else {
+		name += "." + t.Name()
+	}
+
+	parts := []string{}
+	part := []rune{}
+	for _, c := range name {
+		if unicode.IsLetter(c) || unicode.IsDigit(c) {
+			part = append(part, c)
+		} else if len(part) > 0 {
+			parts = append(parts, string(part))
+			part = []rune{}
+		}
+	}
+	return joinFunctionNameParts(false, parts...)
+}
+
+// functionName returns a function name for a given type with a given prefix. If a function
+// with this prefix already exists for a type, it is returned.
+//
+// Method is used to track encoder/decoder names for the type.
+func (g *Generator) functionName(prefix string, t reflect.Type) string {
+	prefix = joinFunctionNameParts(true, "easyjson", g.hashString, prefix)
+	name := joinFunctionNameParts(true, prefix, g.safeName(t))
+
+	// Most of the names will be unique, try a shortcut first.
+	if e, ok := g.functionNames[name]; !ok || e == t {
+		g.functionNames[name] = t
+		return name
+	}
+
+	// Search if the function already exists.
+	for name1, t1 := range g.functionNames {
+		if t1 == t && strings.HasPrefix(name1, prefix) {
+			return name1
+		}
+	}
+
+	// Create a new name in the case of a clash.
+	for i := 1; ; i++ {
+		nm := fmt.Sprint(name, i)
+		if _, ok := g.functionNames[nm]; ok {
+			continue
+		}
+		g.functionNames[nm] = t
+		return nm
+	}
+}
+
+// DefaultFieldsNamer implements trivial naming policy equivalent to encoding/json.
+type DefaultFieldNamer struct{}
+
+func (DefaultFieldNamer) GetJSONFieldName(t reflect.Type, f reflect.StructField) string {
+	jsonName := strings.Split(f.Tag.Get("json"), ",")[0]
+	if jsonName != "" {
+		return jsonName
+	} else {
+		return f.Name
+	}
+}
+
+// LowerCamelCaseFieldNamer
+type LowerCamelCaseFieldNamer struct{}
+
+func isLower(b byte) bool {
+	return b <= 122 && b >= 97
+}
+
+func isUpper(b byte) bool {
+	return b >= 65 && b <= 90
+}
+
+// convert HTTPRestClient to httpRestClient
+func lowerFirst(s string) string {
+	if s == "" {
+		return ""
+	}
+
+	str := ""
+	strlen := len(s)
+
+	/**
+	  Loop each char
+	  If is uppercase:
+	    If is first char, LOWER it
+	    If the following char is lower, LEAVE it
+	    If the following char is upper OR numeric, LOWER it
+	    If is the end of string, LEAVE it
+	  Else lowercase
+	*/
+
+	foundLower := false
+	for i := range s {
+		ch := s[i]
+		if isUpper(ch) {
+			if i == 0 {
+				str += string(ch + 32)
+			} else if !foundLower { // Currently just a stream of capitals, eg JSONRESTS[erver]
+				if strlen > (i+1) && isLower(s[i+1]) {
+					// Next char is lower, keep this a capital
+					str += string(ch)
+				} else {
+					// Either at end of string or next char is capital
+					str += string(ch + 32)
+				}
+			} else {
+				str += string(ch)
+			}
+		} else {
+			foundLower = true
+			str += string(ch)
+		}
+	}
+
+	return str
+}
+
+func (LowerCamelCaseFieldNamer) GetJSONFieldName(t reflect.Type, f reflect.StructField) string {
+	jsonName := strings.Split(f.Tag.Get("json"), ",")[0]
+	if jsonName != "" {
+		return jsonName
+	} else {
+		return lowerFirst(f.Name)
+	}
+}
+
+// SnakeCaseFieldNamer implements CamelCase to snake_case conversion for fields names.
+type SnakeCaseFieldNamer struct{}
+
+func camelToSnake(name string) string {
+	var ret bytes.Buffer
+
+	multipleUpper := false
+	var lastUpper rune
+	var beforeUpper rune
+
+	for _, c := range name {
+		// Non-lowercase character after uppercase is considered to be uppercase too.
+		isUpper := (unicode.IsUpper(c) || (lastUpper != 0 && !unicode.IsLower(c)))
+
+		if lastUpper != 0 {
+			// Output a delimiter if last character was either the first uppercase character
+			// in a row, or the last one in a row (e.g. 'S' in "HTTPServer").
+			// Do not output a delimiter at the beginning of the name.
+
+			firstInRow := !multipleUpper
+			lastInRow := !isUpper
+
+			if ret.Len() > 0 && (firstInRow || lastInRow) && beforeUpper != '_' {
+				ret.WriteByte('_')
+			}
+			ret.WriteRune(unicode.ToLower(lastUpper))
+		}
+
+		// Buffer uppercase char, do not output it yet as a delimiter may be required if the
+		// next character is lowercase.
+		if isUpper {
+			multipleUpper = (lastUpper != 0)
+			lastUpper = c
+			continue
+		}
+
+		ret.WriteRune(c)
+		lastUpper = 0
+		beforeUpper = c
+		multipleUpper = false
+	}
+
+	if lastUpper != 0 {
+		ret.WriteRune(unicode.ToLower(lastUpper))
+	}
+	return string(ret.Bytes())
+}
+
+func (SnakeCaseFieldNamer) GetJSONFieldName(t reflect.Type, f reflect.StructField) string {
+	jsonName := strings.Split(f.Tag.Get("json"), ",")[0]
+	if jsonName != "" {
+		return jsonName
+	}
+
+	return camelToSnake(f.Name)
+}
+
+func joinFunctionNameParts(keepFirst bool, parts ...string) string {
+	buf := bytes.NewBufferString("")
+	for i, part := range parts {
+		if i == 0 && keepFirst {
+			buf.WriteString(part)
+		} else {
+			if len(part) > 0 {
+				buf.WriteString(strings.ToUpper(string(part[0])))
+			}
+			if len(part) > 1 {
+				buf.WriteString(part[1:])
+			}
+		}
+	}
+	return buf.String()
+}

vendor/github.com/mailru/easyjson/gen/generator_test.go

@@ -0,0 +1,87 @@
+package gen
+
+import (
+	"testing"
+)
+
+func TestCamelToSnake(t *testing.T) {
+	for i, test := range []struct {
+		In, Out string
+	}{
+		{"", ""},
+		{"A", "a"},
+		{"SimpleExample", "simple_example"},
+		{"internalField", "internal_field"},
+
+		{"SomeHTTPStuff", "some_http_stuff"},
+		{"WriteJSON", "write_json"},
+		{"HTTP2Server", "http2_server"},
+		{"Some_Mixed_Case", "some_mixed_case"},
+		{"do_nothing", "do_nothing"},
+
+		{"JSONHTTPRPCServer", "jsonhttprpc_server"}, // nothing can be done here without a dictionary
+	} {
+		got := camelToSnake(test.In)
+		if got != test.Out {
+			t.Errorf("[%d] camelToSnake(%s) = %s; want %s", i, test.In, got, test.Out)
+		}
+	}
+}
+
+func TestCamelToLowerCamel(t *testing.T) {
+	for i, test := range []struct {
+		In, Out string
+	}{
+		{"", ""},
+		{"A", "a"},
+		{"SimpleExample", "simpleExample"},
+		{"internalField", "internalField"},
+
+		{"SomeHTTPStuff", "someHTTPStuff"},
+		{"WriteJSON", "writeJSON"},
+		{"HTTP2Server", "http2Server"},
+
+		{"JSONHTTPRPCServer", "jsonhttprpcServer"}, // nothing can be done here without a dictionary
+	} {
+		got := lowerFirst(test.In)
+		if got != test.Out {
+			t.Errorf("[%d] lowerFirst(%s) = %s; want %s", i, test.In, got, test.Out)
+		}
+	}
+}
+
+func TestJoinFunctionNameParts(t *testing.T) {
+	for i, test := range []struct {
+		keepFirst bool
+		parts     []string
+		out       string
+	}{
+		{false, []string{}, ""},
+		{false, []string{"a"}, "A"},
+		{false, []string{"simple", "example"}, "SimpleExample"},
+		{true, []string{"first", "example"}, "firstExample"},
+		{false, []string{"some", "UPPER", "case"}, "SomeUPPERCase"},
+		{false, []string{"number", "123"}, "Number123"},
+	} {
+		got := joinFunctionNameParts(test.keepFirst, test.parts...)
+		if got != test.out {
+			t.Errorf("[%d] joinFunctionNameParts(%v) = %s; want %s", i, test.parts, got, test.out)
+		}
+	}
+}
+
+func TestFixVendorPath(t *testing.T) {
+	for i, test := range []struct {
+		In, Out string
+	}{
+		{"", ""},
+		{"time", "time"},
+		{"project/vendor/subpackage", "subpackage"},
+	} {
+		got := fixPkgPathVendoring(test.In)
+		if got != test.Out {
+			t.Errorf("[%d] fixPkgPathVendoring(%s) = %s; want %s", i, test.In, got, test.Out)
+		}
+	}
+
+}

vendor/github.com/mailru/easyjson/opt/gotemplate_Bool.go

@@ -0,0 +1,79 @@
+// generated by gotemplate
+
+package opt
+
+import (
+	"fmt"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// template type Optional(A)
+
+// A 'gotemplate'-based type for providing optional semantics without using pointers.
+type Bool struct {
+	V       bool
+	Defined bool
+}
+
+// Creates an optional type with a given value.
+func OBool(v bool) Bool {
+	return Bool{V: v, Defined: true}
+}
+
+// Get returns the value or given default in the case the value is undefined.
+func (v Bool) Get(deflt bool) bool {
+	if !v.Defined {
+		return deflt
+	}
+	return v.V
+}
+
+// MarshalEasyJSON does JSON marshaling using easyjson interface.
+func (v Bool) MarshalEasyJSON(w *jwriter.Writer) {
+	if v.Defined {
+		w.Bool(v.V)
+	} else {
+		w.RawString("null")
+	}
+}
+
+// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface.
+func (v *Bool) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	if l.IsNull() {
+		l.Skip()
+		*v = Bool{}
+	} else {
+		v.V = l.Bool()
+		v.Defined = true
+	}
+}
+
+// MarshalJSON implements a standard json marshaler interface.
+func (v *Bool) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// UnmarshalJSON implements a standard json unmarshaler interface.
+func (v *Bool) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// IsDefined returns whether the value is defined, a function is required so that it can
+// be used in an interface.
+func (v Bool) IsDefined() bool {
+	return v.Defined
+}
+
+// String implements a stringer interface using fmt.Sprint for the value.
+func (v Bool) String() string {
+	if !v.Defined {
+		return "<undefined>"
+	}
+	return fmt.Sprint(v.V)
+}

vendor/github.com/mailru/easyjson/opt/gotemplate_Float32.go

@@ -0,0 +1,79 @@
+// generated by gotemplate
+
+package opt
+
+import (
+	"fmt"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// template type Optional(A)
+
+// A 'gotemplate'-based type for providing optional semantics without using pointers.
+type Float32 struct {
+	V       float32
+	Defined bool
+}
+
+// Creates an optional type with a given value.
+func OFloat32(v float32) Float32 {
+	return Float32{V: v, Defined: true}
+}
+
+// Get returns the value or given default in the case the value is undefined.
+func (v Float32) Get(deflt float32) float32 {
+	if !v.Defined {
+		return deflt
+	}
+	return v.V
+}
+
+// MarshalEasyJSON does JSON marshaling using easyjson interface.
+func (v Float32) MarshalEasyJSON(w *jwriter.Writer) {
+	if v.Defined {
+		w.Float32(v.V)
+	} else {
+		w.RawString("null")
+	}
+}
+
+// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface.
+func (v *Float32) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	if l.IsNull() {
+		l.Skip()
+		*v = Float32{}
+	} else {
+		v.V = l.Float32()
+		v.Defined = true
+	}
+}
+
+// MarshalJSON implements a standard json marshaler interface.
+func (v *Float32) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// UnmarshalJSON implements a standard json unmarshaler interface.
+func (v *Float32) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// IsDefined returns whether the value is defined, a function is required so that it can
+// be used in an interface.
+func (v Float32) IsDefined() bool {
+	return v.Defined
+}
+
+// String implements a stringer interface using fmt.Sprint for the value.
+func (v Float32) String() string {
+	if !v.Defined {
+		return "<undefined>"
+	}
+	return fmt.Sprint(v.V)
+}

vendor/github.com/mailru/easyjson/opt/gotemplate_Float64.go

@@ -0,0 +1,79 @@
+// generated by gotemplate
+
+package opt
+
+import (
+	"fmt"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// template type Optional(A)
+
+// A 'gotemplate'-based type for providing optional semantics without using pointers.
+type Float64 struct {
+	V       float64
+	Defined bool
+}
+
+// Creates an optional type with a given value.
+func OFloat64(v float64) Float64 {
+	return Float64{V: v, Defined: true}
+}
+
+// Get returns the value or given default in the case the value is undefined.
+func (v Float64) Get(deflt float64) float64 {
+	if !v.Defined {
+		return deflt
+	}
+	return v.V
+}
+
+// MarshalEasyJSON does JSON marshaling using easyjson interface.
+func (v Float64) MarshalEasyJSON(w *jwriter.Writer) {
+	if v.Defined {
+		w.Float64(v.V)
+	} else {
+		w.RawString("null")
+	}
+}
+
+// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface.
+func (v *Float64) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	if l.IsNull() {
+		l.Skip()
+		*v = Float64{}
+	} else {
+		v.V = l.Float64()
+		v.Defined = true
+	}
+}
+
+// MarshalJSON implements a standard json marshaler interface.
+func (v *Float64) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// UnmarshalJSON implements a standard json unmarshaler interface.
+func (v *Float64) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// IsDefined returns whether the value is defined, a function is required so that it can
+// be used in an interface.
+func (v Float64) IsDefined() bool {
+	return v.Defined
+}
+
+// String implements a stringer interface using fmt.Sprint for the value.
+func (v Float64) String() string {
+	if !v.Defined {
+		return "<undefined>"
+	}
+	return fmt.Sprint(v.V)
+}

vendor/github.com/mailru/easyjson/opt/gotemplate_Int.go

@@ -0,0 +1,79 @@
+// generated by gotemplate
+
+package opt
+
+import (
+	"fmt"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// template type Optional(A)
+
+// A 'gotemplate'-based type for providing optional semantics without using pointers.
+type Int struct {
+	V       int
+	Defined bool
+}
+
+// Creates an optional type with a given value.
+func OInt(v int) Int {
+	return Int{V: v, Defined: true}
+}
+
+// Get returns the value or given default in the case the value is undefined.
+func (v Int) Get(deflt int) int {
+	if !v.Defined {
+		return deflt
+	}
+	return v.V
+}
+
+// MarshalEasyJSON does JSON marshaling using easyjson interface.
+func (v Int) MarshalEasyJSON(w *jwriter.Writer) {
+	if v.Defined {
+		w.Int(v.V)
+	} else {
+		w.RawString("null")
+	}
+}
+
+// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface.
+func (v *Int) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	if l.IsNull() {
+		l.Skip()
+		*v = Int{}
+	} else {
+		v.V = l.Int()
+		v.Defined = true
+	}
+}
+
+// MarshalJSON implements a standard json marshaler interface.
+func (v *Int) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// UnmarshalJSON implements a standard json unmarshaler interface.
+func (v *Int) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// IsDefined returns whether the value is defined, a function is required so that it can
+// be used in an interface.
+func (v Int) IsDefined() bool {
+	return v.Defined
+}
+
+// String implements a stringer interface using fmt.Sprint for the value.
+func (v Int) String() string {
+	if !v.Defined {
+		return "<undefined>"
+	}
+	return fmt.Sprint(v.V)
+}

vendor/github.com/mailru/easyjson/opt/gotemplate_Int16.go

@@ -0,0 +1,79 @@
+// generated by gotemplate
+
+package opt
+
+import (
+	"fmt"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// template type Optional(A)
+
+// A 'gotemplate'-based type for providing optional semantics without using pointers.
+type Int16 struct {
+	V       int16
+	Defined bool
+}
+
+// Creates an optional type with a given value.
+func OInt16(v int16) Int16 {
+	return Int16{V: v, Defined: true}
+}
+
+// Get returns the value or given default in the case the value is undefined.
+func (v Int16) Get(deflt int16) int16 {
+	if !v.Defined {
+		return deflt
+	}
+	return v.V
+}
+
+// MarshalEasyJSON does JSON marshaling using easyjson interface.
+func (v Int16) MarshalEasyJSON(w *jwriter.Writer) {
+	if v.Defined {
+		w.Int16(v.V)
+	} else {
+		w.RawString("null")
+	}
+}
+
+// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface.
+func (v *Int16) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	if l.IsNull() {
+		l.Skip()
+		*v = Int16{}
+	} else {
+		v.V = l.Int16()
+		v.Defined = true
+	}
+}
+
+// MarshalJSON implements a standard json marshaler interface.
+func (v *Int16) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// UnmarshalJSON implements a standard json unmarshaler interface.
+func (v *Int16) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// IsDefined returns whether the value is defined, a function is required so that it can
+// be used in an interface.
+func (v Int16) IsDefined() bool {
+	return v.Defined
+}
+
+// String implements a stringer interface using fmt.Sprint for the value.
+func (v Int16) String() string {
+	if !v.Defined {
+		return "<undefined>"
+	}
+	return fmt.Sprint(v.V)
+}

vendor/github.com/mailru/easyjson/opt/gotemplate_Int32.go

@@ -0,0 +1,79 @@
+// generated by gotemplate
+
+package opt
+
+import (
+	"fmt"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// template type Optional(A)
+
+// A 'gotemplate'-based type for providing optional semantics without using pointers.
+type Int32 struct {
+	V       int32
+	Defined bool
+}
+
+// Creates an optional type with a given value.
+func OInt32(v int32) Int32 {
+	return Int32{V: v, Defined: true}
+}
+
+// Get returns the value or given default in the case the value is undefined.
+func (v Int32) Get(deflt int32) int32 {
+	if !v.Defined {
+		return deflt
+	}
+	return v.V
+}
+
+// MarshalEasyJSON does JSON marshaling using easyjson interface.
+func (v Int32) MarshalEasyJSON(w *jwriter.Writer) {
+	if v.Defined {
+		w.Int32(v.V)
+	} else {
+		w.RawString("null")
+	}
+}
+
+// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface.
+func (v *Int32) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	if l.IsNull() {
+		l.Skip()
+		*v = Int32{}
+	} else {
+		v.V = l.Int32()
+		v.Defined = true
+	}
+}
+
+// MarshalJSON implements a standard json marshaler interface.
+func (v *Int32) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// UnmarshalJSON implements a standard json unmarshaler interface.
+func (v *Int32) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// IsDefined returns whether the value is defined, a function is required so that it can
+// be used in an interface.
+func (v Int32) IsDefined() bool {
+	return v.Defined
+}
+
+// String implements a stringer interface using fmt.Sprint for the value.
+func (v Int32) String() string {
+	if !v.Defined {
+		return "<undefined>"
+	}
+	return fmt.Sprint(v.V)
+}

vendor/github.com/mailru/easyjson/opt/gotemplate_Int64.go

@@ -0,0 +1,79 @@
+// generated by gotemplate
+
+package opt
+
+import (
+	"fmt"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// template type Optional(A)
+
+// A 'gotemplate'-based type for providing optional semantics without using pointers.
+type Int64 struct {
+	V       int64
+	Defined bool
+}
+
+// Creates an optional type with a given value.
+func OInt64(v int64) Int64 {
+	return Int64{V: v, Defined: true}
+}
+
+// Get returns the value or given default in the case the value is undefined.
+func (v Int64) Get(deflt int64) int64 {
+	if !v.Defined {
+		return deflt
+	}
+	return v.V
+}
+
+// MarshalEasyJSON does JSON marshaling using easyjson interface.
+func (v Int64) MarshalEasyJSON(w *jwriter.Writer) {
+	if v.Defined {
+		w.Int64(v.V)
+	} else {
+		w.RawString("null")
+	}
+}
+
+// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface.
+func (v *Int64) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	if l.IsNull() {
+		l.Skip()
+		*v = Int64{}
+	} else {
+		v.V = l.Int64()
+		v.Defined = true
+	}
+}
+
+// MarshalJSON implements a standard json marshaler interface.
+func (v *Int64) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// UnmarshalJSON implements a standard json unmarshaler interface.
+func (v *Int64) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// IsDefined returns whether the value is defined, a function is required so that it can
+// be used in an interface.
+func (v Int64) IsDefined() bool {
+	return v.Defined
+}
+
+// String implements a stringer interface using fmt.Sprint for the value.
+func (v Int64) String() string {
+	if !v.Defined {
+		return "<undefined>"
+	}
+	return fmt.Sprint(v.V)
+}

vendor/github.com/mailru/easyjson/opt/gotemplate_Int8.go

@@ -0,0 +1,79 @@
+// generated by gotemplate
+
+package opt
+
+import (
+	"fmt"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// template type Optional(A)
+
+// A 'gotemplate'-based type for providing optional semantics without using pointers.
+type Int8 struct {
+	V       int8
+	Defined bool
+}
+
+// Creates an optional type with a given value.
+func OInt8(v int8) Int8 {
+	return Int8{V: v, Defined: true}
+}
+
+// Get returns the value or given default in the case the value is undefined.
+func (v Int8) Get(deflt int8) int8 {
+	if !v.Defined {
+		return deflt
+	}
+	return v.V
+}
+
+// MarshalEasyJSON does JSON marshaling using easyjson interface.
+func (v Int8) MarshalEasyJSON(w *jwriter.Writer) {
+	if v.Defined {
+		w.Int8(v.V)
+	} else {
+		w.RawString("null")
+	}
+}
+
+// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface.
+func (v *Int8) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	if l.IsNull() {
+		l.Skip()
+		*v = Int8{}
+	} else {
+		v.V = l.Int8()
+		v.Defined = true
+	}
+}
+
+// MarshalJSON implements a standard json marshaler interface.
+func (v *Int8) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// UnmarshalJSON implements a standard json unmarshaler interface.
+func (v *Int8) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// IsDefined returns whether the value is defined, a function is required so that it can
+// be used in an interface.
+func (v Int8) IsDefined() bool {
+	return v.Defined
+}
+
+// String implements a stringer interface using fmt.Sprint for the value.
+func (v Int8) String() string {
+	if !v.Defined {
+		return "<undefined>"
+	}
+	return fmt.Sprint(v.V)
+}

vendor/github.com/mailru/easyjson/opt/gotemplate_String.go

@@ -0,0 +1,79 @@
+// generated by gotemplate
+
+package opt
+
+import (
+	"fmt"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// template type Optional(A)
+
+// A 'gotemplate'-based type for providing optional semantics without using pointers.
+type String struct {
+	V       string
+	Defined bool
+}
+
+// Creates an optional type with a given value.
+func OString(v string) String {
+	return String{V: v, Defined: true}
+}
+
+// Get returns the value or given default in the case the value is undefined.
+func (v String) Get(deflt string) string {
+	if !v.Defined {
+		return deflt
+	}
+	return v.V
+}
+
+// MarshalEasyJSON does JSON marshaling using easyjson interface.
+func (v String) MarshalEasyJSON(w *jwriter.Writer) {
+	if v.Defined {
+		w.String(v.V)
+	} else {
+		w.RawString("null")
+	}
+}
+
+// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface.
+func (v *String) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	if l.IsNull() {
+		l.Skip()
+		*v = String{}
+	} else {
+		v.V = l.String()
+		v.Defined = true
+	}
+}
+
+// MarshalJSON implements a standard json marshaler interface.
+func (v *String) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// UnmarshalJSON implements a standard json unmarshaler interface.
+func (v *String) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// IsDefined returns whether the value is defined, a function is required so that it can
+// be used in an interface.
+func (v String) IsDefined() bool {
+	return v.Defined
+}
+
+// String implements a stringer interface using fmt.Sprint for the value.
+func (v String) String() string {
+	if !v.Defined {
+		return "<undefined>"
+	}
+	return fmt.Sprint(v.V)
+}

vendor/github.com/mailru/easyjson/opt/gotemplate_Uint.go

@@ -0,0 +1,79 @@
+// generated by gotemplate
+
+package opt
+
+import (
+	"fmt"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// template type Optional(A)
+
+// A 'gotemplate'-based type for providing optional semantics without using pointers.
+type Uint struct {
+	V       uint
+	Defined bool
+}
+
+// Creates an optional type with a given value.
+func OUint(v uint) Uint {
+	return Uint{V: v, Defined: true}
+}
+
+// Get returns the value or given default in the case the value is undefined.
+func (v Uint) Get(deflt uint) uint {
+	if !v.Defined {
+		return deflt
+	}
+	return v.V
+}
+
+// MarshalEasyJSON does JSON marshaling using easyjson interface.
+func (v Uint) MarshalEasyJSON(w *jwriter.Writer) {
+	if v.Defined {
+		w.Uint(v.V)
+	} else {
+		w.RawString("null")
+	}
+}
+
+// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface.
+func (v *Uint) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	if l.IsNull() {
+		l.Skip()
+		*v = Uint{}
+	} else {
+		v.V = l.Uint()
+		v.Defined = true
+	}
+}
+
+// MarshalJSON implements a standard json marshaler interface.
+func (v *Uint) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// UnmarshalJSON implements a standard json unmarshaler interface.
+func (v *Uint) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// IsDefined returns whether the value is defined, a function is required so that it can
+// be used in an interface.
+func (v Uint) IsDefined() bool {
+	return v.Defined
+}
+
+// String implements a stringer interface using fmt.Sprint for the value.
+func (v Uint) String() string {
+	if !v.Defined {
+		return "<undefined>"
+	}
+	return fmt.Sprint(v.V)
+}

vendor/github.com/mailru/easyjson/opt/gotemplate_Uint16.go

@@ -0,0 +1,79 @@
+// generated by gotemplate
+
+package opt
+
+import (
+	"fmt"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// template type Optional(A)
+
+// A 'gotemplate'-based type for providing optional semantics without using pointers.
+type Uint16 struct {
+	V       uint16
+	Defined bool
+}
+
+// Creates an optional type with a given value.
+func OUint16(v uint16) Uint16 {
+	return Uint16{V: v, Defined: true}
+}
+
+// Get returns the value or given default in the case the value is undefined.
+func (v Uint16) Get(deflt uint16) uint16 {
+	if !v.Defined {
+		return deflt
+	}
+	return v.V
+}
+
+// MarshalEasyJSON does JSON marshaling using easyjson interface.
+func (v Uint16) MarshalEasyJSON(w *jwriter.Writer) {
+	if v.Defined {
+		w.Uint16(v.V)
+	} else {
+		w.RawString("null")
+	}
+}
+
+// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface.
+func (v *Uint16) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	if l.IsNull() {
+		l.Skip()
+		*v = Uint16{}
+	} else {
+		v.V = l.Uint16()
+		v.Defined = true
+	}
+}
+
+// MarshalJSON implements a standard json marshaler interface.
+func (v *Uint16) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// UnmarshalJSON implements a standard json unmarshaler interface.
+func (v *Uint16) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// IsDefined returns whether the value is defined, a function is required so that it can
+// be used in an interface.
+func (v Uint16) IsDefined() bool {
+	return v.Defined
+}
+
+// String implements a stringer interface using fmt.Sprint for the value.
+func (v Uint16) String() string {
+	if !v.Defined {
+		return "<undefined>"
+	}
+	return fmt.Sprint(v.V)
+}

vendor/github.com/mailru/easyjson/opt/gotemplate_Uint32.go

@@ -0,0 +1,79 @@
+// generated by gotemplate
+
+package opt
+
+import (
+	"fmt"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// template type Optional(A)
+
+// A 'gotemplate'-based type for providing optional semantics without using pointers.
+type Uint32 struct {
+	V       uint32
+	Defined bool
+}
+
+// Creates an optional type with a given value.
+func OUint32(v uint32) Uint32 {
+	return Uint32{V: v, Defined: true}
+}
+
+// Get returns the value or given default in the case the value is undefined.
+func (v Uint32) Get(deflt uint32) uint32 {
+	if !v.Defined {
+		return deflt
+	}
+	return v.V
+}
+
+// MarshalEasyJSON does JSON marshaling using easyjson interface.
+func (v Uint32) MarshalEasyJSON(w *jwriter.Writer) {
+	if v.Defined {
+		w.Uint32(v.V)
+	} else {
+		w.RawString("null")
+	}
+}
+
+// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface.
+func (v *Uint32) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	if l.IsNull() {
+		l.Skip()
+		*v = Uint32{}
+	} else {
+		v.V = l.Uint32()
+		v.Defined = true
+	}
+}
+
+// MarshalJSON implements a standard json marshaler interface.
+func (v *Uint32) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// UnmarshalJSON implements a standard json unmarshaler interface.
+func (v *Uint32) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// IsDefined returns whether the value is defined, a function is required so that it can
+// be used in an interface.
+func (v Uint32) IsDefined() bool {
+	return v.Defined
+}
+
+// String implements a stringer interface using fmt.Sprint for the value.
+func (v Uint32) String() string {
+	if !v.Defined {
+		return "<undefined>"
+	}
+	return fmt.Sprint(v.V)
+}

vendor/github.com/mailru/easyjson/opt/gotemplate_Uint64.go

@@ -0,0 +1,79 @@
+// generated by gotemplate
+
+package opt
+
+import (
+	"fmt"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// template type Optional(A)
+
+// A 'gotemplate'-based type for providing optional semantics without using pointers.
+type Uint64 struct {
+	V       uint64
+	Defined bool
+}
+
+// Creates an optional type with a given value.
+func OUint64(v uint64) Uint64 {
+	return Uint64{V: v, Defined: true}
+}
+
+// Get returns the value or given default in the case the value is undefined.
+func (v Uint64) Get(deflt uint64) uint64 {
+	if !v.Defined {
+		return deflt
+	}
+	return v.V
+}
+
+// MarshalEasyJSON does JSON marshaling using easyjson interface.
+func (v Uint64) MarshalEasyJSON(w *jwriter.Writer) {
+	if v.Defined {
+		w.Uint64(v.V)
+	} else {
+		w.RawString("null")
+	}
+}
+
+// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface.
+func (v *Uint64) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	if l.IsNull() {
+		l.Skip()
+		*v = Uint64{}
+	} else {
+		v.V = l.Uint64()
+		v.Defined = true
+	}
+}
+
+// MarshalJSON implements a standard json marshaler interface.
+func (v *Uint64) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// UnmarshalJSON implements a standard json unmarshaler interface.
+func (v *Uint64) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// IsDefined returns whether the value is defined, a function is required so that it can
+// be used in an interface.
+func (v Uint64) IsDefined() bool {
+	return v.Defined
+}
+
+// String implements a stringer interface using fmt.Sprint for the value.
+func (v Uint64) String() string {
+	if !v.Defined {
+		return "<undefined>"
+	}
+	return fmt.Sprint(v.V)
+}

vendor/github.com/mailru/easyjson/opt/gotemplate_Uint8.go

@@ -0,0 +1,79 @@
+// generated by gotemplate
+
+package opt
+
+import (
+	"fmt"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// template type Optional(A)
+
+// A 'gotemplate'-based type for providing optional semantics without using pointers.
+type Uint8 struct {
+	V       uint8
+	Defined bool
+}
+
+// Creates an optional type with a given value.
+func OUint8(v uint8) Uint8 {
+	return Uint8{V: v, Defined: true}
+}
+
+// Get returns the value or given default in the case the value is undefined.
+func (v Uint8) Get(deflt uint8) uint8 {
+	if !v.Defined {
+		return deflt
+	}
+	return v.V
+}
+
+// MarshalEasyJSON does JSON marshaling using easyjson interface.
+func (v Uint8) MarshalEasyJSON(w *jwriter.Writer) {
+	if v.Defined {
+		w.Uint8(v.V)
+	} else {
+		w.RawString("null")
+	}
+}
+
+// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface.
+func (v *Uint8) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	if l.IsNull() {
+		l.Skip()
+		*v = Uint8{}
+	} else {
+		v.V = l.Uint8()
+		v.Defined = true
+	}
+}
+
+// MarshalJSON implements a standard json marshaler interface.
+func (v *Uint8) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// UnmarshalJSON implements a standard json unmarshaler interface.
+func (v *Uint8) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// IsDefined returns whether the value is defined, a function is required so that it can
+// be used in an interface.
+func (v Uint8) IsDefined() bool {
+	return v.Defined
+}
+
+// String implements a stringer interface using fmt.Sprint for the value.
+func (v Uint8) String() string {
+	if !v.Defined {
+		return "<undefined>"
+	}
+	return fmt.Sprint(v.V)
+}

vendor/github.com/mailru/easyjson/opt/optional/opt.go

@@ -0,0 +1,80 @@
+// +build none
+
+package optional
+
+import (
+	"fmt"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// template type Optional(A)
+type A int
+
+// A 'gotemplate'-based type for providing optional semantics without using pointers.
+type Optional struct {
+	V       A
+	Defined bool
+}
+
+// Creates an optional type with a given value.
+func OOptional(v A) Optional {
+	return Optional{V: v, Defined: true}
+}
+
+// Get returns the value or given default in the case the value is undefined.
+func (v Optional) Get(deflt A) A {
+	if !v.Defined {
+		return deflt
+	}
+	return v.V
+}
+
+// MarshalEasyJSON does JSON marshaling using easyjson interface.
+func (v Optional) MarshalEasyJSON(w *jwriter.Writer) {
+	if v.Defined {
+		w.Optional(v.V)
+	} else {
+		w.RawString("null")
+	}
+}
+
+// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface.
+func (v *Optional) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	if l.IsNull() {
+		l.Skip()
+		*v = Optional{}
+	} else {
+		v.V = l.Optional()
+		v.Defined = true
+	}
+}
+
+// MarshalJSON implements a standard json marshaler interface.
+func (v *Optional) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// UnmarshalJSON implements a standard json unmarshaler interface.
+func (v *Optional) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// IsDefined returns whether the value is defined, a function is required so that it can
+// be used in an interface.
+func (v Optional) IsDefined() bool {
+	return v.Defined
+}
+
+// String implements a stringer interface using fmt.Sprint for the value.
+func (v Optional) String() string {
+	if !v.Defined {
+		return "<undefined>"
+	}
+	return fmt.Sprint(v.V)
+}

vendor/github.com/mailru/easyjson/opt/opts.go

@@ -0,0 +1,22 @@
+package opt
+
+//go:generate sed -i "s/\\+build none/generated by gotemplate/" optional/opt.go
+//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Int(int)
+//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Uint(uint)
+
+//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Int8(int8)
+//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Int16(int16)
+//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Int32(int32)
+//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Int64(int64)
+
+//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Uint8(uint8)
+//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Uint16(uint16)
+//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Uint32(uint32)
+//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Uint64(uint64)
+
+//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Float32(float32)
+//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Float64(float64)
+
+//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Bool(bool)
+//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" String(string)
+//go:generate sed -i "s/generated by gotemplate/+build none/" optional/opt.go

vendor/github.com/mailru/easyjson/parser/parser.go

@@ -0,0 +1,97 @@
+package parser
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os/exec"
+	"strings"
+)
+
+const structComment = "easyjson:json"
+
+type Parser struct {
+	PkgPath     string
+	PkgName     string
+	StructNames []string
+	AllStructs  bool
+}
+
+type visitor struct {
+	*Parser
+
+	name     string
+	explicit bool
+}
+
+func (p *Parser) needType(comments string) bool {
+	for _, v := range strings.Split(comments, "\n") {
+		if strings.HasPrefix(v, structComment) {
+			return true
+		}
+	}
+	return false
+}
+
+func (v *visitor) Visit(n ast.Node) (w ast.Visitor) {
+	switch n := n.(type) {
+	case *ast.Package:
+		return v
+	case *ast.File:
+		v.PkgName = n.Name.String()
+		return v
+
+	case *ast.GenDecl:
+		v.explicit = v.needType(n.Doc.Text())
+
+		if !v.explicit && !v.AllStructs {
+			return nil
+		}
+		return v
+	case *ast.TypeSpec:
+		v.name = n.Name.String()
+
+		// Allow to specify non-structs explicitly independent of '-all' flag.
+		if v.explicit {
+			v.StructNames = append(v.StructNames, v.name)
+			return nil
+		}
+		return v
+	case *ast.StructType:
+		v.StructNames = append(v.StructNames, v.name)
+		return nil
+	}
+	return nil
+}
+
+func (p *Parser) Parse(fname string, isDir bool) error {
+	var err error
+	if p.PkgPath, err = getPkgPath(fname, isDir); err != nil {
+		return err
+	}
+
+	fset := token.NewFileSet()
+	if isDir {
+		packages, err := parser.ParseDir(fset, fname, nil, parser.ParseComments)
+		if err != nil {
+			return err
+		}
+
+		for _, pckg := range packages {
+			ast.Walk(&visitor{Parser: p}, pckg)
+		}
+	} else {
+		f, err := parser.ParseFile(fset, fname, nil, parser.ParseComments)
+		if err != nil {
+			return err
+		}
+
+		ast.Walk(&visitor{Parser: p}, f)
+	}
+	return nil
+}
+
+func getDefaultGoPath() (string, error) {
+	output, err := exec.Command("go", "env", "GOPATH").Output()
+	return string(output), err
+}

vendor/github.com/mailru/easyjson/parser/parser_unix.go

@@ -0,0 +1,42 @@
+// +build !windows
+
+package parser
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"strings"
+)
+
+func getPkgPath(fname string, isDir bool) (string, error) {
+	if !path.IsAbs(fname) {
+		pwd, err := os.Getwd()
+		if err != nil {
+			return "", err
+		}
+		fname = path.Join(pwd, fname)
+	}
+
+	gopath := os.Getenv("GOPATH")
+	if gopath == "" {
+		var err error
+		gopath, err = getDefaultGoPath()
+		if err != nil {
+			return "", fmt.Errorf("cannot determine GOPATH: %s", err)
+		}
+	}
+
+	for _, p := range strings.Split(os.Getenv("GOPATH"), ":") {
+		prefix := path.Join(p, "src") + "/"
+		if rel := strings.TrimPrefix(fname, prefix); rel != fname {
+			if !isDir {
+				return path.Dir(rel), nil
+			} else {
+				return path.Clean(rel), nil
+			}
+		}
+	}
+
+	return "", fmt.Errorf("file '%v' is not in GOPATH", fname)
+}

vendor/github.com/mailru/easyjson/parser/parser_windows.go

@@ -0,0 +1,49 @@
+package parser
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+)
+
+func normalizePath(path string) string {
+	// use lower case, as Windows file systems will almost always be case insensitive 
+	return strings.ToLower(strings.Replace(path, "\\", "/", -1))
+}
+
+func getPkgPath(fname string, isDir bool) (string, error) {
+	// path.IsAbs doesn't work properly on Windows; use filepath.IsAbs instead
+	if !filepath.IsAbs(fname) {
+		pwd, err := os.Getwd()
+		if err != nil {
+			return "", err
+		}
+		fname = path.Join(pwd, fname)
+	}
+
+	fname = normalizePath(fname)
+
+	gopath := os.Getenv("GOPATH")
+	if gopath == "" {
+		var err error
+		gopath, err = getDefaultGoPath()
+		if err != nil {
+			return "", fmt.Errorf("cannot determine GOPATH: %s", err)
+		}
+	}
+
+	for _, p := range strings.Split(os.Getenv("GOPATH"), ";") {
+		prefix := path.Join(normalizePath(p), "src") + "/"
+		if rel := strings.TrimPrefix(fname, prefix); rel != fname {
+			if !isDir {
+				return path.Dir(rel), nil
+			} else {
+				return path.Clean(rel), nil
+			}
+		}
+	}
+
+	return "", fmt.Errorf("file '%v' is not in GOPATH", fname)
+}

vendor/github.com/mailru/easyjson/tests/basic_test.go

@@ -0,0 +1,231 @@
+package tests
+
+import (
+	"reflect"
+	"testing"
+
+	"encoding/json"
+
+	"github.com/mailru/easyjson"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+type testType interface {
+	json.Marshaler
+	json.Unmarshaler
+}
+
+var testCases = []struct {
+	Decoded testType
+	Encoded string
+}{
+	{&primitiveTypesValue, primitiveTypesString},
+	{&namedPrimitiveTypesValue, namedPrimitiveTypesString},
+	{&structsValue, structsString},
+	{&omitEmptyValue, omitEmptyString},
+	{&snakeStructValue, snakeStructString},
+	{&omitEmptyDefaultValue, omitEmptyDefaultString},
+	{&optsValue, optsString},
+	{&rawValue, rawString},
+	{&stdMarshalerValue, stdMarshalerString},
+	{&userMarshalerValue, userMarshalerString},
+	{&unexportedStructValue, unexportedStructString},
+	{&excludedFieldValue, excludedFieldString},
+	{&sliceValue, sliceString},
+	{&arrayValue, arrayString},
+	{&mapsValue, mapsString},
+	{&deepNestValue, deepNestString},
+	{&IntsValue, IntsString},
+	{&mapStringStringValue, mapStringStringString},
+	{&namedTypeValue, namedTypeValueString},
+	{&mapMyIntStringValue, mapMyIntStringValueString},
+	{&mapIntStringValue, mapIntStringValueString},
+	{&mapInt32StringValue, mapInt32StringValueString},
+	{&mapInt64StringValue, mapInt64StringValueString},
+	{&mapUintStringValue, mapUintStringValueString},
+	{&mapUint32StringValue, mapUint32StringValueString},
+	{&mapUint64StringValue, mapUint64StringValueString},
+	{&mapUintptrStringValue, mapUintptrStringValueString},
+	{&intKeyedMapStructValue, intKeyedMapStructValueString},
+}
+
+func TestMarshal(t *testing.T) {
+	for i, test := range testCases {
+		data, err := test.Decoded.MarshalJSON()
+		if err != nil {
+			t.Errorf("[%d, %T] MarshalJSON() error: %v", i, test.Decoded, err)
+		}
+
+		got := string(data)
+		if got != test.Encoded {
+			t.Errorf("[%d, %T] MarshalJSON(): got \n%v\n\t\t want \n%v", i, test.Decoded, got, test.Encoded)
+		}
+	}
+}
+
+func TestUnmarshal(t *testing.T) {
+	for i, test := range testCases {
+		v1 := reflect.New(reflect.TypeOf(test.Decoded).Elem()).Interface()
+		v := v1.(testType)
+
+		err := v.UnmarshalJSON([]byte(test.Encoded))
+		if err != nil {
+			t.Errorf("[%d, %T] UnmarshalJSON() error: %v", i, test.Decoded, err)
+		}
+
+		if !reflect.DeepEqual(v, test.Decoded) {
+			t.Errorf("[%d, %T] UnmarshalJSON(): got \n%+v\n\t\t want \n%+v", i, test.Decoded, v, test.Decoded)
+		}
+	}
+}
+
+func TestRawMessageSTD(t *testing.T) {
+	type T struct {
+		F    easyjson.RawMessage
+		Fnil easyjson.RawMessage
+	}
+
+	val := T{F: easyjson.RawMessage([]byte(`"test"`))}
+	str := `{"F":"test","Fnil":null}`
+
+	data, err := json.Marshal(val)
+	if err != nil {
+		t.Errorf("json.Marshal() error: %v", err)
+	}
+	got := string(data)
+	if got != str {
+		t.Errorf("json.Marshal() = %v; want %v", got, str)
+	}
+
+	wantV := T{F: easyjson.RawMessage([]byte(`"test"`)), Fnil: easyjson.RawMessage([]byte("null"))}
+	var gotV T
+
+	err = json.Unmarshal([]byte(str), &gotV)
+	if err != nil {
+		t.Errorf("json.Unmarshal() error: %v", err)
+	}
+	if !reflect.DeepEqual(gotV, wantV) {
+		t.Errorf("json.Unmarshal() = %v; want %v", gotV, wantV)
+	}
+}
+
+func TestParseNull(t *testing.T) {
+	var got, want SubStruct
+	if err := easyjson.Unmarshal([]byte("null"), &got); err != nil {
+		t.Errorf("Unmarshal() error: %v", err)
+	}
+
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("Unmarshal() = %+v; want %+v", got, want)
+	}
+}
+
+var testSpecialCases = []struct {
+	EncodedString string
+	Value         string
+}{
+	{`"Username \u003cuser@example.com\u003e"`, `Username <user@example.com>`},
+	{`"Username\ufffd"`, "Username\xc5"},
+	{`"тестzтест"`, "тестzтест"},
+	{`"тест\ufffdтест"`, "тест\xc5тест"},
+	{`"绿茶"`, "绿茶"},
+	{`"绿\ufffd茶"`, "绿\xc5茶"},
+	{`"тест\u2028"`, "тест\xE2\x80\xA8"},
+	{`"\\\r\n\t\""`, "\\\r\n\t\""},
+	{`"ü"`, "ü"},
+}
+
+func TestSpecialCases(t *testing.T) {
+	for i, test := range testSpecialCases {
+		w := jwriter.Writer{}
+		w.String(test.Value)
+		got := string(w.Buffer.BuildBytes())
+		if got != test.EncodedString {
+			t.Errorf("[%d] Encoded() = %+v; want %+v", i, got, test.EncodedString)
+		}
+	}
+}
+
+func TestOverflowArray(t *testing.T) {
+	var a Arrays
+	err := easyjson.Unmarshal([]byte(arrayOverflowString), &a)
+	if err != nil {
+		t.Error(err)
+	}
+	if a != arrayValue {
+		t.Errorf("Unmarshal(%v) = %+v; want %+v", arrayOverflowString, a, arrayValue)
+	}
+}
+
+func TestUnderflowArray(t *testing.T) {
+	var a Arrays
+	err := easyjson.Unmarshal([]byte(arrayUnderflowString), &a)
+	if err != nil {
+		t.Error(err)
+	}
+	if a != arrayUnderflowValue {
+		t.Errorf("Unmarshal(%v) = %+v; want %+v", arrayUnderflowString, a, arrayUnderflowValue)
+	}
+}
+
+func TestEncodingFlags(t *testing.T) {
+	for i, test := range []struct {
+		Flags jwriter.Flags
+		In    easyjson.Marshaler
+		Want  string
+	}{
+		{0, EncodingFlagsTestMap{}, `{"F":null}`},
+		{0, EncodingFlagsTestSlice{}, `{"F":null}`},
+		{jwriter.NilMapAsEmpty, EncodingFlagsTestMap{}, `{"F":{}}`},
+		{jwriter.NilSliceAsEmpty, EncodingFlagsTestSlice{}, `{"F":[]}`},
+	} {
+		w := &jwriter.Writer{Flags: test.Flags}
+		test.In.MarshalEasyJSON(w)
+
+		data, err := w.BuildBytes()
+		if err != nil {
+			t.Errorf("[%v] easyjson.Marshal(%+v) error: %v", i, test.In, err)
+		}
+
+		v := string(data)
+		if v != test.Want {
+			t.Errorf("[%v] easyjson.Marshal(%+v) = %v; want %v", i, test.In, v, test.Want)
+		}
+	}
+
+}
+
+func TestNestedEasyJsonMarshal(t *testing.T) {
+	n := map[string]*NestedEasyMarshaler{
+		"Value":  {},
+		"Slice1": {},
+		"Slice2": {},
+		"Map1":   {},
+		"Map2":   {},
+	}
+
+	ni := NestedInterfaces{
+		Value: n["Value"],
+		Slice: []interface{}{n["Slice1"], n["Slice2"]},
+		Map:   map[string]interface{}{"1": n["Map1"], "2": n["Map2"]},
+	}
+	easyjson.Marshal(ni)
+
+	for k, v := range n {
+		if !v.EasilyMarshaled {
+			t.Errorf("Nested interface %s wasn't easily marshaled", k)
+		}
+	}
+}
+
+func TestUnmarshalStructWithEmbeddedPtrStruct(t *testing.T) {
+	var s = StructWithInterface{Field2: &EmbeddedStruct{}}
+	var err error
+	err = easyjson.Unmarshal([]byte(structWithInterfaceString), &s)
+	if err != nil {
+		t.Errorf("easyjson.Unmarshal() error: %v", err)
+	}
+	if !reflect.DeepEqual(s, structWithInterfaceValueFilled) {
+		t.Errorf("easyjson.Unmarshal() = %#v; want %#v", s, structWithInterfaceValueFilled)
+	}
+}

vendor/github.com/mailru/easyjson/tests/data.go

@@ -0,0 +1,759 @@
+package tests
+
+import (
+	"fmt"
+	"math"
+	"net"
+	"time"
+
+	"github.com/mailru/easyjson"
+	"github.com/mailru/easyjson/opt"
+)
+
+type PrimitiveTypes struct {
+	String string
+	Bool   bool
+
+	Int   int
+	Int8  int8
+	Int16 int16
+	Int32 int32
+	Int64 int64
+
+	Uint   uint
+	Uint8  uint8
+	Uint16 uint16
+	Uint32 uint32
+	Uint64 uint64
+
+	IntString   int   `json:",string"`
+	Int8String  int8  `json:",string"`
+	Int16String int16 `json:",string"`
+	Int32String int32 `json:",string"`
+	Int64String int64 `json:",string"`
+
+	UintString   uint   `json:",string"`
+	Uint8String  uint8  `json:",string"`
+	Uint16String uint16 `json:",string"`
+	Uint32String uint32 `json:",string"`
+	Uint64String uint64 `json:",string"`
+
+	Float32 float32
+	Float64 float64
+
+	Ptr    *string
+	PtrNil *string
+}
+
+var str = "bla"
+
+var primitiveTypesValue = PrimitiveTypes{
+	String: "test", Bool: true,
+
+	Int:   math.MinInt32,
+	Int8:  math.MinInt8,
+	Int16: math.MinInt16,
+	Int32: math.MinInt32,
+	Int64: math.MinInt64,
+
+	Uint:   math.MaxUint32,
+	Uint8:  math.MaxUint8,
+	Uint16: math.MaxUint16,
+	Uint32: math.MaxUint32,
+	Uint64: math.MaxUint64,
+
+	IntString:   math.MinInt32,
+	Int8String:  math.MinInt8,
+	Int16String: math.MinInt16,
+	Int32String: math.MinInt32,
+	Int64String: math.MinInt64,
+
+	UintString:   math.MaxUint32,
+	Uint8String:  math.MaxUint8,
+	Uint16String: math.MaxUint16,
+	Uint32String: math.MaxUint32,
+	Uint64String: math.MaxUint64,
+
+	Float32: 1.5,
+	Float64: math.MaxFloat64,
+
+	Ptr: &str,
+}
+
+var primitiveTypesString = "{" +
+	`"String":"test","Bool":true,` +
+
+	`"Int":` + fmt.Sprint(math.MinInt32) + `,` +
+	`"Int8":` + fmt.Sprint(math.MinInt8) + `,` +
+	`"Int16":` + fmt.Sprint(math.MinInt16) + `,` +
+	`"Int32":` + fmt.Sprint(math.MinInt32) + `,` +
+	`"Int64":` + fmt.Sprint(int64(math.MinInt64)) + `,` +
+
+	`"Uint":` + fmt.Sprint(uint32(math.MaxUint32)) + `,` +
+	`"Uint8":` + fmt.Sprint(math.MaxUint8) + `,` +
+	`"Uint16":` + fmt.Sprint(math.MaxUint16) + `,` +
+	`"Uint32":` + fmt.Sprint(uint32(math.MaxUint32)) + `,` +
+	`"Uint64":` + fmt.Sprint(uint64(math.MaxUint64)) + `,` +
+
+	`"IntString":"` + fmt.Sprint(math.MinInt32) + `",` +
+	`"Int8String":"` + fmt.Sprint(math.MinInt8) + `",` +
+	`"Int16String":"` + fmt.Sprint(math.MinInt16) + `",` +
+	`"Int32String":"` + fmt.Sprint(math.MinInt32) + `",` +
+	`"Int64String":"` + fmt.Sprint(int64(math.MinInt64)) + `",` +
+
+	`"UintString":"` + fmt.Sprint(uint32(math.MaxUint32)) + `",` +
+	`"Uint8String":"` + fmt.Sprint(math.MaxUint8) + `",` +
+	`"Uint16String":"` + fmt.Sprint(math.MaxUint16) + `",` +
+	`"Uint32String":"` + fmt.Sprint(uint32(math.MaxUint32)) + `",` +
+	`"Uint64String":"` + fmt.Sprint(uint64(math.MaxUint64)) + `",` +
+
+	`"Float32":` + fmt.Sprint(1.5) + `,` +
+	`"Float64":` + fmt.Sprint(math.MaxFloat64) + `,` +
+
+	`"Ptr":"bla",` +
+	`"PtrNil":null` +
+
+	"}"
+
+type (
+	NamedString string
+	NamedBool   bool
+
+	NamedInt   int
+	NamedInt8  int8
+	NamedInt16 int16
+	NamedInt32 int32
+	NamedInt64 int64
+
+	NamedUint   uint
+	NamedUint8  uint8
+	NamedUint16 uint16
+	NamedUint32 uint32
+	NamedUint64 uint64
+
+	NamedFloat32 float32
+	NamedFloat64 float64
+
+	NamedStrPtr *string
+)
+
+type NamedPrimitiveTypes struct {
+	String NamedString
+	Bool   NamedBool
+
+	Int   NamedInt
+	Int8  NamedInt8
+	Int16 NamedInt16
+	Int32 NamedInt32
+	Int64 NamedInt64
+
+	Uint   NamedUint
+	Uint8  NamedUint8
+	Uint16 NamedUint16
+	Uint32 NamedUint32
+	Uint64 NamedUint64
+
+	Float32 NamedFloat32
+	Float64 NamedFloat64
+
+	Ptr    NamedStrPtr
+	PtrNil NamedStrPtr
+}
+
+var namedPrimitiveTypesValue = NamedPrimitiveTypes{
+	String: "test",
+	Bool:   true,
+
+	Int:   math.MinInt32,
+	Int8:  math.MinInt8,
+	Int16: math.MinInt16,
+	Int32: math.MinInt32,
+	Int64: math.MinInt64,
+
+	Uint:   math.MaxUint32,
+	Uint8:  math.MaxUint8,
+	Uint16: math.MaxUint16,
+	Uint32: math.MaxUint32,
+	Uint64: math.MaxUint64,
+
+	Float32: 1.5,
+	Float64: math.MaxFloat64,
+
+	Ptr: NamedStrPtr(&str),
+}
+
+var namedPrimitiveTypesString = "{" +
+	`"String":"test",` +
+	`"Bool":true,` +
+
+	`"Int":` + fmt.Sprint(math.MinInt32) + `,` +
+	`"Int8":` + fmt.Sprint(math.MinInt8) + `,` +
+	`"Int16":` + fmt.Sprint(math.MinInt16) + `,` +
+	`"Int32":` + fmt.Sprint(math.MinInt32) + `,` +
+	`"Int64":` + fmt.Sprint(int64(math.MinInt64)) + `,` +
+
+	`"Uint":` + fmt.Sprint(uint32(math.MaxUint32)) + `,` +
+	`"Uint8":` + fmt.Sprint(math.MaxUint8) + `,` +
+	`"Uint16":` + fmt.Sprint(math.MaxUint16) + `,` +
+	`"Uint32":` + fmt.Sprint(uint32(math.MaxUint32)) + `,` +
+	`"Uint64":` + fmt.Sprint(uint64(math.MaxUint64)) + `,` +
+
+	`"Float32":` + fmt.Sprint(1.5) + `,` +
+	`"Float64":` + fmt.Sprint(math.MaxFloat64) + `,` +
+
+	`"Ptr":"bla",` +
+	`"PtrNil":null` +
+	"}"
+
+type SubStruct struct {
+	Value     string
+	Value2    string
+	unexpored bool
+}
+
+type SubP struct {
+	V string
+}
+
+type SubStructAlias SubStruct
+
+type Structs struct {
+	SubStruct
+	*SubP
+
+	Value2 int
+
+	Sub1   SubStruct `json:"substruct"`
+	Sub2   *SubStruct
+	SubNil *SubStruct
+
+	SubSlice    []SubStruct
+	SubSliceNil []SubStruct
+
+	SubPtrSlice    []*SubStruct
+	SubPtrSliceNil []*SubStruct
+
+	SubA1 SubStructAlias
+	SubA2 *SubStructAlias
+
+	Anonymous struct {
+		V string
+		I int
+	}
+	Anonymous1 *struct {
+		V string
+	}
+
+	AnonymousSlice    []struct{ V int }
+	AnonymousPtrSlice []*struct{ V int }
+
+	Slice []string
+
+	unexported bool
+}
+
+var structsValue = Structs{
+	SubStruct: SubStruct{Value: "test"},
+	SubP:      &SubP{V: "subp"},
+
+	Value2: 5,
+
+	Sub1: SubStruct{Value: "test1", Value2: "v"},
+	Sub2: &SubStruct{Value: "test2", Value2: "v2"},
+
+	SubSlice: []SubStruct{
+		{Value: "s1"},
+		{Value: "s2"},
+	},
+
+	SubPtrSlice: []*SubStruct{
+		{Value: "p1"},
+		{Value: "p2"},
+	},
+
+	SubA1: SubStructAlias{Value: "test3", Value2: "v3"},
+	SubA2: &SubStructAlias{Value: "test4", Value2: "v4"},
+
+	Anonymous: struct {
+		V string
+		I int
+	}{V: "bla", I: 5},
+
+	Anonymous1: &struct {
+		V string
+	}{V: "bla1"},
+
+	AnonymousSlice:    []struct{ V int }{{1}, {2}},
+	AnonymousPtrSlice: []*struct{ V int }{{3}, {4}},
+
+	Slice: []string{"test5", "test6"},
+}
+
+var structsString = "{" +
+	`"Value2":5,` +
+
+	`"substruct":{"Value":"test1","Value2":"v"},` +
+	`"Sub2":{"Value":"test2","Value2":"v2"},` +
+	`"SubNil":null,` +
+
+	`"SubSlice":[{"Value":"s1","Value2":""},{"Value":"s2","Value2":""}],` +
+	`"SubSliceNil":null,` +
+
+	`"SubPtrSlice":[{"Value":"p1","Value2":""},{"Value":"p2","Value2":""}],` +
+	`"SubPtrSliceNil":null,` +
+
+	`"SubA1":{"Value":"test3","Value2":"v3"},` +
+	`"SubA2":{"Value":"test4","Value2":"v4"},` +
+
+	`"Anonymous":{"V":"bla","I":5},` +
+	`"Anonymous1":{"V":"bla1"},` +
+
+	`"AnonymousSlice":[{"V":1},{"V":2}],` +
+	`"AnonymousPtrSlice":[{"V":3},{"V":4}],` +
+
+	`"Slice":["test5","test6"],` +
+
+	// Embedded fields go last.
+	`"V":"subp",` +
+	`"Value":"test"` +
+	"}"
+
+type OmitEmpty struct {
+	// NOTE: first field is empty to test comma printing.
+
+	StrE, StrNE string  `json:",omitempty"`
+	PtrE, PtrNE *string `json:",omitempty"`
+
+	IntNE int `json:"intField,omitempty"`
+	IntE  int `json:",omitempty"`
+
+	// NOTE: omitempty has no effect on non-pointer struct fields.
+	SubE, SubNE   SubStruct  `json:",omitempty"`
+	SubPE, SubPNE *SubStruct `json:",omitempty"`
+}
+
+var omitEmptyValue = OmitEmpty{
+	StrNE:  "str",
+	PtrNE:  &str,
+	IntNE:  6,
+	SubNE:  SubStruct{Value: "1", Value2: "2"},
+	SubPNE: &SubStruct{Value: "3", Value2: "4"},
+}
+
+var omitEmptyString = "{" +
+	`"StrNE":"str",` +
+	`"PtrNE":"bla",` +
+	`"intField":6,` +
+	`"SubE":{"Value":"","Value2":""},` +
+	`"SubNE":{"Value":"1","Value2":"2"},` +
+	`"SubPNE":{"Value":"3","Value2":"4"}` +
+	"}"
+
+type Opts struct {
+	StrNull      opt.String
+	StrEmpty     opt.String
+	Str          opt.String
+	StrOmitempty opt.String `json:",omitempty"`
+
+	IntNull opt.Int
+	IntZero opt.Int
+	Int     opt.Int
+}
+
+var optsValue = Opts{
+	StrEmpty: opt.OString(""),
+	Str:      opt.OString("test"),
+
+	IntZero: opt.OInt(0),
+	Int:     opt.OInt(5),
+}
+
+var optsString = `{` +
+	`"StrNull":null,` +
+	`"StrEmpty":"",` +
+	`"Str":"test",` +
+	`"IntNull":null,` +
+	`"IntZero":0,` +
+	`"Int":5` +
+	`}`
+
+type Raw struct {
+	Field  easyjson.RawMessage
+	Field2 string
+}
+
+var rawValue = Raw{
+	Field:  []byte(`{"a" : "b"}`),
+	Field2: "test",
+}
+
+var rawString = `{` +
+	`"Field":{"a" : "b"},` +
+	`"Field2":"test"` +
+	`}`
+
+type StdMarshaler struct {
+	T  time.Time
+	IP net.IP
+}
+
+var stdMarshalerValue = StdMarshaler{
+	T:  time.Date(2016, 01, 02, 14, 15, 10, 0, time.UTC),
+	IP: net.IPv4(192, 168, 0, 1),
+}
+var stdMarshalerString = `{` +
+	`"T":"2016-01-02T14:15:10Z",` +
+	`"IP":"192.168.0.1"` +
+	`}`
+
+type UserMarshaler struct {
+	V vMarshaler
+	T tMarshaler
+}
+
+type vMarshaler net.IP
+
+func (v vMarshaler) MarshalJSON() ([]byte, error) {
+	return []byte(`"0::0"`), nil
+}
+
+func (v *vMarshaler) UnmarshalJSON([]byte) error {
+	*v = vMarshaler(net.IPv6zero)
+	return nil
+}
+
+type tMarshaler net.IP
+
+func (v tMarshaler) MarshalText() ([]byte, error) {
+	return []byte(`[0::0]`), nil
+}
+
+func (v *tMarshaler) UnmarshalText([]byte) error {
+	*v = tMarshaler(net.IPv6zero)
+	return nil
+}
+
+var userMarshalerValue = UserMarshaler{
+	V: vMarshaler(net.IPv6zero),
+	T: tMarshaler(net.IPv6zero),
+}
+var userMarshalerString = `{` +
+	`"V":"0::0",` +
+	`"T":"[0::0]"` +
+	`}`
+
+type unexportedStruct struct {
+	Value string
+}
+
+var unexportedStructValue = unexportedStruct{"test"}
+var unexportedStructString = `{"Value":"test"}`
+
+type ExcludedField struct {
+	Process       bool `json:"process"`
+	DoNotProcess  bool `json:"-"`
+	DoNotProcess1 bool `json:"-"`
+}
+
+var excludedFieldValue = ExcludedField{
+	Process:       true,
+	DoNotProcess:  false,
+	DoNotProcess1: false,
+}
+var excludedFieldString = `{"process":true}`
+
+type Slices struct {
+	ByteSlice      []byte
+	EmptyByteSlice []byte
+	NilByteSlice   []byte
+	IntSlice       []int
+	EmptyIntSlice  []int
+	NilIntSlice    []int
+}
+
+var sliceValue = Slices{
+	ByteSlice:      []byte("abc"),
+	EmptyByteSlice: []byte{},
+	NilByteSlice:   []byte(nil),
+	IntSlice:       []int{1, 2, 3, 4, 5},
+	EmptyIntSlice:  []int{},
+	NilIntSlice:    []int(nil),
+}
+
+var sliceString = `{` +
+	`"ByteSlice":"YWJj",` +
+	`"EmptyByteSlice":"",` +
+	`"NilByteSlice":null,` +
+	`"IntSlice":[1,2,3,4,5],` +
+	`"EmptyIntSlice":[],` +
+	`"NilIntSlice":null` +
+	`}`
+
+type Arrays struct {
+	ByteArray      [3]byte
+	EmptyByteArray [0]byte
+	IntArray       [5]int
+	EmptyIntArray  [0]int
+}
+
+var arrayValue = Arrays{
+	ByteArray:      [3]byte{'a', 'b', 'c'},
+	EmptyByteArray: [0]byte{},
+	IntArray:       [5]int{1, 2, 3, 4, 5},
+	EmptyIntArray:  [0]int{},
+}
+
+var arrayString = `{` +
+	`"ByteArray":"YWJj",` +
+	`"EmptyByteArray":"",` +
+	`"IntArray":[1,2,3,4,5],` +
+	`"EmptyIntArray":[]` +
+	`}`
+
+var arrayOverflowString = `{` +
+	`"ByteArray":"YWJjbnNk",` +
+	`"EmptyByteArray":"YWJj",` +
+	`"IntArray":[1,2,3,4,5,6],` +
+	`"EmptyIntArray":[7,8]` +
+	`}`
+
+var arrayUnderflowValue = Arrays{
+	ByteArray:      [3]byte{'x', 0, 0},
+	EmptyByteArray: [0]byte{},
+	IntArray:       [5]int{1, 2, 0, 0, 0},
+	EmptyIntArray:  [0]int{},
+}
+
+var arrayUnderflowString = `{` +
+	`"ByteArray":"eA==",` +
+	`"IntArray":[1,2]` +
+	`}`
+
+type Str string
+
+type Maps struct {
+	Map          map[string]string
+	InterfaceMap map[string]interface{}
+	NilMap       map[string]string
+
+	CustomMap map[Str]Str
+}
+
+var mapsValue = Maps{
+	Map:          map[string]string{"A": "b"}, // only one item since map iteration is randomized
+	InterfaceMap: map[string]interface{}{"G": float64(1)},
+
+	CustomMap: map[Str]Str{"c": "d"},
+}
+
+var mapsString = `{` +
+	`"Map":{"A":"b"},` +
+	`"InterfaceMap":{"G":1},` +
+	`"NilMap":null,` +
+	`"CustomMap":{"c":"d"}` +
+	`}`
+
+type NamedSlice []Str
+type NamedMap map[Str]Str
+
+type DeepNest struct {
+	SliceMap         map[Str][]Str
+	SliceMap1        map[Str][]Str
+	SliceMap2        map[Str][]Str
+	NamedSliceMap    map[Str]NamedSlice
+	NamedMapMap      map[Str]NamedMap
+	MapSlice         []map[Str]Str
+	NamedSliceSlice  []NamedSlice
+	NamedMapSlice    []NamedMap
+	NamedStringSlice []NamedString
+}
+
+var deepNestValue = DeepNest{
+	SliceMap: map[Str][]Str{
+		"testSliceMap": []Str{
+			"0",
+			"1",
+		},
+	},
+	SliceMap1: map[Str][]Str{
+		"testSliceMap1": []Str(nil),
+	},
+	SliceMap2: map[Str][]Str{
+		"testSliceMap2": []Str{},
+	},
+	NamedSliceMap: map[Str]NamedSlice{
+		"testNamedSliceMap": NamedSlice{
+			"2",
+			"3",
+		},
+	},
+	NamedMapMap: map[Str]NamedMap{
+		"testNamedMapMap": NamedMap{
+			"key1": "value1",
+		},
+	},
+	MapSlice: []map[Str]Str{
+		map[Str]Str{
+			"testMapSlice": "someValue",
+		},
+	},
+	NamedSliceSlice: []NamedSlice{
+		NamedSlice{
+			"someValue1",
+			"someValue2",
+		},
+		NamedSlice{
+			"someValue3",
+			"someValue4",
+		},
+	},
+	NamedMapSlice: []NamedMap{
+		NamedMap{
+			"key2": "value2",
+		},
+		NamedMap{
+			"key3": "value3",
+		},
+	},
+	NamedStringSlice: []NamedString{
+		"value4", "value5",
+	},
+}
+
+var deepNestString = `{` +
+	`"SliceMap":{` +
+	`"testSliceMap":["0","1"]` +
+	`},` +
+	`"SliceMap1":{` +
+	`"testSliceMap1":null` +
+	`},` +
+	`"SliceMap2":{` +
+	`"testSliceMap2":[]` +
+	`},` +
+	`"NamedSliceMap":{` +
+	`"testNamedSliceMap":["2","3"]` +
+	`},` +
+	`"NamedMapMap":{` +
+	`"testNamedMapMap":{"key1":"value1"}` +
+	`},` +
+	`"MapSlice":[` +
+	`{"testMapSlice":"someValue"}` +
+	`],` +
+	`"NamedSliceSlice":[` +
+	`["someValue1","someValue2"],` +
+	`["someValue3","someValue4"]` +
+	`],` +
+	`"NamedMapSlice":[` +
+	`{"key2":"value2"},` +
+	`{"key3":"value3"}` +
+	`],` +
+	`"NamedStringSlice":["value4","value5"]` +
+	`}`
+
+//easyjson:json
+type Ints []int
+
+var IntsValue = Ints{1, 2, 3, 4, 5}
+
+var IntsString = `[1,2,3,4,5]`
+
+//easyjson:json
+type MapStringString map[string]string
+
+var mapStringStringValue = MapStringString{"a": "b"}
+
+var mapStringStringString = `{"a":"b"}`
+
+type RequiredOptionalStruct struct {
+	FirstName string `json:"first_name,required"`
+	Lastname  string `json:"last_name"`
+}
+
+//easyjson:json
+type EncodingFlagsTestMap struct {
+	F map[string]string
+}
+
+//easyjson:json
+type EncodingFlagsTestSlice struct {
+	F []string
+}
+
+type StructWithInterface struct {
+	Field1 int         `json:"f1"`
+	Field2 interface{} `json:"f2"`
+	Field3 string      `json:"f3"`
+}
+
+type EmbeddedStruct struct {
+	Field1 int    `json:"f1"`
+	Field2 string `json:"f2"`
+}
+
+var structWithInterfaceString = `{"f1":1,"f2":{"f1":11,"f2":"22"},"f3":"3"}`
+var structWithInterfaceValueFilled = StructWithInterface{1, &EmbeddedStruct{11, "22"}, "3"}
+
+//easyjson:json
+type MapIntString map[int]string
+
+var mapIntStringValue = MapIntString{3: "hi"}
+var mapIntStringValueString = `{"3":"hi"}`
+
+//easyjson:json
+type MapInt32String map[int32]string
+
+var mapInt32StringValue = MapInt32String{-354634382: "life"}
+var mapInt32StringValueString = `{"-354634382":"life"}`
+
+//easyjson:json
+type MapInt64String map[int64]string
+
+var mapInt64StringValue = MapInt64String{-3546343826724305832: "life"}
+var mapInt64StringValueString = `{"-3546343826724305832":"life"}`
+
+//easyjson:json
+type MapUintString map[uint]string
+
+var mapUintStringValue = MapUintString{42: "life"}
+var mapUintStringValueString = `{"42":"life"}`
+
+//easyjson:json
+type MapUint32String map[uint32]string
+
+var mapUint32StringValue = MapUint32String{354634382: "life"}
+var mapUint32StringValueString = `{"354634382":"life"}`
+
+//easyjson:json
+type MapUint64String map[uint64]string
+
+var mapUint64StringValue = MapUint64String{3546343826724305832: "life"}
+var mapUint64StringValueString = `{"3546343826724305832":"life"}`
+
+//easyjson:json
+type MapUintptrString map[uintptr]string
+
+var mapUintptrStringValue = MapUintptrString{272679208: "obj"}
+var mapUintptrStringValueString = `{"272679208":"obj"}`
+
+type MyInt int
+
+//easyjson:json
+type MapMyIntString map[MyInt]string
+
+var mapMyIntStringValue = MapMyIntString{MyInt(42): "life"}
+var mapMyIntStringValueString = `{"42":"life"}`
+
+//easyjson:json
+type IntKeyedMapStruct struct {
+	Foo MapMyIntString            `json:"foo"`
+	Bar map[int16]MapUint32String `json:"bar"`
+}
+
+var intKeyedMapStructValue = IntKeyedMapStruct{
+	Foo: mapMyIntStringValue,
+	Bar: map[int16]MapUint32String{32: mapUint32StringValue},
+}
+var intKeyedMapStructValueString = `{` +
+	`"foo":{"42":"life"},` +
+	`"bar":{"32":{"354634382":"life"}}` +
+	`}`

vendor/github.com/mailru/easyjson/tests/errors.go

@@ -0,0 +1,26 @@
+package tests
+
+//easyjson:json
+type ErrorIntSlice []int
+
+//easyjson:json
+type ErrorBoolSlice []bool
+
+//easyjson:json
+type ErrorUintSlice []uint
+
+//easyjson:json
+type ErrorStruct struct {
+	Int      int    `json:"int"`
+	String   string `json:"string"`
+	Slice    []int  `json:"slice"`
+	IntSlice []int  `json:"int_slice"`
+}
+
+type ErrorNestedStruct struct {
+	ErrorStruct ErrorStruct `json:"error_struct"`
+	Int         int         `json:"int"`
+}
+
+//easyjson:json
+type ErrorIntMap map[uint32]string

vendor/github.com/mailru/easyjson/tests/errors_test.go

@@ -0,0 +1,285 @@
+package tests
+
+import (
+	"testing"
+
+	"github.com/mailru/easyjson/jlexer"
+)
+
+func TestMultipleErrorsInt(t *testing.T) {
+	for i, test := range []struct {
+		Data    []byte
+		Offsets []int
+	}{
+		{
+			Data:    []byte(`[1, 2, 3, "4", "5"]`),
+			Offsets: []int{10, 15},
+		},
+		{
+			Data:    []byte(`[1, {"2":"3"}, 3, "4"]`),
+			Offsets: []int{4, 18},
+		},
+		{
+			Data:    []byte(`[1, "2", "3", "4", "5", "6"]`),
+			Offsets: []int{4, 9, 14, 19, 24},
+		},
+		{
+			Data:    []byte(`[1, 2, 3, 4, "5"]`),
+			Offsets: []int{13},
+		},
+		{
+			Data:    []byte(`[{"1": "2"}]`),
+			Offsets: []int{1},
+		},
+	} {
+		l := jlexer.Lexer{
+			Data:              test.Data,
+			UseMultipleErrors: true,
+		}
+
+		var v ErrorIntSlice
+
+		v.UnmarshalEasyJSON(&l)
+
+		errors := l.GetNonFatalErrors()
+
+		if len(errors) != len(test.Offsets) {
+			t.Errorf("[%d] TestMultipleErrorsInt(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
+			return
+		}
+
+		for ii, e := range errors {
+			if e.Offset != test.Offsets[ii] {
+				t.Errorf("[%d] TestMultipleErrorsInt(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
+			}
+		}
+	}
+}
+
+func TestMultipleErrorsBool(t *testing.T) {
+	for i, test := range []struct {
+		Data    []byte
+		Offsets []int
+	}{
+		{
+			Data: []byte(`[true, false, true, false]`),
+		},
+		{
+			Data:    []byte(`["test", "value", "lol", "1"]`),
+			Offsets: []int{1, 9, 18, 25},
+		},
+		{
+			Data:    []byte(`[true, 42, {"a":"b", "c":"d"}, false]`),
+			Offsets: []int{7, 11},
+		},
+	} {
+		l := jlexer.Lexer{
+			Data:              test.Data,
+			UseMultipleErrors: true,
+		}
+
+		var v ErrorBoolSlice
+		v.UnmarshalEasyJSON(&l)
+
+		errors := l.GetNonFatalErrors()
+
+		if len(errors) != len(test.Offsets) {
+			t.Errorf("[%d] TestMultipleErrorsBool(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
+			return
+		}
+		for ii, e := range errors {
+			if e.Offset != test.Offsets[ii] {
+				t.Errorf("[%d] TestMultipleErrorsBool(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
+			}
+		}
+	}
+}
+
+func TestMultipleErrorsUint(t *testing.T) {
+	for i, test := range []struct {
+		Data    []byte
+		Offsets []int
+	}{
+		{
+			Data: []byte(`[42, 42, 42]`),
+		},
+		{
+			Data:    []byte(`[17, "42", 32]`),
+			Offsets: []int{5},
+		},
+		{
+			Data:    []byte(`["zz", "zz"]`),
+			Offsets: []int{1, 7},
+		},
+		{
+			Data:    []byte(`[{}, 42]`),
+			Offsets: []int{1},
+		},
+	} {
+		l := jlexer.Lexer{
+			Data:              test.Data,
+			UseMultipleErrors: true,
+		}
+
+		var v ErrorUintSlice
+		v.UnmarshalEasyJSON(&l)
+
+		errors := l.GetNonFatalErrors()
+
+		if len(errors) != len(test.Offsets) {
+			t.Errorf("[%d] TestMultipleErrorsUint(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
+			return
+		}
+		for ii, e := range errors {
+			if e.Offset != test.Offsets[ii] {
+				t.Errorf("[%d] TestMultipleErrorsUint(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
+			}
+		}
+	}
+}
+
+func TestMultipleErrorsStruct(t *testing.T) {
+	for i, test := range []struct {
+		Data    []byte
+		Offsets []int
+	}{
+		{
+			Data: []byte(`{"string": "test", "slice":[42, 42, 42], "int_slice":[1, 2, 3]}`),
+		},
+		{
+			Data:    []byte(`{"string": {"test": "test"}, "slice":[42, 42, 42], "int_slice":["1", 2, 3]}`),
+			Offsets: []int{11, 64},
+		},
+		{
+			Data:    []byte(`{"slice": [42, 42], "string": {"test": "test"}, "int_slice":["1", "2", 3]}`),
+			Offsets: []int{30, 61, 66},
+		},
+		{
+			Data:    []byte(`{"string": "test", "slice": {}}`),
+			Offsets: []int{28},
+		},
+		{
+			Data:    []byte(`{"slice":5, "string" : "test"}`),
+			Offsets: []int{9},
+		},
+		{
+			Data:    []byte(`{"slice" : "test", "string" : "test"}`),
+			Offsets: []int{11},
+		},
+		{
+			Data:    []byte(`{"slice": "", "string" : {}, "int":{}}`),
+			Offsets: []int{10, 25, 35},
+		},
+	} {
+		l := jlexer.Lexer{
+			Data:              test.Data,
+			UseMultipleErrors: true,
+		}
+		var v ErrorStruct
+		v.UnmarshalEasyJSON(&l)
+
+		errors := l.GetNonFatalErrors()
+
+		if len(errors) != len(test.Offsets) {
+			t.Errorf("[%d] TestMultipleErrorsStruct(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
+			return
+		}
+		for ii, e := range errors {
+			if e.Offset != test.Offsets[ii] {
+				t.Errorf("[%d] TestMultipleErrorsStruct(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
+			}
+		}
+	}
+}
+
+func TestMultipleErrorsNestedStruct(t *testing.T) {
+	for i, test := range []struct {
+		Data    []byte
+		Offsets []int
+	}{
+		{
+			Data: []byte(`{"error_struct":{}}`),
+		},
+		{
+			Data:    []byte(`{"error_struct":5}`),
+			Offsets: []int{16},
+		},
+		{
+			Data:    []byte(`{"error_struct":[]}`),
+			Offsets: []int{16},
+		},
+		{
+			Data:    []byte(`{"error_struct":{"int":{}}}`),
+			Offsets: []int{23},
+		},
+		{
+			Data:    []byte(`{"error_struct":{"int_slice":{}}, "int":4}`),
+			Offsets: []int{29},
+		},
+		{
+			Data:    []byte(`{"error_struct":{"int_slice":["1", 2, "3"]}, "int":[]}`),
+			Offsets: []int{30, 38, 51},
+		},
+	} {
+		l := jlexer.Lexer{
+			Data:              test.Data,
+			UseMultipleErrors: true,
+		}
+		var v ErrorNestedStruct
+		v.UnmarshalEasyJSON(&l)
+
+		errors := l.GetNonFatalErrors()
+
+		if len(errors) != len(test.Offsets) {
+			t.Errorf("[%d] TestMultipleErrorsNestedStruct(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
+			return
+		}
+		for ii, e := range errors {
+			if e.Offset != test.Offsets[ii] {
+				t.Errorf("[%d] TestMultipleErrorsNestedStruct(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
+			}
+		}
+	}
+}
+
+func TestMultipleErrorsIntMap(t *testing.T) {
+	for i, test := range []struct {
+		Data    []byte
+		Offsets []int
+	}{
+		{
+			Data:    []byte(`{"a":"NumErr"}`),
+			Offsets: []int{1},
+		},
+		{
+			Data:    []byte(`{"":"ErrSyntax"}`),
+			Offsets: []int{1},
+		},
+		{
+			Data:    []byte(`{"a":"NumErr","33147483647":"ErrRange","-1":"ErrRange"}`),
+			Offsets: []int{1, 14, 39},
+		},
+	} {
+		l := jlexer.Lexer{
+			Data:              test.Data,
+			UseMultipleErrors: true,
+		}
+
+		var v ErrorIntMap
+
+		v.UnmarshalEasyJSON(&l)
+
+		errors := l.GetNonFatalErrors()
+
+		if len(errors) != len(test.Offsets) {
+			t.Errorf("[%d] TestMultipleErrorsInt(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors))
+			return
+		}
+
+		for ii, e := range errors {
+			if e.Offset != test.Offsets[ii] {
+				t.Errorf("[%d] TestMultipleErrorsInt(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset)
+			}
+		}
+	}
+}

vendor/github.com/mailru/easyjson/tests/named_type.go

@@ -0,0 +1,22 @@
+package tests
+
+//easyjson:json
+type NamedType struct {
+	Inner struct {
+		// easyjson is mistakenly naming the type of this field 'tests.MyString' in the generated output
+		// something about a named type inside an anonmymous type is triggering this bug
+		Field  MyString `tag:"value"`
+		Field2 int      "tag:\"value with ` in it\""
+	}
+}
+
+type MyString string
+
+var namedTypeValue NamedType
+
+func init() {
+	namedTypeValue.Inner.Field = "test"
+	namedTypeValue.Inner.Field2 = 123
+}
+
+var namedTypeValueString = `{"Inner":{"Field":"test","Field2":123}}`

vendor/github.com/mailru/easyjson/tests/nested_easy.go

@@ -0,0 +1,25 @@
+package tests
+
+import (
+	"github.com/mailru/easyjson"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+//easyjson:json
+type NestedInterfaces struct {
+	Value interface{}
+	Slice []interface{}
+	Map   map[string]interface{}
+}
+
+type NestedEasyMarshaler struct {
+	EasilyMarshaled bool
+}
+
+var _ easyjson.Marshaler = &NestedEasyMarshaler{}
+
+func (i *NestedEasyMarshaler) MarshalEasyJSON(w *jwriter.Writer) {
+	// We use this method only to indicate that easyjson.Marshaler
+	// interface was really used while encoding.
+	i.EasilyMarshaled = true
+}

vendor/github.com/mailru/easyjson/tests/nothing.go

@@ -0,0 +1,3 @@
+package tests
+
+// No structs in this file

vendor/github.com/mailru/easyjson/tests/omitempty.go

@@ -0,0 +1,12 @@
+package tests
+
+//easyjson:json
+type OmitEmptyDefault struct {
+	Field string
+	Str   string
+	Str1  string `json:"s,!omitempty"`
+	Str2  string `json:",!omitempty"`
+}
+
+var omitEmptyDefaultValue = OmitEmptyDefault{Field: "test"}
+var omitEmptyDefaultString = `{"Field":"test","s":"","Str2":""}`

vendor/github.com/mailru/easyjson/tests/required_test.go

@@ -0,0 +1,28 @@
+package tests
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestRequiredField(t *testing.T) {
+	cases := []struct{ json, errorMessage string }{
+		{`{"first_name":"Foo", "last_name": "Bar"}`, ""},
+		{`{"last_name":"Bar"}`, "key 'first_name' is required"},
+		{"{}", "key 'first_name' is required"},
+	}
+
+	for _, tc := range cases {
+		var v RequiredOptionalStruct
+		err := v.UnmarshalJSON([]byte(tc.json))
+		if tc.errorMessage == "" {
+			if err != nil {
+				t.Errorf("%s. UnmarshalJSON didn`t expect error: %v", tc.json, err)
+			}
+		} else {
+			if fmt.Sprintf("%v", err) != tc.errorMessage {
+				t.Errorf("%s. UnmarshalJSON expected error: %v. got: %v", tc.json, tc.errorMessage, err)
+			}
+		}
+	}
+}

vendor/github.com/mailru/easyjson/tests/snake.go

@@ -0,0 +1,10 @@
+package tests
+
+//easyjson:json
+type SnakeStruct struct {
+	WeirdHTTPStuff   bool
+	CustomNamedField string `json:"cUsToM"`
+}
+
+var snakeStructValue SnakeStruct
+var snakeStructString = `{"weird_http_stuff":false,"cUsToM":""}`