Add FeedIcon API call and update dependencies

vendor/golang.org/x/text/message/message.go

@@ -8,26 +8,28 @@ import (
 	"io"
 	"os"
 
+	// Include features to facilitate generated catalogs.
+	_ "golang.org/x/text/feature/plural"
+
+	"golang.org/x/text/internal/number"
 	"golang.org/x/text/language"
 	"golang.org/x/text/message/catalog"
 )
 
-// TODO: allow more than one goroutine per printer. This will allow porting from
-// fmt much less error prone.
-
 // A Printer implements language-specific formatted I/O analogous to the fmt
-// package. Only one goroutine may use a Printer at the same time.
+// package.
 type Printer struct {
-	// Wrap the fields in a hidden type to hide some of the implemented methods.
-	printer printer
+	// the language
+	tag language.Tag
 
-	// NOTE: limiting one goroutine per Printer allows for many optimizations
-	// and simplifications. We can consider removing this restriction down the
-	// road if it the benefits do not seem to outweigh the disadvantages.
+	toDecimal    number.Formatter
+	toScientific number.Formatter
+
+	cat catalog.Catalog
 }
 
 type options struct {
-	cat *catalog.Catalog
+	cat catalog.Catalog
 	// TODO:
 	// - allow %s to print integers in written form (tables are likely too large
 	//   to enable this by default).
@@ -39,39 +41,42 @@ type options struct {
 type Option func(o *options)
 
 // Catalog defines the catalog to be used.
-func Catalog(c *catalog.Catalog) Option {
+func Catalog(c catalog.Catalog) Option {
 	return func(o *options) { o.cat = c }
 }
 
 // NewPrinter returns a Printer that formats messages tailored to language t.
 func NewPrinter(t language.Tag, opts ...Option) *Printer {
 	options := &options{
-		cat: defaultCatalog,
+		cat: DefaultCatalog,
 	}
 	for _, o := range opts {
 		o(options)
 	}
-	p := &Printer{printer{
+	p := &Printer{
 		tag: t,
-	}}
-	p.printer.toDecimal.InitDecimal(t)
-	p.printer.toScientific.InitScientific(t)
-	p.printer.catContext = options.cat.Context(t, &p.printer)
+		cat: options.cat,
+	}
+	p.toDecimal.InitDecimal(t)
+	p.toScientific.InitScientific(t)
 	return p
 }
 
 // Sprint is like fmt.Sprint, but using language-specific formatting.
 func (p *Printer) Sprint(a ...interface{}) string {
-	p.printer.reset()
-	p.printer.doPrint(a)
-	return p.printer.String()
+	pp := newPrinter(p)
+	pp.doPrint(a)
+	s := pp.String()
+	pp.free()
+	return s
 }
 
 // Fprint is like fmt.Fprint, but using language-specific formatting.
 func (p *Printer) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
-	p.printer.reset()
-	p.printer.doPrint(a)
-	n64, err := io.Copy(w, &p.printer.Buffer)
+	pp := newPrinter(p)
+	pp.doPrint(a)
+	n64, err := io.Copy(w, &pp.Buffer)
+	pp.free()
 	return int(n64), err
 }
 
@@ -82,16 +87,19 @@ func (p *Printer) Print(a ...interface{}) (n int, err error) {
 
 // Sprintln is like fmt.Sprintln, but using language-specific formatting.
 func (p *Printer) Sprintln(a ...interface{}) string {
-	p.printer.reset()
-	p.printer.doPrintln(a)
-	return p.printer.String()
+	pp := newPrinter(p)
+	pp.doPrintln(a)
+	s := pp.String()
+	pp.free()
+	return s
 }
 
 // Fprintln is like fmt.Fprintln, but using language-specific formatting.
 func (p *Printer) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
-	p.printer.reset()
-	p.printer.doPrintln(a)
-	n64, err := io.Copy(w, &p.printer.Buffer)
+	pp := newPrinter(p)
+	pp.doPrintln(a)
+	n64, err := io.Copy(w, &pp.Buffer)
+	pp.free()
 	return int(n64), err
 }
 
@@ -102,25 +110,34 @@ func (p *Printer) Println(a ...interface{}) (n int, err error) {
 
 // Sprintf is like fmt.Sprintf, but using language-specific formatting.
 func (p *Printer) Sprintf(key Reference, a ...interface{}) string {
-	lookupAndFormat(p, key, a)
-	return p.printer.String()
+	pp := newPrinter(p)
+	lookupAndFormat(pp, key, a)
+	s := pp.String()
+	pp.free()
+	return s
 }
 
 // Fprintf is like fmt.Fprintf, but using language-specific formatting.
 func (p *Printer) Fprintf(w io.Writer, key Reference, a ...interface{}) (n int, err error) {
-	lookupAndFormat(p, key, a)
-	return w.Write(p.printer.Bytes())
+	pp := newPrinter(p)
+	lookupAndFormat(pp, key, a)
+	n, err = w.Write(pp.Bytes())
+	pp.free()
+	return n, err
+
 }
 
 // Printf is like fmt.Printf, but using language-specific formatting.
 func (p *Printer) Printf(key Reference, a ...interface{}) (n int, err error) {
-	lookupAndFormat(p, key, a)
-	return os.Stdout.Write(p.printer.Bytes())
+	pp := newPrinter(p)
+	lookupAndFormat(pp, key, a)
+	n, err = os.Stdout.Write(pp.Bytes())
+	pp.free()
+	return n, err
 }
 
-func lookupAndFormat(p *Printer, r Reference, a []interface{}) {
-	p.printer.reset()
-	p.printer.args = a
+func lookupAndFormat(p *printer, r Reference, a []interface{}) {
+	p.fmt.Reset(a)
 	var id, msg string
 	switch v := r.(type) {
 	case string:
@@ -131,9 +148,9 @@ func lookupAndFormat(p *Printer, r Reference, a []interface{}) {
 		panic("key argument is not a Reference")
 	}
 
-	if p.printer.catContext.Execute(id) == catalog.ErrNotFound {
-		if p.printer.catContext.Execute(msg) == catalog.ErrNotFound {
-			p.printer.Render(msg)
+	if p.catContext.Execute(id) == catalog.ErrNotFound {
+		if p.catContext.Execute(msg) == catalog.ErrNotFound {
+			p.Render(msg)
 			return
 		}
 	}
@@ -142,8 +159,8 @@ func lookupAndFormat(p *Printer, r Reference, a []interface{}) {
 // Arg implements catmsg.Renderer.
 func (p *printer) Arg(i int) interface{} { // TODO, also return "ok" bool
 	i--
-	if uint(i) < uint(len(p.args)) {
-		return p.args[i]
+	if uint(i) < uint(len(p.fmt.Args)) {
+		return p.fmt.Args[i]
 	}
 	return nil
 }