feature: is.Error(v, nil)

README.md

@@ -105,6 +105,15 @@ Expectation | Type constraints | Description
 `is.StringHavingSuffix` | `string` | Expects the given value to be a string having a given suffix
 `is.EqualToStringByLines` | `string` | Similar to EqualTo used on two strings but reports differences on a line-by-line basis
 
+### A note on error testing
+
+`expect` provides two expectations targeting `error` specificially: `is.Error` and `is.NoError`. The later one
+is straight forward and expects the given value to be `nil`. `is.Error` works by applying the standard library
+function `errors.Is` and expects the given error to contain the target error as part of its error wrapping
+chain. In addition, `is.Error` also supports the target error to be `nil`. In this case, `is.Error(v, nil)`
+behaves identical to `is.Error(v)`. This allows an easy and convenient way of writing table based tests that
+expect both error and non-error conditions.
+
 ### Deep equality
 
 The `is.DeepEqualTo` expectation is special as compared to the other ones. It uses a recursive algorithm to 

cmd/expect-migrate/main.go

@@ -197,11 +197,16 @@ func (v *expectationRewriteVisitor) Visit(node ast.Node) ast.Visitor {
 		}
 	}
 
-	if _, ok := node.(*ast.ExprStmt); ok {
+	exprStmt, ok := node.(*ast.ExprStmt)
+	if !ok {
+		if currentBlock != nil {
+			currentBlock.lastExpectation = nil
+		}
+
 		return v
 	}
 
-	call, ok := node.(*ast.CallExpr)
+	call, ok := exprStmt.X.(*ast.CallExpr)
 	if !ok {
 		if currentBlock != nil {
 			currentBlock.lastExpectation = nil

is/error.go

@@ -8,7 +8,13 @@ import (
 
 // Error matches got to contain target in its chain. The check is performed
 // using errors.Is.
+// A special case happens when target is nil. In this case, Error behaves identical to NoError. This improves
+// testing convenience when writing table based tests that test on both error and non error conditions.
 func Error(got, target error) expect.Expectation {
+	if target == nil {
+		return NoError(got)
+	}
+
 	return expect.ExpectFunc(func(t expect.TB) {
 		t.Helper()
 

is/error_test.go

@@ -28,6 +28,7 @@ func TestError(t *testing.T) {
 
 	err := errors.New("failed")
 
+	Error(nil, nil).Expect(&tm)
 	Error(nil, err).Expect(&tm)
 	Error(errors.New("other"), err).Expect(&tm)
 	Error(err, err).Expect(&tm)