Fix handling of condition method calls

spock-core/src/main/java/org/spockframework/compiler/ConditionRewriter.java

@@ -41,6 +41,7 @@
 import static java.util.Collections.singletonList;
 import static org.spockframework.compiler.AstUtil.createDirectMethodCall;
 import static org.spockframework.compiler.AstUtil.primitiveConstExpression;
+import static org.spockframework.compiler.SpecialMethodCall.checkIsConditionMethodCall;
 
 // NOTE: currently some conversions reference old expression objects rather than copying them;
 // this can potentially lead to aliasing problems (e.g. for Condition.originalExpression)
@@ -641,8 +642,7 @@ private Statement rewriteCondition(Expression expr, Expression message, boolean
     // method conditions with spread operator are not lifted because MOP doesn't support spreading
     if (expr instanceof MethodCallExpression && !((MethodCallExpression) expr).isSpreadSafe()) {
       MethodCallExpression methodCallExpression = (MethodCallExpression)expr;
-      String methodName = AstUtil.getMethodName(methodCallExpression);
-      if ((Identifiers.CONDITION_METHODS.contains(methodName))) {
+      if (checkIsConditionMethodCall(methodCallExpression)) {
         return surroundSpecialTryCatch(expr);
       }
       return rewriteMethodCondition(methodCallExpression, message, explicit, optOut);

spock-core/src/main/java/org/spockframework/compiler/DeepBlockRewriter.java

@@ -204,12 +204,17 @@ private boolean handleImplicitCondition(ExpressionStatement stat) {
 
     checkIsValidImplicitCondition(stat, resources.getErrorReporter());
 
-    String methodName = AstUtil.getMethodName(stat.getExpression());
-    boolean isConditionMethodCall = Identifiers.CONDITION_METHODS.contains(methodName);
+    boolean isConditionMethodCall;
+    if (stat.getExpression() instanceof MethodCallExpression) {
+      isConditionMethodCall = SpecialMethodCall.checkIsConditionMethodCall(((MethodCallExpression) stat.getExpression()));
+    } else {
+      isConditionMethodCall = false;
+    }
 
     if (isConditionMethodCall) {
       groupConditionFound = currSpecialMethodCall.isGroupConditionBlock();
-    } else {
+    }
+    if (!isConditionMethodCall || currSpecialMethodCall.isConditionMethodCall() || currSpecialMethodCall.isGroupConditionBlock()) {
       conditionFound();
     }
 

spock-core/src/main/java/org/spockframework/compiler/SpecialMethodCall.java

@@ -269,6 +269,11 @@ public String toString() {
         methodName, inferredName, inferredType, methodCallExpr, closureExpr, conditionBlock);
   }
 
+  static boolean checkIsConditionMethodCall(MethodCallExpression expr) {
+    if (!AstUtil.isThisOrSuperExpression(expr.getObjectExpression())) return false;
+    return Identifiers.CONDITION_METHODS.contains(expr.getMethodAsString());
+  }
+
   private static boolean checkIsBuiltInMethodCall(MethodCallExpression expr) {
     if (!AstUtil.isThisOrSuperExpression(expr.getObjectExpression())) return false;
     return Identifiers.BUILT_IN_METHODS.contains(expr.getMethodAsString());

spock-specs/src/test/groovy/org/spockframework/smoke/WithBlockFailingConditions.groovy

@@ -14,10 +14,11 @@
 
 package org.spockframework.smoke
 
+import org.spockframework.EmbeddedSpecification
 import org.spockframework.runtime.*
 import spock.lang.*
 
-class WithBlockFailingConditions extends Specification {
+class WithBlockFailingConditions extends EmbeddedSpecification {
   @FailsWith(ConditionNotSatisfiedError)
   def "basic usage"() {
     def list = [1, 2]
@@ -155,4 +156,146 @@ class WithBlockFailingConditions extends Specification {
       size() == 3
     }
   }
+
+  @FailsWith(ConditionNotSatisfiedError)
+  def "GDK method that looks like built-in method as implicit condition"() {
+    expect:
+    null.with {
+      false
+    }
+  }
+
+  @FailsWith(ConditionNotSatisfiedError)
+  def "GDK method that looks like built-in method as explicit condition"() {
+    expect:
+    assert null.with {
+      false
+    }
+  }
+
+  def "condition method #conditionMethod within condition method #conditionMethod"() {
+    when:
+    runner.runFeatureBody("""
+expect:
+$conditionMethod(['']) {
+  $conditionMethod(['']) {
+    false
+  }
+}
+""")
+
+    then:
+    thrown(expectedException)
+
+    where:
+    conditionMethod || expectedException
+    'with'          || ConditionNotSatisfiedError
+    'verifyAll'     || ConditionNotSatisfiedError
+    'verifyEach'    || SpockAssertionError
+  }
+
+  def "condition method #conditionMethod within condition method #conditionMethod with exception"() {
+    when:
+    runner.runFeatureBody("""
+expect:
+$conditionMethod(['']) {
+  $conditionMethod(['']) {
+    true
+    throw new Exception('foo')
+  }
+}
+""")
+
+    then:
+    def exception = thrown(expectedException)
+    exception.message."${expectedException == Exception ? 'equals' : 'contains'}"('foo')
+
+    where:
+    conditionMethod || expectedException
+    'with'          || Exception
+    'verifyAll'     || Exception
+    'verifyEach'    || SpockAssertionError
+  }
+
+  def "condition method #conditionMethod within condition method #conditionMethod with only exception"() {
+    when:
+    runner.runFeatureBody("""
+expect:
+$conditionMethod(['']) {
+  $conditionMethod(['']) {
+    throw new Exception('foo')
+  }
+}
+""")
+
+    then:
+    def exception = thrown(expectedException)
+    exception.message."${expectedException == Exception ? 'equals' : 'contains'}"('foo')
+
+    where:
+    conditionMethod || expectedException
+    'with'          || Exception
+    'verifyAll'     || Exception
+    'verifyEach'    || SpockAssertionError
+  }
+
+  def "condition method #conditionMethod"() {
+    when:
+    runner.runFeatureBody("""
+expect:
+$conditionMethod(['']) {
+  false
+}
+""")
+
+    then:
+    thrown(expectedException)
+
+    where:
+    conditionMethod || expectedException
+    'with'          || ConditionNotSatisfiedError
+    'verifyAll'     || ConditionNotSatisfiedError
+    'verifyEach'    || SpockAssertionError
+  }
+
+  def "condition method #conditionMethod with exception"() {
+    when:
+    runner.runFeatureBody("""
+expect:
+$conditionMethod(['']) {
+  true
+  throw new Exception('foo')
+}
+""")
+
+    then:
+    def exception = thrown(expectedException)
+    exception.message."${expectedException == Exception ? 'equals' : 'contains'}"('foo')
+
+    where:
+    conditionMethod || expectedException
+    'with'          || Exception
+    'verifyAll'     || Exception
+    'verifyEach'    || SpockAssertionError
+  }
+
+  def "condition method #conditionMethod with only exception"() {
+    when:
+    runner.runFeatureBody("""
+expect:
+$conditionMethod(['']) {
+  throw new Exception('foo')
+}
+""")
+
+    then:
+    def exception = thrown(expectedException)
+    exception.message."${expectedException == Exception ? 'equals' : 'contains'}"('foo')
+
+    where:
+    conditionMethod || expectedException
+    'with'          || Exception
+    'verifyAll'     || Exception
+    'verifyEach'    || SpockAssertionError
+  }
 }

spock-specs/src/test/groovy/org/spockframework/smoke/ast/AstSpec.groovy

@@ -387,4 +387,158 @@ class TestSpec extends Specification {
     then:
     textSnapshotter.assertThat(result.source).matchesSnapshot()
   }
+
+  def "GDK method that looks like built-in method as implicit condition"() {
+    when:
+    def result = compiler.transpileFeatureBody('''
+expect:
+null.with {
+  false
+}
+''')
+
+    then:
+    snapshotter.assertThat(result.source).matchesSnapshot()
+  }
+
+  def "GDK method that looks like built-in method as explicit condition"() {
+    when:
+    def result = compiler.transpileFeatureBody('''
+expect:
+assert null.with {
+  false
+}
+''')
+
+    then:
+    snapshotter.assertThat(result.source).matchesSnapshot()
+  }
+
+  def "condition method #conditionMethod within condition method #conditionMethod"() {
+    when:
+    def result = compiler.transpileFeatureBody("""
+expect:
+$conditionMethod(['']) {
+  $conditionMethod(['']) {
+    false
+  }
+}
+""")
+
+    then:
+    snapshotter.assertThat(result.source).matchesSnapshot()
+
+    where:
+    conditionMethod << [
+      'with',
+      'verifyAll',
+      'verifyEach'
+    ]
+  }
+
+  def "condition method #conditionMethod within condition method #conditionMethod with exception"() {
+    when:
+    def result = compiler.transpileFeatureBody("""
+expect:
+$conditionMethod(['']) {
+  $conditionMethod(['']) {
+    true
+    throw new Exception('foo')
+  }
+}
+""")
+
+    then:
+    snapshotter.assertThat(result.source).matchesSnapshot()
+
+    where:
+    conditionMethod << [
+      'with',
+      'verifyAll',
+      'verifyEach'
+    ]
+  }
+
+  def "condition method #conditionMethod within condition method #conditionMethod with only exception"() {
+    when:
+    def result = compiler.transpileFeatureBody("""
+expect:
+$conditionMethod(['']) {
+  $conditionMethod(['']) {
+    throw new Exception('foo')
+  }
+}
+""")
+
+    then:
+    snapshotter.assertThat(result.source).matchesSnapshot()
+
+    where:
+    conditionMethod << [
+      'with',
+      'verifyAll',
+      'verifyEach'
+    ]
+  }
+
+  def "condition method #conditionMethod"() {
+    when:
+    def result = compiler.transpileFeatureBody("""
+expect:
+$conditionMethod(['']) {
+  false
+}
+""")
+
+    then:
+    snapshotter.assertThat(result.source).matchesSnapshot()
+
+    where:
+    conditionMethod << [
+      'with',
+      'verifyAll',
+      'verifyEach'
+    ]
+  }
+
+  def "condition method #conditionMethod with exception"() {
+    when:
+    def result = compiler.transpileFeatureBody("""
+expect:
+$conditionMethod(['']) {
+  true
+  throw new Exception('foo')
+}
+""")
+
+    then:
+    snapshotter.assertThat(result.source).matchesSnapshot()
+
+    where:
+    conditionMethod << [
+      'with',
+      'verifyAll',
+      'verifyEach'
+    ]
+  }
+
+  def "condition method #conditionMethod with only exception"() {
+    when:
+    def result = compiler.transpileFeatureBody("""
+expect:
+$conditionMethod(['']) {
+  throw new Exception('foo')
+}
+""")
+
+    then:
+    snapshotter.assertThat(result.source).matchesSnapshot()
+
+    where:
+    conditionMethod << [
+      'with',
+      'verifyAll',
+      'verifyEach'
+    ]
+  }
 }

spock-specs/src/test/resources/snapshots/org/spockframework/smoke/ast/AstSpec/GDK_method_that_looks_like_built_in_method_as_explicit_condition.groovy

@@ -0,0 +1,17 @@
+@org.spockframework.runtime.model.FeatureMetadata(name = 'a feature', ordinal = 0, line = 1, blocks = [@org.spockframework.runtime.model.BlockMetadata(kind = org.spockframework.runtime.model.BlockKind.EXPECT, texts = [])], parameterNames = [])
+public void $spock_feature_0_0() {
+    org.spockframework.runtime.ErrorCollector $spock_errorCollector = org.spockframework.runtime.ErrorRethrower.INSTANCE
+    org.spockframework.runtime.ValueRecorder $spock_valueRecorder = new org.spockframework.runtime.ValueRecorder()
+    org.spockframework.runtime.SpockRuntime.callBlockEntered(this, 0)
+    try {
+        org.spockframework.runtime.SpockRuntime.verifyMethodCondition($spock_errorCollector, $spock_valueRecorder.reset(), 'null.with {\n  false\n}', 2, 8, null, $spock_valueRecorder.record($spock_valueRecorder.startRecordingValue(0), null), $spock_valueRecorder.record($spock_valueRecorder.startRecordingValue(1), 'with'), new java.lang.Object[]{$spock_valueRecorder.record($spock_valueRecorder.startRecordingValue(2), { ->
+            false
+        })}, $spock_valueRecorder.realizeNas(5, false), true, 4)
+    }
+    catch (java.lang.Throwable $spock_condition_throwable) {
+        org.spockframework.runtime.SpockRuntime.conditionFailedWithException($spock_errorCollector, $spock_valueRecorder, 'null.with {\n  false\n}', 2, 8, null, $spock_condition_throwable)}
+    finally {
+    }
+    org.spockframework.runtime.SpockRuntime.callBlockExited(this, 0)
+    this.getSpecificationContext().getMockController().leaveScope()
+}