[Test] Moved test-spec parsing test to Swift.

To prove out that the bridging works.

Author: nate-chandler

SwiftCompilerSources/Sources/SIL/Test.swift

@@ -148,4 +148,72 @@ private func registerFunctionTest(
 }
 
 public func registerSILTests() {
+  registerFunctionTest(parseTestSpecificationTest, implementation: { parseTestSpecificationTest.run($0, $1, $2) })
 }
+
+// Arguments:
+// - string: list of characters, each of which specifies subsequent arguments
+//           - A: (block) argument
+//           - F: function
+//           - B: block
+//           - I: instruction
+//           - V: value
+//           - O: operand
+//           - b: boolean
+//           - u: unsigned
+//           - s: string
+// - ...
+// - an argument of the type specified in the initial string
+// - ...
+// Dumps:
+// - for each argument (after the initial string)
+//   - its type
+//   - something to identify the instance (mostly this means calling dump)
+let parseTestSpecificationTest = 
+FunctionTest(name: "test_specification_parsing") { function, arguments, context in 
+  struct _Stderr : TextOutputStream {
+    public init() {}
+
+    public mutating func write(_ string: String) {
+      for c in string.utf8 {
+        _swift_stdlib_putc_stderr(CInt(c))
+      }
+    }
+  }
+  var stderr = _Stderr()
+  let expectedFields = arguments.takeString()
+  for expectedField in expectedFields.string {
+    switch expectedField {
+    case "A":
+      let argument = arguments.takeArgument()
+      print("argument:\n\(argument)", to: &stderr)
+    case "F":
+      let function = arguments.takeFunction()
+      print("function: \(function.name)", to: &stderr)
+    case "B":
+      let block = arguments.takeBlock()
+      print("block:\n\(block)", to: &stderr)
+    case "I":
+      let instruction = arguments.takeInstruction()
+      print("instruction: \(instruction)", to: &stderr)
+    case "V":
+      let value = arguments.takeValue()
+      print("value: \(value)", to: &stderr)
+    case "O":
+      let operand = arguments.takeOperand()
+      print("operand: \(operand)", to: &stderr)
+    case "u":
+      let u = arguments.takeInt()
+      print("uint: \(u)", to: &stderr)
+    case "b":
+      let b = arguments.takeBool()
+      print("bool: \(b)", to: &stderr)
+    case "s":
+      let s = arguments.takeString()
+      print("string: \(s)", to: &stderr)
+    default:
+      fatalError("unknown field type was expected?!");
+    }
+  }
+}
+

lib/SILOptimizer/UtilityPasses/TestRunner.cpp

@@ -148,85 +148,6 @@ static FunctionTest FunctionGetSelfArgumentIndex(
       llvm::errs() << "self argument index = " << index << "\n";
     });
 
-// Arguments:
-// - string: list of characters, each of which specifies subsequent arguments
-//           - A: (block) argument
-//           - F: function
-//           - B: block
-//           - I: instruction
-//           - V: value
-//           - O: operand
-//           - b: boolean
-//           - u: unsigned
-//           - s: string
-// - ...
-// - an argument of the type specified in the initial string
-// - ...
-// Dumps:
-// - for each argument (after the initial string)
-//   - its type
-//   - something to identify the instance (mostly this means calling dump)
-static FunctionTest TestSpecificationTest(
-    "test_specification_parsing",
-    [](auto &function, auto &arguments, auto &test) {
-      auto expectedFields = arguments.takeString();
-      for (auto expectedField : expectedFields) {
-        switch (expectedField) {
-        case 'A': {
-          auto *argument = arguments.takeBlockArgument();
-          llvm::errs() << "argument:\n";
-          argument->dump();
-          break;
-        }
-        case 'F': {
-          auto *function = arguments.takeFunction();
-          llvm::errs() << "function: " << function->getName() << "\n";
-          break;
-        }
-        case 'B': {
-          auto *block = arguments.takeBlock();
-          llvm::errs() << "block:\n";
-          block->dump();
-          break;
-        }
-        case 'I': {
-          auto *instruction = arguments.takeInstruction();
-          llvm::errs() << "instruction: ";
-          instruction->dump();
-          break;
-        }
-        case 'V': {
-          auto value = arguments.takeValue();
-          llvm::errs() << "value: ";
-          value->dump();
-          break;
-        }
-        case 'O': {
-          auto *operand = arguments.takeOperand();
-          llvm::errs() << "operand: ";
-          operand->print(llvm::errs());
-          break;
-        }
-        case 'u': {
-          auto u = arguments.takeUInt();
-          llvm::errs() << "uint: " << u << "\n";
-          break;
-        }
-        case 'b': {
-          auto b = arguments.takeBool();
-          llvm::errs() << "bool: " << b << "\n";
-          break;
-        }
-        case 's': {
-          auto s = arguments.takeString();
-          llvm::errs() << "string: " << s << "\n";
-          break;
-        }
-        default:
-          llvm_unreachable("unknown field type was expected?!");
-        }
-      }
-    });
 } // namespace swift::test
 
 //===----------------------------------------------------------------------===//

test/SILOptimizer/test_specification_parsing.sil

@@ -1,5 +1,7 @@
 // RUN: %target-sil-opt -test-runner %s 2>&1 | %FileCheck %s
 
+// REQUIRES: swift_in_compiler
+
 sil_stage raw
 
 import Builtin
@@ -8,8 +10,8 @@ import Builtin
 // CHECK: test_arg_parsing_reference
 // CHECK: test_arg_parsing_referenceable
 // CHECK: test_arg_parsing
-// CHECK: bool: 1
-// CHECK: bool: 0
+// CHECK: bool: true
+// CHECK: bool: false
 // CHECK-LABEL: end running test 1 of {{[^,]+}} on test_arg_parsing: test_specification_parsing
 // CHECK-LABEL: begin running test 2 of {{[^,]+}} on test_arg_parsing: test_specification_parsing
 // CHECK: block:
@@ -45,10 +47,8 @@ import Builtin
 // CHECK: instruction: // function_ref something_remarkable
 // CHECK-LABEL: end running test 5 of {{[^,]+}} on test_arg_parsing: test_specification_parsing
 // CHECK-LABEL: begin running test 6 of {{[^,]+}} on test_arg_parsing: test_specification_parsing
-// CHECK: operand: 
-// CHECK: Owner:   return {{%[^,]+}} : $()
-// CHECK: operand:
-// CHECK: Value:   {{%[^,]+}} = tuple ({{%[^,]+}} : $())
+// CHECK: operand: operand #0 of return {{%[^,]+}} : $()
+// CHECK: operand: operand #1 of {{%[^,]+}} = tuple
 // CHECK-LABEL: end running test 6 of {{[^,]+}} on test_arg_parsing: test_specification_parsing
 // CHECK-LABEL: begin running test 7 of {{[^,]+}} on test_arg_parsing: test_specification_parsing
 // CHECK: value: {{%[^,]+}} = tuple ({{%[^,]+}} : $(), {{%[^,]+}} : $(_: ()), {{%[^,]+}} : $((), (_: ())))