code review 7942045: cmd/gc: more race instrumentation.

src/pkg/runtime/race/testdata/mop_test.go

 // Copyright 2011 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 race_test
 
 import (
         "errors"
         "fmt"
         "runtime"
@@ skipping 558 matching lines @@
         go func() {
                 a = DummyWriter{1}
                 ch <- true
         }()
         a = DummyWriter{2}
         <-ch
         b = a
         a = b
 }
 
 func TestRaceIfaceCmp(t *testing.T) {

[remyoudompheng, 2013/03/26 00:26:01]

This test fails without the patch.

         var a, b Writer
         a = DummyWriter{1}
         ch := make(chan bool, 1)
         go func() {
                 a = DummyWriter{1}
                 ch <- true
         }()
         _ = a == b
         <-ch
 }
@@ skipping 648 matching lines @@
         c := make(chan bool, 1)
         i := &InterImpl{}
         go func() {
                 i = &InterImpl{}
                 c <- true
         }()
         i.Foo(0)
         <-c
 }
 
+// Method value with concrete value receiver.
 func TestRaceMethodValue(t *testing.T) {
         c := make(chan bool, 1)
         i := InterImpl{}
         go func() {
                 i = InterImpl{}
                 c <- true
         }()
         _ = i.Foo
         <-c
 }
 
+// Method value with interface receiver.
 func TestRaceMethodValue2(t *testing.T) {
         c := make(chan bool, 1)
         var i Inter = InterImpl{}

[dvyukov, 2013/03/26 06:31:47]

It is different from the previous test only by i declaration. Why is it
important?
I know the tests are not rich with comment, but please add one here explaining
the difference.

[remyoudompheng, 2013/03/26 07:27:36]

Done.

         go func() {
                 i = InterImpl{}
                 c <- true
         }()
         _ = i.Foo
         <-c
 }
 
+// Method value with implicit dereference.
 func TestRaceMethodValue3(t *testing.T) {
         c := make(chan bool, 1)
         i := &InterImpl{}
         go func() {
                 *i = InterImpl{}
                 c <- true
         }()
         _ = i.Foo // dereferences i.
         <-c
 }
 
+// Method value implicitly taking receiver address.
 func TestNoRaceMethodValue(t *testing.T) {
         c := make(chan bool, 1)
         i := InterImpl2{}
         go func() {
                 i = InterImpl2{}
                 c <- true
         }()
         _ = i.Foo // takes the address of i only.
         <-c
 }
@@ skipping 266 matching lines @@
                 x X
         }
         c := make(chan Y)
         var y Y
         go func() {
                 c <- y
         }()
         y.x.y = 42
         <-c
 }