make And() propagate MatchMayChangeInTheFuture()
- considers both Match() cases and considers the appropriate matcher(s) in making decision
- also added a comment to WithTransform.MatchMayChangeInTheFuture(), as it will not have correct behavior with non-deterministic transformer

matchers/and.go

diff --git a/matchers/and.go b/matchers/and.go
index 5092463..9acf470 100644
--- a/matchers/and.go
+++ b/matchers/and.go
@@ -3,6 +3,7 @@
 import (
 	"fmt"
 	"github.com/onsi/gomega/format"
+	"github.com/onsi/gomega/internal/asyncassertion"
 	"github.com/onsi/gomega/types"
 )
 
@@ -10,25 +11,53 @@
 	Matchers []types.GomegaMatcher
 
 	// state
-	firstFailedMatchErrMsg string
+	firstFailedMatcher types.GomegaMatcher
 }
 
 func (m *AndMatcher) Match(actual interface{}) (success bool, err error) {
+	m.firstFailedMatcher = nil
 	for _, matcher := range m.Matchers {
 		success, err := matcher.Match(actual)
 		if !success || err != nil {
-			m.firstFailedMatchErrMsg = matcher.FailureMessage(actual)
+			m.firstFailedMatcher = matcher
 			return false, err
 		}
 	}
 	return true, nil
 }
 
-func (m *AndMatcher) FailureMessage(_ interface{}) (message string) {
-	return m.firstFailedMatchErrMsg
+func (m *AndMatcher) FailureMessage(actual interface{}) (message string) {
+	return m.firstFailedMatcher.FailureMessage(actual)
 }
 
 func (m *AndMatcher) NegatedFailureMessage(actual interface{}) (message string) {
 	// not the most beautiful list of matchers, but not bad either...
 	return format.Message(actual, fmt.Sprintf("To not satisfy all of these matchers: %s", m.Matchers))
 }
+
+func (m *AndMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
+	/*
+		Example with 3 matchers: A, B, C
+
+		Match evaluates them: T, F, <?>  => F
+		So match is currently F, what should MatchMayChangeInTheFuture() return?
+		Seems like it only depends on B, since currently B MUST change to allow the result to become T
+
+		Match eval: T, T, T  => T
+		So match is currently T, what should MatchMayChangeInTheFuture() return?
+		Answer: Seems to depend on ANY of them being able to change to F.
+	*/
+
+	if m.firstFailedMatcher == nil {
+		// so all matchers succeeded.. Any one of them changing would change the result.
+		for _, matcher := range m.Matchers {
+			if asyncassertion.MatchMayChangeInTheFuture(matcher, actual) {
+				return true
+			}
+		}
+		return false // none of were going to change
+	} else {
+		// one of the matchers failed.. it must be able to change in order to affect the result
+		return asyncassertion.MatchMayChangeInTheFuture(m.firstFailedMatcher, actual)
+	}
+}

matchers/and_test.go

diff --git a/matchers/and_test.go b/matchers/and_test.go
index 955e4ae..5e281ca 100644
--- a/matchers/and_test.go
+++ b/matchers/and_test.go
@@ -3,6 +3,7 @@
 import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
 	"github.com/onsi/gomega/types"
 )
 
@@ -61,4 +62,46 @@
 			})
 		})
 	})
+
+	Context("MatchMayChangeInTheFuture", func() {
+		// setup a closed channel
+		closedChannel := make(chan int)
+		close(closedChannel)
+		var i int
+		Context("Match returned false", func() {
+			Context("returns value of the failed matcher", func() {
+				It("false if failed matcher not going to change", func() {
+					// 3 matchers: 1st returns true, 2nd returns false and is not going to change, 3rd is never called
+					m := And(Not(BeNil()), Receive(&i), Equal(1))
+					Expect(m.Match(closedChannel)).To(BeFalse())
+					Expect(m.(*AndMatcher).MatchMayChangeInTheFuture(closedChannel)).To(BeFalse()) // closed channel, so not going to change
+				})
+				It("true if failed matcher indicates it might change", func() {
+					// 3 matchers: 1st returns true, 2nd returns false and "might" change, 3rd is never called
+					m := And(Not(BeNil()), Equal(5), Equal(1))
+					Expect(m.Match(closedChannel)).To(BeFalse())
+					Expect(m.(*AndMatcher).MatchMayChangeInTheFuture(closedChannel)).To(BeTrue()) // Equal(5) indicates it might change
+				})
+			})
+		})
+		Context("Match returned true", func() {
+			It("returns true if any of the matchers could change", func() {
+				// 3 matchers, all return true, and all could change
+				m := And(Not(BeNil()), Equal("hi"), HaveLen(2))
+				Expect(m.Match("hi")).To(BeTrue())
+				Expect(m.(*AndMatcher).MatchMayChangeInTheFuture("hi")).To(BeTrue()) // all 3 of these matchers default to 'true'
+			})
+			It("returns false if none of the matchers could change", func() {
+				// empty And() has the property of always matching, and never can change since there are no sub-matchers that could change
+				m := And()
+				Expect(m.Match("anything")).To(BeTrue())
+				Expect(m.(*AndMatcher).MatchMayChangeInTheFuture("anything")).To(BeFalse())
+
+				// And() with 3 sub-matchers that return true, and can't change
+				m = And(And(), And(), And())
+				Expect(m.Match("hi")).To(BeTrue())
+				Expect(m.(*AndMatcher).MatchMayChangeInTheFuture("hi")).To(BeFalse()) // the 3 empty And()'s won't change
+			})
+		})
+	})
 })

matchers/with_transform.go

diff --git a/matchers/with_transform.go b/matchers/with_transform.go
index a8d2a7c..21d9fe0 100644
--- a/matchers/with_transform.go
+++ b/matchers/with_transform.go
@@ -62,5 +62,10 @@
 }
 
 func (m *WithTransformMatcher) MatchMayChangeInTheFuture(_ interface{}) bool {
+	// TODO: Maybe this should always just return true? (Only an issue for non-deterministic transformers.)
+	//
+	// Querying the next matcher is fine if the transformer always will return the same value.
+	// But if the transformer is non-deterministic and returns a different value each time, then there
+	// is no point in querying the next matcher, since it can only comment on the last transformed value.
 	return asyncassertion.MatchMayChangeInTheFuture(m.Matcher, m.transformedValue)
 }