[Textual SIL] Explicit function arg lifetimes.

Print and parse @_eagerMove and @_lexical on function arguments.

Author: nate-chandler

include/swift/AST/DiagnosticsParse.def

@@ -517,6 +517,9 @@ ERROR(silfunc_and_silarg_have_incompatible_sil_value_ownership,none,
       "SILFunction and SILArgument have mismatching ValueOwnershipKinds. "
       "Function type specifies: '@%0'. SIL argument specifies: '@%1'.",
       (StringRef, StringRef))
+ERROR(sil_arg_both_lexical_and_eagerMove,none,
+      "Function argument is annotated both @_eagerMove and @_lexical, "
+      "but these are incompatible alternatives", ())
 ERROR(expected_sil_colon,none,
       "expected ':' before %0", (StringRef))
 ERROR(expected_sil_tuple_index,none,

lib/SIL/IR/SILPrinter.cpp

@@ -28,6 +28,7 @@
 #include "swift/Demangling/Demangle.h"
 #include "swift/SIL/ApplySite.h"
 #include "swift/SIL/CFG.h"
+#include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILCoverageMap.h"
 #include "swift/SIL/SILDebugScope.h"
 #include "swift/SIL/SILDeclRef.h"
@@ -157,6 +158,7 @@ struct SILValuePrinterInfo {
   SILType Type;
   Optional<ValueOwnershipKind> OwnershipKind;
   bool IsNoImplicitCopy = false;
+  LifetimeAnnotation Lifetime = LifetimeAnnotation::None;
 
   SILValuePrinterInfo(ID ValueID) : ValueID(ValueID), Type(), OwnershipKind() {}
   SILValuePrinterInfo(ID ValueID, SILType Type)
@@ -165,12 +167,14 @@ struct SILValuePrinterInfo {
                       ValueOwnershipKind OwnershipKind)
       : ValueID(ValueID), Type(Type), OwnershipKind(OwnershipKind) {}
   SILValuePrinterInfo(ID ValueID, SILType Type,
-                      ValueOwnershipKind OwnershipKind, bool IsNoImplicitCopy)
+                      ValueOwnershipKind OwnershipKind, bool IsNoImplicitCopy,
+                      LifetimeAnnotation Lifetime)
       : ValueID(ValueID), Type(Type), OwnershipKind(OwnershipKind),
-        IsNoImplicitCopy(IsNoImplicitCopy) {}
-  SILValuePrinterInfo(ID ValueID, SILType Type, bool IsNoImplicitCopy)
+        IsNoImplicitCopy(IsNoImplicitCopy), Lifetime(Lifetime) {}
+  SILValuePrinterInfo(ID ValueID, SILType Type, bool IsNoImplicitCopy,
+                      LifetimeAnnotation Lifetime)
       : ValueID(ValueID), Type(Type), OwnershipKind(),
-        IsNoImplicitCopy(IsNoImplicitCopy) {}
+        IsNoImplicitCopy(IsNoImplicitCopy), Lifetime(Lifetime) {}
 };
 
 /// Return the fully qualified dotted path for DeclContext.
@@ -639,6 +643,16 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     *this << " : ";
     if (i.IsNoImplicitCopy)
       *this << "@noImplicitCopy ";
+    switch (i.Lifetime) {
+    case LifetimeAnnotation::EagerMove:
+      *this << "@_eagerMove ";
+      break;
+    case LifetimeAnnotation::None:
+      break;
+    case LifetimeAnnotation::Lexical:
+      *this << "@_lexical ";
+      break;
+    }
     if (i.OwnershipKind && *i.OwnershipKind != OwnershipKind::None) {
       *this << "@" << i.OwnershipKind.getValue() << " ";
     }
@@ -672,14 +686,15 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     return {Ctx.getID(V), V ? V->getType() : SILType()};
   }
   SILValuePrinterInfo getIDAndType(SILFunctionArgument *arg) {
-    return {Ctx.getID(arg), arg->getType(), arg->isNoImplicitCopy()};
+    return {Ctx.getID(arg), arg->getType(), arg->isNoImplicitCopy(),
+            arg->getLifetimeAnnotation()};
   }
   SILValuePrinterInfo getIDAndTypeAndOwnership(SILValue V) {
     return {Ctx.getID(V), V ? V->getType() : SILType(), V->getOwnershipKind()};
   }
   SILValuePrinterInfo getIDAndTypeAndOwnership(SILFunctionArgument *arg) {
     return {Ctx.getID(arg), arg->getType(), arg->getOwnershipKind(),
-            arg->isNoImplicitCopy()};
+            arg->isNoImplicitCopy(), arg->getLifetimeAnnotation()};
   }
 
   //===--------------------------------------------------------------------===//

lib/SIL/Parser/ParseSIL.cpp

@@ -310,19 +310,19 @@ namespace swift {
       return parseASTType(result, genericSig, genericParams);
     }
 
