Merge pull request swiftlang#84374 from DougGregor/embedded-swift-restrictions

Embedded swift restrictions

Author: DougGregor

include/swift/AST/DiagnosticsSIL.def

@@ -378,52 +378,57 @@ ERROR(bad_attr_on_non_const_global,none,
       "global variable must be a compile-time constant to use %0 attribute", (StringRef))
 ERROR(global_must_be_compile_time_const,none,
       "global variable must be a compile-time constant", ())
-ERROR(embedded_cannot_specialize_class_method,none,
+ERROR(perf_diag_existential_type,none,
+      "cannot use a value of protocol type %0 in '@_noExistential' function", (Type))
+ERROR(perf_diag_existential,none,
+      "cannot use a value of protocol type in '@_noExistential' function", ())
+
+// Embedded Swift diagnostics
+GROUPED_ERROR(embedded_cannot_specialize_class_method,EmbeddedRestrictions,none,
       "classes cannot have a non-final, generic method %0 in embedded Swift", (DeclName))
-ERROR(embedded_cannot_specialize_witness_method,none,
+GROUPED_ERROR(embedded_cannot_specialize_witness_method,EmbeddedRestrictions,none,
       "a protocol type cannot contain a generic method %0 in embedded Swift", (DeclName))
-ERROR(cannot_specialize_class,none,
+GROUPED_ERROR(cannot_specialize_class,EmbeddedRestrictions,none,
       "cannot specialize %0 because class definition is not available (make sure to build with -wmo)", (Type))
-ERROR(embedded_swift_existential_type,none,
+GROUPED_ERROR(embedded_swift_existential_type,EmbeddedRestrictions,none,
       "cannot use a value of protocol type %0 in embedded Swift", (Type))
-ERROR(embedded_swift_existential_protocol,none,
+GROUPED_ERROR(embedded_swift_existential_protocol,EmbeddedRestrictions,none,
       "cannot use a value of protocol type 'any %0' in embedded Swift", (StringRef))
-ERROR(embedded_swift_existential,none,
+GROUPED_ERROR(embedded_swift_existential,EmbeddedRestrictions,none,
       "cannot use a value of protocol type in embedded Swift", ())
-ERROR(perf_diag_existential_type,none,
-      "cannot use a value of protocol type %0 in '@_noExistential' function", (Type))
-ERROR(perf_diag_existential,none,
-      "cannot use a value of protocol type in '@_noExistential' function", ())
-ERROR(embedded_swift_value_deinit,none,
+GROUPED_ERROR(embedded_swift_value_deinit,EmbeddedRestrictions,none,
       "cannot de-virtualize deinit of type %0", (Type))
-ERROR(embedded_swift_metatype_type,none,
+GROUPED_ERROR(embedded_swift_metatype_type,EmbeddedRestrictions,none,
       "cannot use metatype of type %0 in embedded Swift", (Type))
-ERROR(embedded_swift_metatype,none,
+GROUPED_ERROR(embedded_swift_metatype,EmbeddedRestrictions,none,
       "cannot use metatype in embedded Swift", ())
-ERROR(embedded_swift_keypath,none,
+GROUPED_ERROR(embedded_swift_keypath,EmbeddedRestrictions,none,
       "cannot use key path in embedded Swift", ())
-ERROR(embedded_swift_dynamic_cast,none,
+GROUPED_ERROR(embedded_swift_dynamic_cast,EmbeddedRestrictions,none,
       "cannot do dynamic casting in embedded Swift", ())
-ERROR(embedded_swift_allocating_type,none,
-      "cannot use allocating type %0 in -no-allocations mode", (Type))
-ERROR(embedded_swift_allocating_coroutine,none,
-      "cannot use co-routines (like accessors) in -no-allocations mode", ())
-ERROR(embedded_swift_allocating_closure,none,
-      "cannot use escaping closures in -no-allocations mode", ())
-ERROR(embedded_swift_allocating,none,
-      "cannot use allocating operation in -no-allocations mode", ())
-ERROR(embedded_capture_of_generic_value_with_deinit,none,
+GROUPED_ERROR(embedded_capture_of_generic_value_with_deinit,EmbeddedRestrictions,none,
       "capturing generic non-copyable type with deinit in escaping closure not supported in embedded Swift", ())
-ERROR(embedded_call_generic_function,none,
+GROUPED_ERROR(embedded_call_generic_function,EmbeddedRestrictions,none,
       "cannot specialize generic function or default protocol method in this context", ())
-ERROR(embedded_call_generic_function_with_dynamic_self,none,
+GROUPED_ERROR(embedded_call_generic_function_with_dynamic_self,EmbeddedRestrictions,none,
       "cannot call an initializer or static method, which is defined as default protocol method, from a class method or initializer", ())
 NOTE(embedded_specialization_called_from,none,
       "generic specialization called here", ())
 NOTE(embedded_existential_created,none,
       "protocol type value created here", ())
 NOTE(embedded_constructor_called,none,
       "instance of type created here", ())
+
+// no-allocations diagnostics
+ERROR(embedded_swift_allocating_type,none,
+      "cannot use allocating type %0 in -no-allocations mode", (Type))
+ERROR(embedded_swift_allocating_coroutine,none,
+      "cannot use co-routines (like accessors) in -no-allocations mode", ())
+ERROR(embedded_swift_allocating_closure,none,
+      "cannot use escaping closures in -no-allocations mode", ())
+ERROR(embedded_swift_allocating,none,
+      "cannot use allocating operation in -no-allocations mode", ())
+
 ERROR(wrong_linkage_for_serialized_function,none,
       "function has wrong linkage to be called from %0", (StringRef))
 NOTE(performance_called_from,none,

include/swift/AST/DiagnosticsSema.def

@@ -8616,6 +8616,18 @@ GROUPED_ERROR(weak_unowned_in_embedded_swift, EmbeddedRestrictions, none,
 GROUPED_WARNING(untyped_throws_in_embedded_swift, EmbeddedRestrictions,
                 DefaultIgnore,
                 "untyped throws is not available in Embedded Swift; add a thrown error type with '(type)'", ())
+GROUPED_WARNING(generic_nonfinal_in_embedded_swift, EmbeddedRestrictions,
+                DefaultIgnore,
+                "generic %kind0 in a class %select{must be 'final'|cannot be 'required'}1 in Embedded Swift",
+                (const Decl *, bool))
+GROUPED_WARNING(use_generic_member_of_existential_in_embedded_swift,
+                EmbeddedRestrictions, DefaultIgnore,
+                "cannot use generic %kind0 on a value of type %1 in Embedded Swift",
+                (const Decl *, Type))
+GROUPED_WARNING(dynamic_cast_involving_protocol_in_embedded_swift,
+                EmbeddedRestrictions, DefaultIgnore,
+                "cannot perform a dynamic cast to a type involving %kind0 in Embedded Swift",
+                (const Decl *))
 
 //===----------------------------------------------------------------------===//
 // MARK: @abi Attribute

lib/Sema/CSApply.cpp

@@ -21,6 +21,7 @@
 #include "MiscDiagnostics.h"
 #include "OpenedExistentials.h"
 #include "TypeCheckConcurrency.h"
+#include "TypeCheckEmbedded.h"
 #include "TypeCheckMacros.h"
 #include "TypeCheckProtocol.h"
 #include "TypeCheckType.h"
@@ -924,8 +925,9 @@ namespace {
     /// \returns An OpaqueValueExpr that provides a reference to the value
     /// stored within the expression or its metatype (if the base was a
     /// metatype).
-    Expr *openExistentialReference(Expr *base, ExistentialArchetypeType *archetype,
-                                   ValueDecl *member) {
+    Expr *openExistentialReference(Expr *base,
+                                   ExistentialArchetypeType *archetype,
+                                   ValueDecl *member, SourceLoc memberLoc) {
       assert(archetype && "archetype not already opened?");
 
       // Dig out the base type.
@@ -955,6 +957,11 @@ namespace {
 
       assert(baseTy->isAnyExistentialType() && "Type must be existential");
 
+      // Embedded Swift has limitations on the use of generic members of
+      // existentials. Diagnose them here.
+      diagnoseGenericMemberOfExistentialInEmbedded(
+          dc, memberLoc, baseTy, member);
+
       // If the base was an lvalue but it will only be treated as an
       // rvalue, turn the base into an rvalue now. This results in
       // better SILGen.
@@ -1983,7 +1990,8 @@ namespace {
             (!member->getDeclContext()->getSelfProtocolDecl() &&
              baseIsInstance && member->isInstanceMember())) {
           // Open the existential before performing the member reference.
-          base = openExistentialReference(base, knownOpened->second, member);
+          base = openExistentialReference(base, knownOpened->second, member,
+                                          memberLoc.getBaseNameLoc());
           baseTy = baseOpenedTy;
           selfTy = baseTy;
           openedExistential = true;
@@ -2490,7 +2498,8 @@ namespace {
       auto memberLoc = cs.getCalleeLocator(cs.getConstraintLocator(locator));
       auto knownOpened = solution.OpenedExistentialTypes.find(memberLoc);
       if (knownOpened != solution.OpenedExistentialTypes.end()) {
-        base = openExistentialReference(base, knownOpened->second, subscript);
+        base = openExistentialReference(base, knownOpened->second, subscript,
+                                        args->getLoc());
         baseTy = knownOpened->second;
       }
 
@@ -6551,7 +6560,8 @@ ArgumentList *ExprRewriter::coerceCallArguments(
           cs.getConstraintLocator(argLoc));
       if (knownOpened != solution.OpenedExistentialTypes.end()) {
         argExpr = openExistentialReference(
-            argExpr, knownOpened->second, callee.getDecl());
+            argExpr, knownOpened->second, callee.getDecl(),
+            apply ? apply->getLoc() : argExpr->getLoc());
         argType = cs.getType(argExpr);
       }
     }

lib/Sema/MiscDiagnostics.cpp

@@ -17,6 +17,7 @@
 #include "MiscDiagnostics.h"
 #include "TypeCheckAvailability.h"
 #include "TypeCheckConcurrency.h"
+#include "TypeCheckEmbedded.h"
 #include "TypeCheckInvertible.h"
 #include "TypeChecker.h"
 #include "swift/AST/ASTBridging.h"
@@ -390,6 +391,9 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
         }
       }
 
+      // Embedded Swift places restrictions on dynamic casting.
+      diagnoseDynamicCastInEmbedded(DC, cast);
+
       // now, look for conditional casts to marker protocols.
 
       if (!isa<ConditionalCheckedCastExpr>(cast) && !isa<IsExpr>(cast))

lib/Sema/TypeCheckEmbedded.cpp

@@ -19,21 +19,31 @@
 #include "swift/AST/Decl.h"
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/Effects.h"
+#include "swift/AST/Expr.h"
+#include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/SourceFile.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/SourceLoc.h"
 #include "swift/Bridging/ASTGen.h"
 
 using namespace swift;
 
+static DiagnosticBehavior
+defaultEmbeddedLimitationForError(const DeclContext *dc, SourceLoc loc) {
+  if (dc->getASTContext().LangOpts.hasFeature(Feature::Embedded))
+    return DiagnosticBehavior::Unspecified;
+
+  return DiagnosticBehavior::Warning;
+}
+
 std::optional<DiagnosticBehavior>
 swift::shouldDiagnoseEmbeddedLimitations(const DeclContext *dc, SourceLoc loc,
                                          bool wasAlwaysEmbeddedError) {
   // In Embedded Swift, things that were always errors will still be emitted
   // as errors. Use "unspecified" so we don't change anything.
   if (dc->getASTContext().LangOpts.hasFeature(Feature::Embedded) &&
       wasAlwaysEmbeddedError) {
-    return DiagnosticBehavior::Unspecified;
+    return defaultEmbeddedLimitationForError(dc, loc);
   }
 
   // Check one of the Embedded restriction diagnostics that is ignored by
@@ -66,6 +76,42 @@ swift::shouldDiagnoseEmbeddedLimitations(const DeclContext *dc, SourceLoc loc,
   return DiagnosticBehavior::Unspecified;
 }
 
+/// Determine whether the inner signature is more generic than the outer
+/// signature, ignoring differences that
+static bool isABIMoreGenericThan(GenericSignature innerSig, GenericSignature outerSig) {
+  auto canInnerSig = innerSig.getCanonicalSignature();
+  auto canOuterSig = outerSig.getCanonicalSignature();
+  if (canInnerSig == canOuterSig)
+    return false;
+
+  // The inner signature added generic parameters.
+  if (canOuterSig.getGenericParams().size() !=
+        canInnerSig.getGenericParams().size())
+    return true;
+
+  // Look at the requirements of the inner signature that aren't satisfied
+  // by the outer signature, to see if there are any requirements that aren't
+  // just marker protocols.
+  auto requirements = canInnerSig.requirementsNotSatisfiedBy(canOuterSig);
+  for (const auto &req : requirements) {
+    switch (req.getKind()) {
+    case RequirementKind::Conformance:
+      if (req.getProtocolDecl()->isMarkerProtocol())
+        continue;
+
+      return true;
+
+    case RequirementKind::Superclass:
+    case RequirementKind::Layout:
+    case RequirementKind::SameShape:
+    case RequirementKind::SameType:
+      return true;
+    }
+  }
+
+  return false;
+}
+
 /// Check embedded restrictions in the signature of the given function.
 void swift::checkEmbeddedRestrictionsInSignature(
     const AbstractFunctionDecl *func) {
@@ -80,6 +126,20 @@ void swift::checkEmbeddedRestrictionsInSignature(
       !func->hasPolymorphicEffect(EffectKind::Throws)) {
     diagnoseUntypedThrowsInEmbedded(func, throwsLoc);
   }
+
+  // If we're in a class, one cannot have a non-final generic function.
+  if (auto classDecl = dyn_cast<ClassDecl>(func->getDeclContext())) {
+    if (!classDecl->isSemanticallyFinal() &&
+        ((isa<FuncDecl>(func) && !func->isSemanticallyFinal()) ||
+         (isa<ConstructorDecl>(func) &&
+          cast<ConstructorDecl>(func)->isRequired())) &&
+        isABIMoreGenericThan(func->getGenericSignature(),
+                             classDecl->getGenericSignature())) {
+      func->diagnose(diag::generic_nonfinal_in_embedded_swift, func,
+                     isa<ConstructorDecl>(func))
+        .limitBehavior(defaultEmbeddedLimitationForError(func, func->getLoc()));
+    }
+  }
 }
 
 void swift::diagnoseUntypedThrowsInEmbedded(
@@ -94,3 +154,45 @@ void swift::diagnoseUntypedThrowsInEmbedded(
     .limitBehavior(*behavior)
     .fixItInsertAfter(throwsLoc, "(<#thrown error type#>)");
 }
+
+void swift::diagnoseGenericMemberOfExistentialInEmbedded(
+    const DeclContext *dc, SourceLoc loc,
+    Type baseType, const ValueDecl *member) {
+  // If we are not supposed to diagnose Embedded Swift limitations, do nothing.
+  auto behavior = shouldDiagnoseEmbeddedLimitations(dc, loc);
+  if (!behavior)
+    return;
+
+  if (isABIMoreGenericThan(
+          member->getInnermostDeclContext()->getGenericSignatureOfContext(),
+          member->getDeclContext()->getGenericSignatureOfContext())) {
+    dc->getASTContext().Diags.diagnose(loc, diag::use_generic_member_of_existential_in_embedded_swift, member,
+        baseType)
+      .limitBehavior(*behavior);
+  }
+}
+
+void swift::diagnoseDynamicCastInEmbedded(
+    const DeclContext *dc, const CheckedCastExpr *cast) {
+  // If we are not supposed to diagnose Embedded Swift limitations, do nothing.
+  auto behavior = shouldDiagnoseEmbeddedLimitations(dc, cast->getLoc());
+  if (!behavior)
+    return;
+
+  // We only care about casts to existential types.
+  Type toType = cast->getCastType()->lookThroughAllOptionalTypes();
+  if (!toType->isAnyExistentialType())
+    return;
+
+  ExistentialLayout layout = toType->getExistentialLayout();
+  for (auto proto : layout.getProtocols()) {
+    if (proto->isMarkerProtocol())
+      continue;
+
+    dc->getASTContext().Diags.diagnose(
+        cast->getLoc(),
+        diag::dynamic_cast_involving_protocol_in_embedded_swift, proto)
+      .limitBehaviorIf(behavior);
+    return;
+  }
+}

lib/Sema/TypeCheckEmbedded.h

@@ -24,8 +24,11 @@ namespace swift {
 class AbstractFunctionDecl;
 class DeclContext;
 struct DiagnosticBehavior;
+class CheckedCastExpr;
 class SourceLoc;
-  
+class Type;
+class ValueDecl;
+
 /// Whether we should diagnose language-level limitations of Embedded Swift
 /// at the given source location, and how.
 ///
@@ -46,5 +49,16 @@ void checkEmbeddedRestrictionsInSignature(const AbstractFunctionDecl *func);
 /// Diagnose a declaration of typed throws at the given location.
 void diagnoseUntypedThrowsInEmbedded(const DeclContext *dc, SourceLoc throwsLoc);
 
+/// Diagnose references to a generic member via an existential type, which are
+/// not available in Embedded Swift.
+void diagnoseGenericMemberOfExistentialInEmbedded(
+    const DeclContext *dc, SourceLoc loc,
+    Type baseType, const ValueDecl *member);
+
+/// Diagnose dynamic casts (is/as?/as!) to a type, which is not always available
+/// in Embedded Swift.
+void diagnoseDynamicCastInEmbedded(
+    const DeclContext *dc, const CheckedCastExpr *cast);
+
 }
 #endif // SWIFT_SEMA_TYPECHECKEMBEDDED_H