Add Sema support for LifetimeDependence

Author: meg-gupta

include/swift/AST/DiagnosticsSema.def

@@ -7765,5 +7765,23 @@ ERROR(result_depends_on_no_result,none,
 ERROR(pack_iteration_where_clause_not_supported, none,
       "'where' clause in pack iteration is not supported", ())
 
+
+ //------------------------------------------------------------------------------
+ // MARK: Lifetime Dependence Diagnostics
+ //------------------------------------------------------------------------------
+
+ ERROR(lifetime_dependence_invalid_param_name, none,
+       "invalid parameter name specified %0", (Identifier))
+ ERROR(lifetime_dependence_invalid_param_index, none,
+       "invalid parameter index specified %0", (unsigned))
+ ERROR(lifetime_dependence_invalid_self, none,
+       "invalid lifetime dependence specifier, self is valid in non-static "
+       "methods only", ())
+ ERROR(lifetime_dependence_duplicate_param_id, none,
+       "duplicate lifetime dependence specifier", ())
+ ERROR(lifetime_dependence_cannot_use_kind, none,
+       "invalid use of %0 lifetime dependence for %1 ownership",
+       (StringRef, StringRef))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/ExtInfo.h

@@ -85,6 +85,27 @@ class ClangTypeInfo {
   void dump(llvm::raw_ostream &os, const clang::ASTContext &ctx) const;
 };
 
+class LifetimeDependenceInfo {
+  IndexSubset *copyLifetimeParamIndices;
+  IndexSubset *borrowLifetimeParamIndices;
+
+public:
+  LifetimeDependenceInfo()
+      : copyLifetimeParamIndices(nullptr), borrowLifetimeParamIndices(nullptr) {
+  }
+  LifetimeDependenceInfo(IndexSubset *copyLifetimeParamIndices,
+                         IndexSubset *borrowLifetimeParamIndices)
+      : copyLifetimeParamIndices(copyLifetimeParamIndices),
+        borrowLifetimeParamIndices(borrowLifetimeParamIndices) {}
+
+  operator bool() const { return empty(); }
+
+  bool empty() const {
+    return copyLifetimeParamIndices == nullptr &&
+           borrowLifetimeParamIndices == nullptr;
+  }
+};
+
 // MARK: - UnexpectedClangTypeError
 /// Potential errors when trying to store a Clang type in an ExtInfo.
 struct UnexpectedClangTypeError {

include/swift/AST/LifetimeDependence.h

@@ -93,6 +93,17 @@ class LifetimeDependenceSpecifier {
     assert(specifierKind == SpecifierKind::Ordered);
     return value.Ordered.index;
   }
+  std::string getParamString() const {
+    switch (specifierKind) {
+    case SpecifierKind::Named:
+      return value.Named.name.str().str();
+    case SpecifierKind::Self:
+      return "self";
+    case SpecifierKind::Ordered:
+      return std::to_string(value.Ordered.index);
+    }
+    llvm_unreachable("Invalid LifetimeDependenceSpecifier::SpecifierKind");
+  }
 };
 } // namespace swift
 

include/swift/AST/Ownership.h

@@ -142,6 +142,19 @@ enum class ValueOwnership : uint8_t {
 enum : unsigned { NumValueOwnershipBits =
   countBitsUsed(static_cast<unsigned>(ValueOwnership::Last_Kind)) };
 
+static inline llvm::StringRef getOwnershipSpelling(ValueOwnership ownership) {
+  switch (ownership) {
+  case ValueOwnership::Default:
+    return "";
+  case ValueOwnership::InOut:
+    return "inout";
+  case ValueOwnership::Shared:
+    return "borrowing";
+  case ValueOwnership::Owned:
+    return "consuming";
+  }
+  llvm_unreachable("Invalid ValueOwnership");
+}
 } // end namespace swift
 
 #endif

include/swift/AST/TypeRepr.h

@@ -22,14 +22,15 @@
 #include "swift/AST/DiagnosticEngine.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/Identifier.h"
+#include "swift/AST/LifetimeDependence.h"
 #include "swift/AST/Type.h"
 #include "swift/AST/TypeAlignments.h"
+#include "swift/Basic/Debug.h"
+#include "swift/Basic/InlineBitfield.h"
+#include "swift/Basic/Located.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/STLExtras.h"
-#include "swift/Basic/Debug.h"
-#include "swift/Basic/Located.h"
-#include "swift/Basic/InlineBitfield.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/TrailingObjects.h"
 
