[SIL] Renamed specify_test instruction.

Changed from test_specification which is too many characters and
insufficiently active.

Author: nate-chandler

docs/SIL.rst

@@ -4330,13 +4330,13 @@ It is code-generated to a NOP instruction.
 Testing
 ~~~~~~~
 
-test_specification
-``````````````````
+specify_test
+````````````
 ::
 
-  sil-instruction ::= 'test_specification' string-literal
+  sil-instruction ::= 'specify_test' string-literal
 
-  test_specification "parsing @trace[3] @function[other].block[2].instruction[1]"
+  specify_test "parsing @trace[3] @function[other].block[2].instruction[1]"
 
 Exists only for writing FileCheck tests.  Specifies a list of test arguments
 which should be used in order to run a particular test "in the context" of the
@@ -4349,10 +4349,11 @@ The following types of test arguments are supported:
 - boolean: true false
 - unsigned integer: 0...ULONG_MAX
 - string
+- value: %name
 - function: @function <-- the current function
             @function[uint] <-- function at index ``uint``
             @function[name] <-- function named ``name``
-- block: @block <-- the block containing the test_specification instruction
+- block: @block <-- the block containing the specify_test instruction
          @block[+uint] <-- the block ``uint`` blocks after the containing block
          @block[-uint] <-- the block ``uint`` blocks before the containing block
          @block[uint] <-- the block at index ``uint``
@@ -4366,9 +4367,9 @@ The following types of test arguments are supported:
             @argument[uint] <-- the argument at index ``uint`` of the current block
             @{block}.{argument} <-- the indicated argument in the indicated block
             @{function}.{argument} <-- the indicated argument in the entry block of the indicated function
-- instruction: @instruction <-- the instruction after* the test_specification instruction
-               @instruction[+uint] <-- the instruction ``uint`` instructions after* the test_specification instruction
-               @instruction[-uint] <-- the instruction ``uint`` instructions before* the test_specification instruction
+- instruction: @instruction <-- the instruction after* the specify_test instruction
+               @instruction[+uint] <-- the instruction ``uint`` instructions after* the specify_test instruction
+               @instruction[-uint] <-- the instruction ``uint`` instructions before* the specify_test instruction
                @instruction[uint] <-- the instruction at index ``uint``
                @{function}.{instruction} <-- the indicated instruction in the indicated function
                Example: @function[baz].instruction[19]
@@ -4383,7 +4384,7 @@ The following types of test arguments are supported:
 * Not counting instructions that are deleted when processing functions for tests.
   The following instructions currently are deleted:
 
-      test_specification
+      specify_test
       debug_value [trace]
 
 

include/swift/AST/DiagnosticsParse.def

@@ -545,7 +545,7 @@ ERROR(expected_sil_profiler_counter_total,none,
       "expected profiler counter total", ())
 ERROR(expected_sil_profiler_counter_hash,none,
       "expected profiler counter hash", ())
