Merge pull request #73061 from meg-gupta/lifetimediagfixes

Diagnostic fixes to LifetimeDependence

Author: meg-gupta

include/swift/AST/DiagnosticsSema.def

@@ -7900,14 +7900,14 @@ ERROR(lifetime_dependence_invalid_return_type, none,
 ERROR(lifetime_dependence_cannot_infer_ambiguous_candidate, none,
       "cannot infer lifetime dependence %0, multiple parameters qualifiy as a candidate", (StringRef))
  ERROR(lifetime_dependence_cannot_infer_no_candidates, none,
-       "cannot infer lifetime dependence %0, no parameters found that are either "
+       "cannot infer lifetime dependence%0, no parameters found that are either "
        "~Escapable or Escapable with a borrowing ownership", (StringRef))
  ERROR(lifetime_dependence_ctor_non_self_or_nil_return, none,
        "expected nil or self as return values in an initializer with "
        "lifetime dependent specifiers",
        ())
  ERROR(lifetime_dependence_on_bitwise_copyable, none,
-       "invalid lifetime dependence on bitwise copyable type", ())
+       "invalid lifetime dependence on BitwiseCopyable type", ())
  ERROR(lifetime_dependence_cannot_be_applied_to_tuple_elt, none,
        "lifetime dependence specifiers cannot be applied to tuple elements", ())
  ERROR(lifetime_dependence_method_escapable_bitwisecopyable_self, none,

include/swift/AST/LifetimeDependence.h

@@ -17,6 +17,7 @@
 #ifndef SWIFT_AST_LIFETIMEDEPENDENCE_H
 #define SWIFT_AST_LIFETIMEDEPENDENCE_H
 
+#include "swift/AST/DeclContext.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/IndexSubset.h"
 #include "swift/AST/Ownership.h"

lib/AST/CMakeLists.txt

@@ -61,6 +61,7 @@ add_swift_host_library(swiftAST STATIC
   IndexSubset.cpp
   InlinableText.cpp
   LayoutConstraint.cpp
+  LifetimeDependence.cpp
   Module.cpp
   ModuleDependencies.cpp
   ModuleLoader.cpp

lib/Sema/LifetimeDependence.cpp renamed to lib/AST/LifetimeDependence.cpp

@@ -10,11 +10,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "TypeChecker.h"
-
+#include "swift/AST/LifetimeDependence.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
-#include "swift/AST/LifetimeDependence.h"
+#include "swift/AST/DiagnosticsSema.h"
+#include "swift/AST/Module.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/Type.h"
 #include "swift/AST/TypeRepr.h"
@@ -165,13 +165,25 @@ static LifetimeDependenceKind getLifetimeDependenceKindFromDecl(
     return LifetimeDependenceKind::Scope;
   }
   if (parsedLifetimeDependenceKind == ParsedLifetimeDependenceKind::Inherit) {
-    // TODO: assert that this can happen only on deserialized decls
+    // TODO: assert that this can happen in SIL tests
     return LifetimeDependenceKind::Inherit;
   }
   return paramType->isEscapable() ? LifetimeDependenceKind::Scope
                                   : LifetimeDependenceKind::Inherit;
 }
 
+static bool isBitwiseCopyable(Type type, ModuleDecl *mod, ASTContext &ctx) {
+  if (!ctx.LangOpts.hasFeature(Feature::BitwiseCopyable)) {
+    return false;
+  }
+  auto *bitwiseCopyableProtocol =
+      ctx.getProtocol(KnownProtocolKind::BitwiseCopyable);
+  if (!bitwiseCopyableProtocol) {
+    return false;
+  }
+  return (bool)(mod->checkConformance(type, bitwiseCopyableProtocol));
+}
+
 std::optional<LifetimeDependenceInfo>
 LifetimeDependenceInfo::fromTypeRepr(AbstractFunctionDecl *afd) {
   auto *dc = afd->getDeclContext();
@@ -205,14 +217,9 @@ LifetimeDependenceInfo::fromTypeRepr(AbstractFunctionDecl *afd) {
     // error.
     // TODO: Diagnose ~Escapable types are always non-trivial in SIL.
     if (paramType->isEscapable()) {
-      if (ctx.LangOpts.hasFeature(Feature::BitwiseCopyable)) {
-        auto *bitwiseCopyableProtocol =
-            ctx.getProtocol(KnownProtocolKind::BitwiseCopyable);
-        if (bitwiseCopyableProtocol &&
-            mod->checkConformance(paramType, bitwiseCopyableProtocol)) {
-          diags.diagnose(loc, diag::lifetime_dependence_on_bitwise_copyable);
-          return true;
-        }
+      if (isBitwiseCopyable(paramType, mod, ctx)) {
+        diags.diagnose(loc, diag::lifetime_dependence_on_bitwise_copyable);
+        return true;
       }
     }
 
@@ -277,7 +284,7 @@ LifetimeDependenceInfo::fromTypeRepr(AbstractFunctionDecl *afd) {
     }
     case LifetimeDependenceSpecifier::SpecifierKind::Ordered: {
       auto index = specifier.getIndex();
-      if (index > afd->getParameters()->size()) {
+      if (index >= afd->getParameters()->size()) {
         diags.diagnose(specifier.getLoc(),
                        diag::lifetime_dependence_invalid_param_index, index);
         return std::nullopt;
@@ -426,16 +433,11 @@ LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd) {
   if (!cd && afd->hasImplicitSelfDecl()) {
     Type selfTypeInContext = dc->getSelfTypeInContext();
     if (selfTypeInContext->isEscapable()) {
-      if (ctx.LangOpts.hasFeature(Feature::BitwiseCopyable)) {
-        auto *bitwiseCopyableProtocol =
-            ctx.getProtocol(KnownProtocolKind::BitwiseCopyable);
-        if (bitwiseCopyableProtocol &&
-            mod->checkConformance(selfTypeInContext, bitwiseCopyableProtocol)) {
+      if (isBitwiseCopyable(selfTypeInContext, mod, ctx)) {
           diags.diagnose(
               returnLoc,
               diag::lifetime_dependence_method_escapable_bitwisecopyable_self);
           return std::nullopt;
-        }
       }
     }
     auto kind = getLifetimeDependenceKindFromType(selfTypeInContext);
@@ -455,23 +457,26 @@ LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd) {
   unsigned paramIndex = 0;
   bool hasParamError = false;
   for (auto *param : *afd->getParameters()) {
-    SWIFT_DEFER {
-      paramIndex++;
-    };
+    SWIFT_DEFER { paramIndex++; };
     Type paramTypeInContext =
         afd->mapTypeIntoContext(param->getInterfaceType());
     if (paramTypeInContext->hasError()) {
       hasParamError = true;
       continue;
     }
     auto paramOwnership = param->getValueOwnership();
-    if (paramTypeInContext->isEscapable() && paramOwnership == ValueOwnership::Default) {
-      continue;
+    if (paramTypeInContext->isEscapable()) {
+      if (isBitwiseCopyable(paramTypeInContext, mod, ctx)) {
+        continue;
+      }
+      if (paramOwnership == ValueOwnership::Default) {
+        continue;
+      }
     }
 
     auto lifetimeKind = getLifetimeDependenceKindFromType(paramTypeInContext);
-    if (!isLifetimeDependenceCompatibleWithOwnership(lifetimeKind, paramOwnership,
-                                                     afd)) {
+    if (!isLifetimeDependenceCompatibleWithOwnership(lifetimeKind,
+                                                     paramOwnership, afd)) {
       continue;
     }
     if (candidateParam) {
@@ -496,12 +501,11 @@ LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd) {
     if (cd && afd->isImplicit()) {
       diags.diagnose(returnLoc,
                      diag::lifetime_dependence_cannot_infer_no_candidates,
-                     "on implicit initializer");
+                     " on implicit initializer");
       return std::nullopt;
     }
     diags.diagnose(returnLoc,
-                   diag::lifetime_dependence_cannot_infer_no_candidates,
-                   "");
+                   diag::lifetime_dependence_cannot_infer_no_candidates, "");
     return std::nullopt;
   }
   return lifetimeDependenceInfo;

lib/Sema/CMakeLists.txt

@@ -35,7 +35,6 @@ add_swift_host_library(swiftSema STATIC
   DerivedConformances.cpp
   ImportResolution.cpp
   InstrumenterSupport.cpp
-  LifetimeDependence.cpp
   LookupVisibleDecls.cpp
   MiscDiagnostics.cpp
   PCMacro.cpp

test/Sema/explicit_lifetime_dependence_specifiers2.swift

@@ -12,9 +12,14 @@ struct AnotherBufferView : ~Escapable, _BitwiseCopyable {
 
 struct BufferView : ~Escapable {
   let ptr: UnsafeRawBufferPointer
-  init(_ bv: borrowing AnotherBufferView) -> _borrow(bv) Self {
+  init(_ bv: borrowing AnotherBufferView) -> dependsOn(bv) Self {
     self.ptr = bv.ptr
     return self
   }
 }
 
+struct NonescapableType: ~Escapable {}
+
+func f<T: ~Escapable & _BitwiseCopyable>(arg: T) -> NonescapableType {
+  NonescapableType()
+}

test/Sema/implicit_lifetime_dependence.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift -enable-experimental-feature NonescapableTypes -enable-experimental-feature NoncopyableGenerics
+// RUN: %target-typecheck-verify-swift -enable-experimental-feature NonescapableTypes -enable-experimental-feature NoncopyableGenerics -enable-experimental-feature BitwiseCopyable
 // REQUIRES: asserts
 
 struct BufferView : ~Escapable, ~Copyable {
@@ -24,7 +24,15 @@ struct ImplicitInit3 : ~Escapable, ~Copyable { // expected-error{{cannot infer l
   let mbv2: BufferView
 }
 
-func foo() -> BufferView { // expected-error{{cannot infer lifetime dependence , no parameters found that are either ~Escapable or Escapable with a borrowing ownership}}
+func foo1() -> BufferView { // expected-error{{cannot infer lifetime dependence, no parameters found that are either ~Escapable or Escapable with a borrowing ownership}}
+  return BufferView(nil, 0)
+}
+
+func foo2(_ i: borrowing Int) -> BufferView { // expected-error{{cannot infer lifetime dependence, no parameters found that are either ~Escapable or Escapable with a borrowing ownership}}
+  return BufferView(nil, 0)
+}
+
+func foo3<T: _BitwiseCopyable>(arg: borrowing T) -> BufferView { // expected-error{{cannot infer lifetime dependence, no parameters found that are either ~Escapable or Escapable with a borrowing ownership}}
   return BufferView(nil, 0)
 }