@@ -109,6 +110,10 @@ class alignas(1 << TypeReprAlignInBits) TypeRepr
     NumElements : 32
   );
 
+  SWIFT_INLINE_BITFIELD_FULL(LifetimeDependentReturnTypeRepr, TypeRepr, 32,
+      : NumPadBits,
+      NumDependencies : 32
+   );
   } Bits;
   // clang-format on
 
@@ -1093,7 +1098,8 @@ class SpecifierTypeRepr : public TypeRepr {
     return T->getKind() == TypeReprKind::Ownership ||
            T->getKind() == TypeReprKind::Isolated ||
            T->getKind() == TypeReprKind::CompileTimeConst ||
-           T->getKind() == TypeReprKind::ResultDependsOn;
+           T->getKind() == TypeReprKind::ResultDependsOn ||
+           T->getKind() == TypeReprKind::LifetimeDependentReturn;
   }
   static bool classof(const SpecifierTypeRepr *T) { return true; }
 
@@ -1505,6 +1511,50 @@ class SILBoxTypeRepr final : public TypeRepr,
   friend TypeRepr;
 };
 
+class LifetimeDependentReturnTypeRepr final
+    : public SpecifierTypeRepr,
+      private llvm::TrailingObjects<LifetimeDependentReturnTypeRepr,
+                                    LifetimeDependenceSpecifier> {
+  friend TrailingObjects;
+
+  size_t
+  numTrailingObjects(OverloadToken<LifetimeDependentReturnTypeRepr>) const {
+    return Bits.LifetimeDependentReturnTypeRepr.NumDependencies;
+  }
+
+public:
+  LifetimeDependentReturnTypeRepr(
+      TypeRepr *base, ArrayRef<LifetimeDependenceSpecifier> specifiers)
+      : SpecifierTypeRepr(TypeReprKind::LifetimeDependentReturn, base,
+                          specifiers.front().getLoc()) {
+    assert(base);
+    Bits.LifetimeDependentReturnTypeRepr.NumDependencies = specifiers.size();
+    std::uninitialized_copy(specifiers.begin(), specifiers.end(),
+                            getTrailingObjects<LifetimeDependenceSpecifier>());
+  }
+
+  static LifetimeDependentReturnTypeRepr *
+  create(ASTContext &C, TypeRepr *base,
+         ArrayRef<LifetimeDependenceSpecifier> specifiers);
+
+  ArrayRef<LifetimeDependenceSpecifier> getLifetimeDependencies() const {
+    return {getTrailingObjects<LifetimeDependenceSpecifier>(),
+            Bits.LifetimeDependentReturnTypeRepr.NumDependencies};
+  }
+
+  static bool classof(const TypeRepr *T) {
+    return T->getKind() == TypeReprKind::LifetimeDependentReturn;
+  }
+  static bool classof(const LifetimeDependentReturnTypeRepr *T) { return true; }
+
+private:
+  SourceLoc getStartLocImpl() const;
+  SourceLoc getEndLocImpl() const;
+  SourceLoc getLocImpl() const;
+  void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;
+  friend class TypeRepr;
+};
+
 inline bool TypeRepr::isSimple() const {
   // NOTE: Please keep this logic in sync with TypeBase::hasSimpleTypeRepr().
   switch (getKind()) {
@@ -1539,6 +1589,7 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::Placeholder:
   case TypeReprKind::CompileTimeConst:
   case TypeReprKind::ResultDependsOn:
+  case TypeReprKind::LifetimeDependentReturn:
     return true;
   }
   llvm_unreachable("bad TypeRepr kind");

include/swift/AST/TypeReprNodes.def

@@ -77,6 +77,7 @@ ABSTRACT_TYPEREPR(Specifier, TypeRepr)
 TYPEREPR(Fixed, TypeRepr)
 TYPEREPR(SILBox, TypeRepr)
 TYPEREPR(Self, TypeRepr)
+TYPEREPR(LifetimeDependentReturn, TypeRepr)
 LAST_TYPEREPR(Self)
 
 #undef SPECIFIER_TYPEREPR

lib/AST/ASTDumper.cpp

@@ -447,6 +447,20 @@ static size_t getDumpString(size_t value) {
 }
 static void *getDumpString(void *value) { return value; }
 
+static StringRef getDumpString(LifetimeDependenceKind kind) {
+  switch (kind) {
+  case LifetimeDependenceKind::Copy:
+    return "copy";
+  case LifetimeDependenceKind::Consume:
+    return "consume";
+  case LifetimeDependenceKind::Borrow:
+    return "borrow";
+  case LifetimeDependenceKind::Mutate:
+    return "mutate";
+  }
+  llvm_unreachable("Invalid lifetime dependence kind\n");
+}
+
 //===----------------------------------------------------------------------===//
 //  Decl printing.
 //===----------------------------------------------------------------------===//
@@ -3514,6 +3528,21 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr, void, StringRef>,
 
     printFoot();
   }