-ERROR(expected_sil_test_specification_body,none,
+ERROR(expected_sil_specify_test_body,none,
       "expected a string consisting of the space-separated test arguments", ())
 
 // SIL Values

include/swift/SIL/ParseTestSpecification.h

@@ -219,13 +219,13 @@ struct UnparsedSpecification {
 void getTestSpecificationComponents(StringRef specificationString,
                                     SmallVectorImpl<StringRef> &components);
 
-/// Finds and deletes each test_specification instruction in \p function and
+/// Finds and deletes each specify_test instruction in \p function and
 /// appends its string payload to the provided vector.
 void getTestSpecifications(
     SILFunction *function,
     SmallVectorImpl<UnparsedSpecification> &specifications);
 
-/// Given the string \p specification operand of a test_specification
+/// Given the string \p specification operand of a specify_test
 /// instruction from \p function, parse the arguments which it refers to into
 /// \p arguments and the component strings into \p argumentStrings.
 void parseTestArgumentsFromSpecification(

include/swift/SIL/SILNodes.def

@@ -836,7 +836,7 @@ NON_VALUE_INST(DebugValueInst, debug_value,
                SILInstruction, None, DoesNotRelease)
 NON_VALUE_INST(DebugStepInst, debug_step,
                SILInstruction, MayHaveSideEffects, DoesNotRelease)
-NON_VALUE_INST(TestSpecificationInst, test_specification,
+NON_VALUE_INST(TestSpecificationInst, specify_test,
                SILInstruction, None, DoesNotRelease)
 #define NEVER_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, name, ...) \
   NON_VALUE_INST(Store##Name##Inst, store_##name, \

include/swift/SIL/Test.h

@@ -1,4 +1,4 @@
-//===---- Test.h - Testing based on test_specification insts -*- C++ ----*-===//
+//===---- Test.h - Testing based on specify_test insts -*- C++ ----*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -26,7 +26,7 @@
 // of a function.  The goal is to get the same effect as calling a function and
 // checking its output.
 //
-// This is done via the test_specification instruction.  Using one or more
+// This is done via the specify_test instruction.  Using one or more
 // instances of it in your test case's SIL function, you can specify which test
 // (instance of FunctionTest) should be run and what arguments should be
 // provided to it.  The test grabs the arguments it expects out of the
@@ -59,10 +59,10 @@
 //    TestRunner pass:
 //     // RUN: %target-sil-opt -test-runner %s -o /dev/null 2>&1 | %FileCheck %s
 // 2) A function in interesting_functionality_unit.sil contains the
-//    test_specification instruction.
+//    specify_test instruction.
 //      sil @f : $() -> () {
 //      ...
-//      test_specification "my-neato-utility 43 @trace[2] @function[other_fun]"
+//      specify_test "my-neato-utility 43 @trace[2] @function[other_fun]"
 //      ...
 //      }
 // 3) TestRunner finds the FunctionTest instance MyNeatoUtilityTest registered
@@ -109,18 +109,18 @@ namespace test {
 struct Arguments;
 class TestRunner;
 
-/// A test that is run when the corresponding test_specification instruction is
+/// A test that is run when the corresponding specify_test instruction is
 /// processed by the TestRunner pass.
 ///
 /// Tests are instantiated once at program launch.  At that time, they are
-/// stored in a registry name -> test.  When an test_specification instruction
+/// stored in a registry name -> test.  When an specify_test instruction
 /// naming a particular test is processed, that test is run.
 class FunctionTest final {
 public:
   /// Wraps a test lambda.
   ///
   /// There are three arguments in order of priority:
-  /// - SILFunction & - the function with the test_specification instruction
+  /// - SILFunction & - the function with the specify_test instruction
   /// - Arguments & - the resolved list of args specified by the instruction
   /// - FunctionTest & - the test being run; used to find less commonly used
   ///                    values such as the results of analyses

lib/SIL/Parser/ParseSIL.cpp

@@ -3777,7 +3777,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
   case SILInstructionKind::TestSpecificationInst: {
     // Parse the specification string.
     if (P.Tok.getKind() != tok::string_literal) {
-      P.diagnose(P.Tok, diag::expected_sil_test_specification_body);
+      P.diagnose(P.Tok, diag::expected_sil_specify_test_body);
       return true;
     }
     // Drop the double quotes.

lib/SIL/Parser/ParseTestSpecification.cpp

@@ -347,7 +347,7 @@ class ParseArgumentSpecification {
     if (!consumePrefix("argument"))
       return nullptr;
     // If this is a bare @argument reference, it refers to the first argument
-    // of the block containing the test_specification.
+    // of the block containing the specify_test.
     if (!block) {
       block = context->getParent();
     }
@@ -385,15 +385,15 @@ class ParseArgumentSpecification {
     if (empty() || peekPrefix(".")) {
       if (!within) {
         // If this is a bare @instruction reference, it refers to to the
-        // context of the test_specification.
+        // context of the specify_test.
         return context;
       }
       return getInstructionAtIndex(0, *within);
     }
     if (auto subscript = parseSubscript()) {
       // If this is a bare @instruction[...] reference, it can refer either to
       // an instruction counting from the beginning of the function or else to
-      // an instruction offset from the context of the test_specification.
+      // an instruction offset from the context of the specify_test.
       if (!within && subscript->isa<long long>()) {
         auto offset = subscript->get<long long>();
         return getInstructionOffsetFrom(context, offset);
@@ -422,7 +422,7 @@ class ParseArgumentSpecification {
       return nullptr;
     if (empty() || peekPrefix(".")) {
       // If this is a bare @block reference, it refers to the block containing
-      // the test_specification instruction.
+      // the specify_test instruction.
       if (!within) {
         return context->getParent();
       }
@@ -432,7 +432,7 @@ class ParseArgumentSpecification {
     if (auto subscript = parseSubscript()) {
       // If this is a bare @block[...] reference, it can refer either to a block
       // counting from the beginning of the function or else to a block offset
-      // from the block containing the context of the test_specification.
+      // from the block containing the context of the specify_test.
       if (!within && subscript->isa<long long>()) {
         return getBlockOffsetFrom(context->getParent(),
                                   subscript->get<long long>());
@@ -462,7 +462,7 @@ class ParseArgumentSpecification {
       return nullptr;
     if (empty() || peekPrefix(".")) {
       // If this is a bare @function reference, it refers to the function
-      // containing the test_specification instruction.
+      // containing the specify_test instruction.
       if (!within) {
         return context->getFunction();
       }

test/SIL/OwnershipVerifier/guaranteed_chain.sil

@@ -15,7 +15,7 @@ struct PairC {
 //
 sil [ossa] @testSSALongForwardingChain : $@convention(thin) (@guaranteed C) -> () {
 bb0(%0 : @guaranteed $C):
-  test_specification "ssa-liveness @trace[0]"
+  specify_test "ssa-liveness @trace[0]"
   debug_value [trace] %0 : $C
   %s0 = struct $PairC(%0 : $C, %0 : $C)
   %s0a = struct_extract %s0 : $PairC, #PairC.first

test/SIL/Parser/test_instructions.sil

@@ -8,12 +8,12 @@ import Builtin
 //
 // In particular, this doesn't test parsing the components that make up the test
 // specification.
-// CHECK-LABEL: sil [ossa] @for_test_specification : {{.*}} {
-// CHECK:       test_specification "try-running-it foo bar 18 false baz"
-// CHECK-LABEL: } // end sil function 'for_test_specification'
-sil [ossa] @for_test_specification : $@convention(thin) () -> () {
+// CHECK-LABEL: sil [ossa] @for_specify_test : {{.*}} {
+// CHECK:       specify_test "try-running-it foo bar 18 false baz"
+// CHECK-LABEL: } // end sil function 'for_specify_test'
+sil [ossa] @for_specify_test : $@convention(thin) () -> () {
 entry:
-  test_specification "try-running-it foo bar 18 false baz"
+  specify_test "try-running-it foo bar 18 false baz"
   %4 = tuple()
   return %4 : $()
 }

test/SIL/cloning.sil

@@ -108,18 +108,18 @@ entry(%0 : @owned $X):
   return %res : $X
 }
 
-// CHECK-LABEL: sil [ossa] @caller_test_specification : {{.*}} {
-// CHECK:         test_specification "foo bar baz"
-// CHECK-LABEL: } // end sil function 'caller_test_specification'
-sil [always_inline] [ossa] @callee_test_specification : $@convention(thin) () -> () {
+// CHECK-LABEL: sil [ossa] @caller_specify_test : {{.*}} {
+// CHECK:         specify_test "foo bar baz"
+// CHECK-LABEL: } // end sil function 'caller_specify_test'
+sil [always_inline] [ossa] @callee_specify_test : $@convention(thin) () -> () {
 entry:
-  test_specification "foo bar baz"
+  specify_test "foo bar baz"
   %retval = tuple ()
   return %retval : $()
 }
 
-sil [ossa] @caller_test_specification : $@convention(thin) () -> () {
-  %callee = function_ref @callee_test_specification : $@convention(thin) () -> ()
+sil [ossa] @caller_specify_test : $@convention(thin) () -> () {
+  %callee = function_ref @callee_specify_test : $@convention(thin) () -> ()
   %retval = apply %callee() : $@convention(thin) () -> ()
   return %retval : $()
 }