Merge pull request #63170 from nate-chandler/rdar104021173

[Test] Print helpful info on malformed unit test.

Author: nate-chandler

include/swift/SILOptimizer/Utils/ParseTestSpecification.h

@@ -19,9 +19,12 @@
 
 #include "swift/Basic/TaggedUnion.h"
 #include "swift/SIL/SILArgument.h"
+#include "swift/SIL/SILBasicBlock.h"
+#include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILValue.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/FormattedStream.h"
 
 namespace llvm {
 template <class T>
@@ -68,10 +71,15 @@ struct Argument {
 
 public:
   Kind getKind() const { return kind; }
+  void print(llvm::raw_ostream &os);
+#ifndef NDEBUG
+  void dump() { print(llvm::errs()); }
+#endif
 };
 
-template <typename Stored, Argument::Kind TheKind>
+template <typename _Stored, Argument::Kind TheKind>
 struct ConcreteArgument : Argument {
+  using Stored = _Stored;
   using Super = ConcreteArgument<Stored, TheKind>;
   ConcreteArgument(Stored stored) : Argument(Union{stored}, TheKind) {}
   Stored getValue() { return storage.get<Stored>(); }
@@ -142,13 +150,28 @@ struct Arguments {
   Arguments &operator=(Arguments const &) = delete;
   ~Arguments() { assertUsed(); }
   Argument &takeArgument() { return storage[untakenIndex++]; }
-  StringRef takeString() {
-    return cast<StringArgument>(takeArgument()).getValue();
+
+private:
+  template <typename Subtype>
+  typename Subtype::Stored getInstance(StringRef name, Argument &argument) {
+    if (isa<Subtype>(argument)) {
+      auto string = cast<Subtype>(argument).getValue();
+      return string;
+    }
+    llvm::errs() << "Attempting to take a " << name << " argument but have\n";
+    argument.print(llvm::errs());
+    llvm::report_fatal_error("Bad unit test");
   }
-  bool takeBool() { return cast<BoolArgument>(takeArgument()).getValue(); }
-  unsigned long long takeUInt() {
-    return cast<UIntArgument>(takeArgument()).getValue();
+  template <typename Subtype>
+  typename Subtype::Stored takeInstance(StringRef name) {
+    auto argument = takeArgument();
+    return getInstance<Subtype>(name, argument);
   }
+
+public:
+  StringRef takeString() { return takeInstance<StringArgument>("string"); }
+  bool takeBool() { return takeInstance<BoolArgument>("bool"); }
+  unsigned long long takeUInt() { return takeInstance<UIntArgument>("uint"); }
   SILValue takeValue() {
     auto argument = takeArgument();
     if (isa<InstructionArgument>(argument)) {
@@ -159,22 +182,18 @@ struct Arguments {
       auto *arg = cast<BlockArgumentArgument>(argument).getValue();
       return arg;
     }
-    return cast<ValueArgument>(argument).getValue();
-  }
-  Operand *takeOperand() {
-    return cast<OperandArgument>(takeArgument()).getValue();
+    return getInstance<ValueArgument>("value", argument);
   }
+  Operand *takeOperand() { return takeInstance<OperandArgument>("operand"); }
   SILInstruction *takeInstruction() {
-    return cast<InstructionArgument>(takeArgument()).getValue();
+    return takeInstance<InstructionArgument>("instruction");
   }
   SILArgument *takeBlockArgument() {
-    return cast<BlockArgumentArgument>(takeArgument()).getValue();
-  }
-  SILBasicBlock *takeBlock() {
-    return cast<BlockArgument>(takeArgument()).getValue();
+    return takeInstance<BlockArgumentArgument>("block argument");
   }
+  SILBasicBlock *takeBlock() { return takeInstance<BlockArgument>("block"); }
   SILFunction *takeFunction() {
-    return cast<FunctionArgument>(takeArgument()).getValue();
+    return takeInstance<FunctionArgument>("block");
   }
 };
 

lib/SILOptimizer/UtilityPasses/ParseTestSpecification.cpp

@@ -584,6 +584,46 @@ SILValue ParseArgumentSpecification::getTraceValue(unsigned index,
 
 } // anonymous namespace
 
+// Member function implementations
+
+void Argument::print(llvm::raw_ostream &os) {
+  switch (kind) {
+  case Kind::Value:
+    llvm::errs() << "value:\n";
+    cast<ValueArgument>(*this).getValue()->print(os);
+    break;
+  case Kind::Operand:
+    os << "operand:\n";
+    cast<OperandArgument>(*this).getValue()->print(os);
+    break;
+  case Kind::Instruction:
+    os << "instruction:\n";
+    cast<InstructionArgument>(*this).getValue()->print(os);
+    break;
+  case Kind::BlockArgument:
+    os << "block argument:\n";
+    cast<BlockArgumentArgument>(*this).getValue()->print(os);
+    break;
+  case Kind::Block:
+    os << "block:\n";
+    cast<BlockArgument>(*this).getValue()->print(os);
+    break;
+  case Kind::Function:
+    os << "function:\n";
+    cast<FunctionArgument>(*this).getValue()->print(os);
+    break;
+  case Kind::Bool:
+    os << "bool: " << cast<BoolArgument>(*this).getValue() << "\n";
+    break;
+  case Kind::UInt:
+    os << "uint: " << cast<UIntArgument>(*this).getValue() << "\n";
+    break;
+  case Kind::String:
+    os << "string: " << cast<StringArgument>(*this).getValue() << "\n";
+    break;
+  }
+}
+
 // API
 
 void swift::test::getTestSpecifications(

lib/SILOptimizer/UtilityPasses/UnitTestRunner.cpp

@@ -501,9 +501,11 @@ struct SimplifyCFGSimplifyArgument : UnitTest {
     auto *passToRun = cast<SILFunctionTransform>(createSimplifyCFG());
     passToRun->injectPassManager(getPass()->getPassManager());
     passToRun->injectFunction(getFunction());
+    auto *block = arguments.takeBlock();
+    auto index = arguments.takeUInt();
     SimplifyCFG(*getFunction(), *passToRun, /*VerifyAll=*/false,
                 /*EnableJumpThread=*/false)
-        .simplifyArgument(arguments.takeBlock(), arguments.takeUInt());
+        .simplifyArgument(block, index);
   }
 };
 

test/SILOptimizer/simplify_cfg_ossa_bbargs.sil

@@ -1,8 +1,5 @@
 // RUN: %target-sil-opt -unit-test-runner %s | %FileCheck %s
 
-// Test fails in Windows CI - rdar://104021173
-// UNSUPPORTED: OS=windows-msvc
-
 import Builtin
 
 class Klass {}

test/SILOptimizer/unit_test.sil

@@ -205,3 +205,19 @@ exit(%owned : @owned $C, %guaranteed_1 : @guaranteed $C, %guaranteed_2 : @guaran
   %retval = tuple ()
   return %retval : $()
 }
+
+// CHECK-LABEL: begin running test 1 of {{[^,]+}} on test_arg_parsing_2
+// CHECK:       block:
+// CHECK:       {{bb[0-9]+}}:
+// CHECK:         {{%[^,]+}} = tuple ()
+// CHECK:         return {{%[^,]+}}
+// CHECK:       uint: 0
+// CHECK-LABEL: end running test 1 of {{[^,]+}} on test_arg_parsing_2
+sil @test_arg_parsing_2 : $() -> () {
+entry:
+  test_specification "test-specification-parsing Bu @block[1] 0"
+  br exit
+exit:
+  %retval = tuple ()
+  return %retval : $()
+}