Bridge SILFunctionType LifetimeDependenceInfo

Author: atrick

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -228,6 +228,10 @@ public struct ArgumentConventions : Collection, CustomStringConvertible {
     return endIndex - 1
   }
 
+  public var resultDependencies: FunctionConvention.ResultDependencies? {
+    return originalFunctionConvention.resultDependencies
+  }
+
   public var description: String {
     var str = String(taking: originalFunctionConvention.bridgedFunctionType.getDebugDescription())
     if let substitutedFunctionConvention {

SwiftCompilerSources/Sources/SIL/FunctionConvention.swift

@@ -25,24 +25,6 @@ public struct FunctionConvention : CustomStringConvertible {
     self.hasLoweredAddresses = function.hasLoweredAddresses
   }
 
-  public struct Results : Collection {
-    let bridged: BridgedResultInfoArray
-    let hasLoweredAddresses: Bool
-
-    public var startIndex: Int { 0 }
-
-    public var endIndex: Int { bridged.count() }
-
-    public func index(after index: Int) -> Int {
-      return index + 1
-    }
-
-    public subscript(_ index: Int) -> ResultInfo {
-      return ResultInfo(bridged: bridged.at(index),
-        hasLoweredAddresses: hasLoweredAddresses)
-    }
-  }
-
   /// All results including the error.
   public var results: Results {
     Results(bridged: bridgedFunctionType.SILFunctionType_getResultsWithError(),
@@ -71,24 +53,6 @@ public struct FunctionConvention : CustomStringConvertible {
     : results.lazy.filter { $0.convention == .pack }
   }
 
-  public struct Parameters : Collection {
-    let bridged: BridgedParameterInfoArray
-    let hasLoweredAddresses: Bool
-
-    public var startIndex: Int { 0 }
-
-    public var endIndex: Int { bridged.count() }
-
-    public func index(after index: Int) -> Int {
-      return index + 1
-    }
-
-    public subscript(_ index: Int) -> ParameterInfo {
-      return ParameterInfo(bridged: bridged.at(index),
-        hasLoweredAddresses: hasLoweredAddresses)
-    }
-  }
-
   public var parameters: Parameters {
     Parameters(bridged: bridgedFunctionType.SILFunctionType_getParameters(),
       hasLoweredAddresses: hasLoweredAddresses)
@@ -98,34 +62,31 @@ public struct FunctionConvention : CustomStringConvertible {
     bridgedFunctionType.SILFunctionType_hasSelfParam()
   }
 
-  public struct Yields : Collection {
-    let bridged: BridgedYieldInfoArray
-    let hasLoweredAddresses: Bool
-
-    public var startIndex: Int { 0 }
-
-    public var endIndex: Int { bridged.count() }
-
-    public func index(after index: Int) -> Int {
-      return index + 1
-    }
-
-    public subscript(_ index: Int) -> ParameterInfo {
-      return ParameterInfo(bridged: bridged.at(index),
-        hasLoweredAddresses: hasLoweredAddresses)
-    }
-  }
-
   public var yields: Yields {
     Yields(bridged: bridgedFunctionType.SILFunctionType_getYields(),
       hasLoweredAddresses: hasLoweredAddresses)
   }
 
+  /// If the function result depends on any parameters, return a
+  /// Collection of LifetimeDependenceConvention indexed on the
+  /// function parameter.
+  public var resultDependencies: ResultDependencies? {
+    let deps = bridgedFunctionType.SILFunctionType_getLifetimeDependenceInfo()
+    if deps.empty() {
+      return nil
+    }
+    return ResultDependencies(bridged: deps, parameterCount: parameters.count,
+                              hasSelfParameter: hasSelfParameter)
+  }
+
   public var description: String {
     var str = String(taking: bridgedFunctionType.getDebugDescription())
     parameters.forEach { str += "\nparameter: " + $0.description }
     results.forEach { str += "\n   result: " + $0.description }
     str += (hasLoweredAddresses ? "\n[lowered_address]" : "\n[sil_opaque]")
+    if let deps = resultDependencies {
+      str += "\nresult dependences \(deps)"
+    }
     return str
   }
 }
@@ -160,6 +121,26 @@ public struct ResultInfo : CustomStringConvertible {
   }
 }
 
+extension FunctionConvention {
+  public struct Results : Collection {
+    let bridged: BridgedResultInfoArray
+    let hasLoweredAddresses: Bool
+
+    public var startIndex: Int { 0 }
+
+    public var endIndex: Int { bridged.count() }
+
+    public func index(after index: Int) -> Int {
+      return index + 1
+    }
+
+    public subscript(_ index: Int) -> ResultInfo {
+      return ResultInfo(bridged: bridged.at(index),
+        hasLoweredAddresses: hasLoweredAddresses)
+    }
+  }
+}
+
 public struct ParameterInfo : CustomStringConvertible {
   /// The parameter type that describes the abstract calling
   /// convention of the parameter.
@@ -193,6 +174,109 @@ public struct ParameterInfo : CustomStringConvertible {
   }
 }
 
+extension FunctionConvention {
+  public struct Parameters : Collection {
+    let bridged: BridgedParameterInfoArray
+    let hasLoweredAddresses: Bool
+
+    public var startIndex: Int { 0 }
+
+    public var endIndex: Int { bridged.count() }
+
+    public func index(after index: Int) -> Int {
+      return index + 1
+    }
+
+    public subscript(_ index: Int) -> ParameterInfo {
+      return ParameterInfo(bridged: bridged.at(index),
+        hasLoweredAddresses: hasLoweredAddresses)
+    }
+  }
+}
+
+extension FunctionConvention {
+  public struct Yields : Collection {
+    let bridged: BridgedYieldInfoArray
+    let hasLoweredAddresses: Bool
+
+    public var startIndex: Int { 0 }
+
+    public var endIndex: Int { bridged.count() }
+
+    public func index(after index: Int) -> Int {
+      return index + 1
+    }
+
+    public subscript(_ index: Int) -> ParameterInfo {
+      return ParameterInfo(bridged: bridged.at(index),
+        hasLoweredAddresses: hasLoweredAddresses)
+    }
+  }
+}
+
+public enum LifetimeDependenceConvention {
+  case inherit
+  case borrow
+  case mutate
+}
+
+extension FunctionConvention {
+  /// Collection of LifetimeDependenceConvention? that parallels parameters.
+  public struct ResultDependencies : Collection, CustomStringConvertible {
+    let bridged: BridgedLifetimeDependenceInfo
+    let paramCount: Int
+    let hasSelfParam: Bool
+
+    init(bridged: BridgedLifetimeDependenceInfo, parameterCount: Int,
+         hasSelfParameter: Bool) {
+      assert(!bridged.empty())
+      self.bridged = bridged
+      self.paramCount = parameterCount
+      self.hasSelfParam = hasSelfParameter
+    }
+
+    public var startIndex: Int { 0 }
+
+    public var endIndex: Int { paramCount }
+
+    public func index(after index: Int) -> Int {
+      return index + 1
+    }
+
+    public subscript(_ index: Int) -> LifetimeDependenceConvention? {
+      let inherit = bridged.checkInherit(bridgedIndex(parameterIndex: index))
+      let borrow = bridged.checkBorrow(bridgedIndex(parameterIndex: index))
+      let mutate = bridged.checkMutate(bridgedIndex(parameterIndex: index))
+      if inherit {
+        assert(!borrow && !mutate, "mutualy exclusive lifetime specifiers")
+        return .inherit
+      }
+      if borrow {
+        assert(!mutate, "mutualy exclusive lifetime specifiers")
+        return .borrow
+      }
+      if mutate {
+        return .mutate
+      }
+      return nil
+    }
+
+    // In Sema's LifetimeDependenceInfo, 'self' is always index zero,
+    // whether it exists or not. In SILFunctionType, 'self' is the
+    // last parameter if it exists.
+    private func bridgedIndex(parameterIndex: Int) -> Int {
+      if hasSelfParam, parameterIndex == (paramCount - 1) {
+        return 0
+      }
+      return parameterIndex + 1
+    }
+
+    public var description: String {
+      String(taking: bridged.getDebugDescription())
+    }
+  }
+}
+
 public enum ResultConvention : CustomStringConvertible {
   /// This result is returned indirectly, i.e. by passing the address of an uninitialized object in memory.  The callee is responsible for leaving an initialized object at this address.  The callee may assume that the address does not alias any valid object.
   case indirect

include/swift/AST/LifetimeDependence.h

@@ -165,6 +165,21 @@ class LifetimeDependenceInfo {
   bool hasBorrowLifetimeParamIndices() const {
     return scopeLifetimeParamIndices != nullptr;
   }
+  
+  bool checkInherit(int index) const {
+    assert(!empty());
+    return inheritLifetimeParamIndices->contains(index);
+  }
+
+  bool checkBorrow(int index) const {
+    assert(!empty());
+    return borrowLifetimeParamIndices->contains(index);
+  }
+
+  bool checkMutate(int index) const {
+    assert(!empty());
+    return mutateLifetimeParamIndices->contains(index);
+  }
 
   std::string getString() const;
   void Profile(llvm::FoldingSetNodeID &ID) const;
@@ -176,4 +191,4 @@ class LifetimeDependenceInfo {
 
 } // namespace swift
 
-#endif
+#endif

include/swift/AST/Types.h

@@ -5224,7 +5224,15 @@ class SILFunctionType final
 
   ClangTypeInfo getClangTypeInfo() const;
 
-  LifetimeDependenceInfo getLifetimeDependenceInfo() const;
+  /// Returns nullptr for an empty dependence list.
+  const LifetimeDependenceInfo *getLifetimeDependenceInfoOrNull() const;
+
+  inline LifetimeDependenceInfo getLifetimeDependenceInfo() const {
+    if (auto *depInfo = getLifetimeDependenceInfoOrNull()) {
+      return *depInfo;
+    }
+    return LifetimeDependenceInfo();
+  }
 
   /// Returns true if the function type stores a Clang type that cannot
   /// be derived from its Swift type. Returns false otherwise, including if

include/swift/SIL/SILBridging.h

@@ -63,6 +63,7 @@ class VarDecl;
 class TypeBase;
 class SwiftPassInvocation;
 class GenericSpecializationInformation;
+class LifetimeDependenceInfo;
 }
 
 bool swiftModulesInitialized();
@@ -227,6 +228,17 @@ struct BridgedYieldInfoArray {
   BridgedParameterInfo at(SwiftInt resultIndex) const;
 };
 
+struct BridgedLifetimeDependenceInfo {
+  const swift::LifetimeDependenceInfo * _Nullable info = nullptr;
+
+  BRIDGED_INLINE bool empty() const;
+  BRIDGED_INLINE bool checkInherit(SwiftInt index) const;
+  BRIDGED_INLINE bool checkBorrow(SwiftInt index) const;
+  BRIDGED_INLINE bool checkMutate(SwiftInt index) const;
+
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedOwnedString getDebugDescription() const;
+};
+
 // Temporary access to the AST type within SIL until ASTBridging provides it.
 struct BridgedASTType {
   swift::TypeBase * _Nullable type;
@@ -270,6 +282,8 @@ struct BridgedASTType {
 
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE
   BridgedYieldInfoArray SILFunctionType_getYields() const;
+
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedLifetimeDependenceInfo SILFunctionType_getLifetimeDependenceInfo() const;
 };
 
 struct BridgedType {

include/swift/SIL/SILBridgingImpl.h

@@ -77,6 +77,34 @@ BridgedParameterInfo BridgedParameterInfoArray::at(SwiftInt parameterIndex) cons
   return BridgedParameterInfo(unbridged()[parameterIndex]);
 }
 
+//===----------------------------------------------------------------------===//
+//                       BridgedLifetimeDependenceInfo
+//===----------------------------------------------------------------------===//
+
+bool BridgedLifetimeDependenceInfo::empty() const {
+  return info == nullptr || info->empty();
+}
+
+bool BridgedLifetimeDependenceInfo::checkInherit(SwiftInt index) const {
+  assert(info);
+  return info->checkInherit(index);
+}
+
+bool BridgedLifetimeDependenceInfo::checkBorrow(SwiftInt index) const {
+  assert(info);
+  return info->checkBorrow(index);
+}
+
+bool BridgedLifetimeDependenceInfo::checkMutate(SwiftInt index) const {
+  assert(info);
+  return info->checkMutate(index);
+}
+
+BridgedOwnedString BridgedLifetimeDependenceInfo::getDebugDescription() const {
+  assert(info);
+  return BridgedOwnedString(info->getString());
+}
+
 //===----------------------------------------------------------------------===//
 //                               BridgedASTType
 //===----------------------------------------------------------------------===//
@@ -134,6 +162,11 @@ BridgedYieldInfoArray BridgedASTType::SILFunctionType_getYields() const {
   return unbridged()->castTo<swift::SILFunctionType>()->getYields();
 }
 
+BridgedLifetimeDependenceInfo BridgedASTType::SILFunctionType_getLifetimeDependenceInfo() const {
+  auto fnTy = unbridged()->castTo<swift::SILFunctionType>();
+  return {fnTy->getLifetimeDependenceInfoOrNull()};
+}
+
 //===----------------------------------------------------------------------===//
 //                                BridgedType
 //===----------------------------------------------------------------------===//

lib/AST/ASTPrinter.cpp

@@ -7599,9 +7599,9 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       }
       sub->Printer << ") -> ";
 
-      auto lifetimeDependenceInfo = T->getLifetimeDependenceInfo();
-      if (!lifetimeDependenceInfo.empty()) {
-        sub->Printer << lifetimeDependenceInfo.getString() << " ";
+      auto *lifetimeDependenceInfo = T->getLifetimeDependenceInfo();
+      if (lifetimeDependenceInfo && !lifetimeDependenceInfo->empty()) {
+        sub->Printer << lifetimeDependenceInfo->getString() << " ";
       }
 
       bool parenthesizeResults = mustParenthesizeResults(T);