[Test] Print helpful info on bad unit tests.

If a unit test is miswritten in the sense that the test expects an
instance of one type by an instance of some other type is specified,
print that out.

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(