-    bool parseIsNoImplicitCopy() {
+    Optional<StringRef> parseOptionalAttribute(ArrayRef<StringRef> expected) {
       // We parse here @ <identifier>.
       if (P.Tok.getKind() != tok::at_sign)
-        return false;
+        return llvm::None;
 
-      // Make sure our text is no implicit copy.
-      if (P.peekToken().getText() != "noImplicitCopy")
-        return false;
+      auto name = P.peekToken().getText();
+      if (!is_contained(expected, name))
+        return llvm::None;
 
       // Ok, we can do this.
       P.consumeToken(tok::at_sign);
       P.consumeToken(tok::identifier);
-      return true;
+      return name;
     }
 
     bool parseSILOwnership(ValueOwnershipKind &OwnershipKind) {
@@ -6369,7 +6369,31 @@ bool SILParser::parseSILBasicBlock(SILBuilder &B) {
             P.parseToken(tok::colon, diag::expected_sil_colon_value_ref))
           return true;
 
-        bool foundNoImplicitCopy = parseIsNoImplicitCopy();
+        bool foundNoImplicitCopy = false;
+        bool foundLexical = false;
+        bool foundEagerMove = false;
+        while (auto attributeName = parseOptionalAttribute(
+                   {"noImplicitCopy", "_lexical", "_eagerMove"})) {
+          if (*attributeName == "noImplicitCopy")
+            foundNoImplicitCopy = true;
+          else if (*attributeName == "_lexical")
+            foundLexical = true;
+          else if (*attributeName == "_eagerMove")
+            foundEagerMove = true;
+          else {
+            llvm_unreachable("Unexpected attribute!");
+          }
+        }
+
+        LifetimeAnnotation lifetime = LifetimeAnnotation::None;
+        if (foundEagerMove && foundLexical) {
+          P.diagnose(NameLoc, diag::sil_arg_both_lexical_and_eagerMove);
+          return true;
+        } else if (foundEagerMove) {
+          lifetime = LifetimeAnnotation::EagerMove;
+        } else if (foundLexical) {
+          lifetime = LifetimeAnnotation::Lexical;
+        }
 
         // If SILOwnership is enabled and we are not assuming that we are
         // parsing unqualified SIL, look for printed value ownership kinds.
@@ -6384,6 +6408,7 @@ bool SILParser::parseSILBasicBlock(SILBuilder &B) {
         if (IsEntry) {
           auto *fArg = BB->createFunctionArgument(Ty);
           fArg->setNoImplicitCopy(foundNoImplicitCopy);
+          fArg->setLifetimeAnnotation(lifetime);
           Arg = fArg;
 
           // Today, we construct the ownership kind straight from the function

test/SIL/Parser/function_argument_lifetime_annotation.sil

@@ -0,0 +1,46 @@
+// RUN: %target-sil-opt -enable-objc-interop -enable-lexical-lifetimes=true -enable-sil-verify-all=true %s | %target-sil-opt -enable-objc-interop -enable-lexical-lifetimes=true -enable-sil-verify-all=true | %FileCheck %s
+
+sil_stage canonical
+
+class C {}
+
+// CHECK-LABEL: sil [ossa] @one_arg_eager_move : {{.*}} {
+// CHECK:       {{bb[0-9]+}}({{%[^,]+}} : @_eagerMove @owned $C):
+// CHECK-LABEL: } // end sil function 'one_arg_eager_move'
+sil [ossa] @one_arg_eager_move : $@convention(thin) (@owned C) -> () {
+bb0(%instance : @_eagerMove @owned $C):
+  destroy_value %instance : $C
+  %retval = tuple()
+  return %retval : $()
+}
+
+// CHECK-LABEL: sil [ossa] @one_arg_eager_move_and_no_implicit_copy : {{.*}} {
+// CHECK:       {{bb[0-9]+}}({{%[^,]+}} : @noImplicitCopy @_eagerMove @owned $C):
+// CHECK-LABEL: } // end sil function 'one_arg_eager_move_and_no_implicit_copy'
+sil [ossa] @one_arg_eager_move_and_no_implicit_copy : $(@owned C) -> () {
+bb0(%instance : @noImplicitCopy @_eagerMove @owned $C):
+  destroy_value %instance : $C
+  %retval = tuple()
+  return %retval : $()
+}
+
+// CHECK-LABEL: sil [ossa] @one_arg_lexical : {{.*}} {
+// CHECK:       {{bb[0-9]+}}({{%[^,]+}} : @_lexical @owned $C):
+// CHECK-LABEL: } // end sil function 'one_arg_lexical'
+sil [ossa] @one_arg_lexical : $@convention(thin) (@owned C) -> () {
+bb0(%instance : @_lexical @owned $C):
+  destroy_value %instance : $C
+  %retval = tuple()
+  return %retval : $()
+}
+
+// CHECK-LABEL: sil [ossa] @one_arg_lexical_and_no_implicit_copy : {{.*}} {
+// CHECK:       {{bb[0-9]+}}({{%[^,]+}} : @noImplicitCopy @_lexical @owned $C):
+// CHECK-LABEL: } // end sil function 'one_arg_lexical_and_no_implicit_copy'
+sil [ossa] @one_arg_lexical_and_no_implicit_copy : $@convention(thin) (@owned C) -> () {
+bb0(%instance : @noImplicitCopy @_lexical @owned $C):
+  destroy_value %instance : $C
+  %retval = tuple()
+  return %retval : $()
+}
+