Merge pull request swiftlang#27353 from ravikandhadai/constexpr-test

[Constant Evaluator][Test] Add tests to check whether fatal errors are detected

Author: ravikandhadai

lib/SILOptimizer/UtilityPasses/ConstantEvaluableSubsetChecker.cpp

@@ -74,10 +74,6 @@ class ConstantEvaluableSubsetChecker : public SILModuleTransform {
       if (isa<ReturnInst>(inst))
         break;
 
-      assert(!previousEvaluationHadFatalError &&
-             "cannot continue evaluation of test driver as previous call "
-             "resulted in non-skippable evaluation error.");
-
       auto *applyInst = dyn_cast<ApplyInst>(inst);
       SILFunction *callee = nullptr;
       if (applyInst) {
@@ -89,6 +85,16 @@ class ConstantEvaluableSubsetChecker : public SILModuleTransform {
 
       if (!applyInst || !callee ||
           !callee->hasSemanticsAttr(constantEvaluableSemanticsAttr)) {
+
+        // Ignore these instructions if we had a fatal error already.
+        if (previousEvaluationHadFatalError) {
+          if (isa<TermInst>(inst)) {
+            assert(false && "non-constant control flow in the test driver");
+          }
+          ++currI;
+          continue;
+        }
+
         std::tie(nextInstOpt, errorVal) =
             stepEvaluator.tryEvaluateOrElseMakeEffectsNonConstant(currI);
         if (!nextInstOpt) {
@@ -100,6 +106,10 @@ class ConstantEvaluableSubsetChecker : public SILModuleTransform {
         continue;
       }
 
+      assert(!previousEvaluationHadFatalError &&
+             "cannot continue evaluation of test driver as previous call "
+             "resulted in non-skippable evaluation error.");
+
       // Here, a function annotated as "constant_evaluable" is called.
       llvm::errs() << "@" << demangleSymbolName(callee->getName()) << "\n";
       std::tie(nextInstOpt, errorVal) =

test/SILOptimizer/constant_evaluable_subset_test.swift

@@ -350,6 +350,19 @@ func interpretDivideByZero() -> Int {
   return testDivideByZero(127, 0)
 }
 
+// CHECK-LABEL: @testDividingFullWidthByZero
+// CHECK: error: not constant evaluable
+@_semantics("constant_evaluable")
+func testDividingFullWidthByZero(_ x: Int, _ y: Int, _ z: UInt) -> Int {
+  return x.dividingFullWidth((y, z)).1
+} // CHECK: note: {{.*}}: Division by zero
+  // CHECK: note: operation performed during this call traps
+
+@_semantics("test_driver")
+func interpretDividingFullWidthByZero() -> Int {
+  return testDividingFullWidthByZero(0, 1, 1)
+}
+
 // CHECK-LABEL: @testDivideOverflow
 // CHECK: error: not constant evaluable
 @_semantics("constant_evaluable")
@@ -364,6 +377,20 @@ func interpretDivideOverflow() -> Int8 {
   return testDivideOverflow(-128, -1)
 }
 
+// CHECK-LABEL: @testDistance
+// CHECK: error: not constant evaluable
+@_semantics("constant_evaluable")
+func testDistance(_ x: UInt, _ y: UInt) -> Int {
+  return x.distance(to: y)
+    // CHECK: note: {{.*}}: Distance is not representable in Int
+    // CHECK: note: operation performed during this call traps
+}
+
+@_semantics("test_driver")
+func interpretDistanceTest() -> Int {
+  return testDistance(0, UInt.max)
+}
+
 // CHECK-LABEL: @testInOut
 // CHECK-NOT: error:
 @_semantics("constant_evaluable")