+
+  void visitLifetimeDependentReturnTypeRepr(LifetimeDependentReturnTypeRepr *T,
+                                            StringRef label) {
+    printCommon("type_lifetime_dependent_return", label);
+    for (auto &dep : T->getLifetimeDependencies()) {
+      printFieldRaw(
+          [&](raw_ostream &out) {
+            out << getDumpString(dep.getLifetimeDependenceKind()) << "(";
+            out << dep.getParamString() << ")";
+          },
+          "");
+    }
+    printRec(T->getBase());
+    printFoot();
+  }
 };
 
 void PrintBase::printRec(Decl *D, StringRef label) {

lib/AST/ASTWalker.cpp

@@ -2266,6 +2266,11 @@ bool Traversal::visitSILBoxTypeRepr(SILBoxTypeRepr *T) {
   return false;
 }
 
+bool Traversal::visitLifetimeDependentReturnTypeRepr(
+    LifetimeDependentReturnTypeRepr *T) {
+  return doIt(T->getBase());
+}
+
 Expr *Expr::walk(ASTWalker &walker) {
   return Traversal(walker).doIt(this);
 }

lib/AST/NameLookup.cpp

@@ -3047,6 +3047,7 @@ directReferencesForTypeRepr(Evaluator &evaluator,
   case TypeReprKind::Existential:
   case TypeReprKind::Inverse:
   case TypeReprKind::ResultDependsOn:
+  case TypeReprKind::LifetimeDependentReturn:
     return { };
 
   case TypeReprKind::Fixed:

lib/AST/TypeRepr.cpp

@@ -470,6 +470,31 @@ SourceLoc SILBoxTypeRepr::getLocImpl() const {
   return LBraceLoc;
 }
 
+LifetimeDependentReturnTypeRepr *LifetimeDependentReturnTypeRepr::create(
+    ASTContext &C, TypeRepr *base,
+    ArrayRef<LifetimeDependenceSpecifier> specifiers) {
+  auto size = totalSizeToAlloc<LifetimeDependenceSpecifier>(specifiers.size());
+  auto mem = C.Allocate(size, alignof(LifetimeDependenceSpecifier));
+  return new (mem) LifetimeDependentReturnTypeRepr(base, specifiers);
+}
+
+SourceLoc LifetimeDependentReturnTypeRepr::getStartLocImpl() const {
+  return getLifetimeDependencies().front().getLoc();
+}
+
+SourceLoc LifetimeDependentReturnTypeRepr::getEndLocImpl() const {
+  return getLifetimeDependencies().back().getLoc();
+}
+
+SourceLoc LifetimeDependentReturnTypeRepr::getLocImpl() const {
+  return getBase()->getLoc();
+}
+
+void LifetimeDependentReturnTypeRepr::printImpl(
+    ASTPrinter &Printer, const PrintOptions &Opts) const {
+  printTypeRepr(getBase(), Printer, Opts);
+}
+
 void VarargTypeRepr::printImpl(ASTPrinter &Printer,
                                const PrintOptions &Opts) const {
   printTypeRepr(Element, Printer, Opts);

lib/Parse/ParseType.cpp

@@ -57,6 +57,10 @@ Parser::ParsedTypeAttributeList::applyAttributesToType(Parser &p,
     ty = new (p.Context) ResultDependsOnTypeRepr(ty, ResultDependsOnLoc);
   }
 
+  if (!lifetimeDependenceSpecifiers.empty()) {
+    ty = LifetimeDependentReturnTypeRepr::create(p.Context, ty,
+                                                 lifetimeDependenceSpecifiers);
+  }
   return ty;
 }