code review 5619052: std: add struct field tags to untagged literals.

src/pkg/image/draw/draw_test.go

 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package draw
 
 import (
         "image"
         "image/color"
         "testing"
@@ skipping 150 matching lines @@
         sb := src.Bounds()
         mb := image.Rect(-1e9, -1e9, 1e9, 1e9)
         if mask != nil {
                 mb = mask.Bounds()
         }
         golden := image.NewRGBA(image.Rect(0, 0, b.Max.X, b.Max.Y))
         for y := r.Min.Y; y < r.Max.Y; y++ {
                 sy := y + sp.Y - r.Min.Y
                 my := y + mp.Y - r.Min.Y
                 for x := r.Min.X; x < r.Max.X; x++ {
-                        if !(image.Point{x, y}.In(b)) {
+                        if !(image.Pt(x, y).In(b)) {
                                 continue
                         }
                         sx := x + sp.X - r.Min.X
-                        if !(image.Point{sx, sy}.In(sb)) {
+                        if !(image.Pt(sx, sy).In(sb)) {
                                 continue
                         }
                         mx := x + mp.X - r.Min.X
-                        if !(image.Point{mx, my}.In(mb)) {
+                        if !(image.Pt(mx, my).In(mb)) {
                                 continue
                         }
 
                         const M = 1<<16 - 1
                         var dr, dg, db, da uint32
                         if op == Over {
                                 dr, dg, db, da = dst.At(x, y).RGBA()
                         }
                         sr, sg, sb, sa := src.At(sx, sy).RGBA()
                         ma := uint32(M)
@@ skipping 115 matching lines @@
                 image.Rect(0, 15, 40, 16),
                 image.Rect(24, 24, 25, 25),
                 image.Rect(23, 23, 26, 26),
                 image.Rect(22, 22, 27, 27),
                 image.Rect(21, 21, 28, 28),
                 image.Rect(20, 20, 29, 29),
         }
         for _, r := range rr {
                 m := image.NewRGBA(image.Rect(0, 0, 40, 30)).SubImage(r).(*image.RGBA)
                 b := m.Bounds()
-                c := color.RGBA{11, 0, 0, 255}
-                src := &image.Uniform{c}
+                c := color.RGBA{R: 11, G: 0, B: 0, A: 255}

[dsymonds, 2012/02/02 07:00:33]

color.RGBA is frozen; you don't need to change this.

[nigeltao, 2012/02/02 07:05:49]

True, but it looked weird to use an untagged struct literal on one line and a
tagged one on the next.

[nigeltao, 2012/02/02 22:57:48]

The color.RGBA changes have been reverted.

+                src := &image.Uniform{C: c}
                 check := func(desc string) {
                         for y := b.Min.Y; y < b.Max.Y; y++ {
                                 for x := b.Min.X; x < b.Max.X; x++ {
                                         if !eq(c, m.At(x, y)) {
                                                 t.Errorf("%s fill: at (%d, %d), sub-image bounds=%v: want %v got %v", desc, x, y, r, c, m.At(x, y))
                                                 return
                                         }
                                 }
                         }
                 }
                 // Draw 1 pixel at a time.
                 for y := b.Min.Y; y < b.Max.Y; y++ {
                         for x := b.Min.X; x < b.Max.X; x++ {
                                 DrawMask(m, image.Rect(x, y, x+1, y+1), src, image.ZP, nil, image.ZP, Src)
                         }
                 }
                 check("pixel")
                 // Draw 1 row at a time.
-                c = color.RGBA{0, 22, 0, 255}
-                src = &image.Uniform{c}
+                c = color.RGBA{R: 0, G: 22, B: 0, A: 255}

[dsymonds, 2012/02/02 07:00:33]

ditto

+                src = &image.Uniform{C: c}
                 for y := b.Min.Y; y < b.Max.Y; y++ {
                         DrawMask(m, image.Rect(b.Min.X, y, b.Max.X, y+1), src, image.ZP, nil, image.ZP, Src)
                 }
                 check("row")
                 // Draw 1 column at a time.
-                c = color.RGBA{0, 0, 33, 255}
-                src = &image.Uniform{c}
+                c = color.RGBA{R: 0, G: 0, B: 33, A: 255}

[dsymonds, 2012/02/02 07:00:33]

ditto

+                src = &image.Uniform{C: c}
                 for x := b.Min.X; x < b.Max.X; x++ {
                         DrawMask(m, image.Rect(x, b.Min.Y, x+1, b.Max.Y), src, image.ZP, nil, image.ZP, Src)
                 }
                 check("column")
                 // Draw the whole image at once.
-                c = color.RGBA{44, 55, 66, 77}
-                src = &image.Uniform{c}
+                c = color.RGBA{R: 44, G: 55, B: 66, A: 77}

[dsymonds, 2012/02/02 07:00:33]

ditto

+                src = &image.Uniform{C: c}
                 DrawMask(m, b, src, image.ZP, nil, image.ZP, Src)
                 check("whole")
         }
 }