[Test] Refer to inst results.

Via `.result[idx]`.

Author: nate-chandler

docs/SIL.rst

@@ -4361,6 +4361,8 @@ The following types of test arguments are supported:
          Example: @function[foo].block[2]
 - trace: @trace <-- the first ``debug_value [trace]`` in the current function
          @trace[uint] <-- the ``debug_value [trace]`` at index ``uint``
+- value: @{instruction}.result <-- the first result of the instruction
+         @{instruction}.result[uint] <-- the result at index ``uint`` produced by the instruction
          @{function}.{trace} <-- the indicated trace in the indicated function
          Example: @function[bar].trace
 - argument: @argument <-_ the first argument of the current block

lib/SIL/Parser/ParseTestSpecification.cpp

@@ -343,6 +343,28 @@ class ParseArgumentSpecification {
     return OperandArgument{operand};
   }
 
+  SILValue parseResultComponent(SILInstruction *within) {
+    if (!consumePrefix("result"))
+      return nullptr;
+    if (empty()) {
+      auto result = within->getResult(0);
+      return result;
+    }
+    if (auto subscript = parseSubscript()) {
+      auto index = subscript->get<unsigned long long>();
+      auto result = within->getResult(index);
+      return result;
+    }
+    llvm_unreachable("bad suffix after 'result'!?");
+  }
+
+  llvm::Optional<Argument> parseResultReference(SILInstruction *within) {
+    auto result = parseResultComponent(within);
+    if (!result)
+      return llvm::None;
+    return ValueArgument{result};
+  }
+
   SILArgument *parseBlockArgumentComponent(SILBasicBlock *block) {
     if (!consumePrefix("argument"))
       return nullptr;
@@ -414,6 +436,8 @@ class ParseArgumentSpecification {
       return InstructionArgument{instruction};
     if (auto arg = parseOperandReference(instruction))
       return arg;
+    if (auto res = parseResultReference(instruction))
+      return res;
     llvm_unreachable("unhandled suffix after 'instruction'!?");
   }