Merge pull request #71488 from kavon/ncgenerics-test-fixes-kavon-v5

Ncgenerics test fixes kavon v5

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -7578,6 +7578,9 @@ ERROR(inverse_with_class_constraint, none,
       "composition involving %select{class requirement %2|'AnyObject'}0 "
       "cannot contain '~%1'",
       (bool, StringRef, Type))
+ERROR(inverse_conflicts_explicit_composition, none,
+      "composition cannot contain '~%0' when another member requires '%0'",
+      (StringRef))
 ERROR(inverse_extension, none,
       "cannot apply inverse %0 to extension",
       (Type))

include/swift/AST/Requirement.h

@@ -255,15 +255,26 @@ struct InverseRequirement {
   static void enumerateDefaultedParams(GenericContext *decl,
                                        SmallVectorImpl<Type> &result);
 
-  /// \returns the protocols that are required by default for the given type
-  /// parameter. These are not inverses themselves.
-  static InvertibleProtocolSet expandDefault(Type gp);
-
   /// Appends additional requirements corresponding to defaults for the given
   /// generic parameters.
   static void expandDefaults(ASTContext &ctx,
                              ArrayRef<Type> gps,
                              SmallVectorImpl<StructuralRequirement> &result);
+
+  /// Adds the inferred default protocols for an assumed generic parameter with
+  /// respect to that parameter's inverses and existing required protocols.
+  /// For example, if an inverse ~P exists, then P will not be added to the
+  /// protocols list.
+  ///
+  /// Similarly, if the protocols list has a protocol Q that already implies
+  /// Copyable, then we will not add `Copyable` to the protocols list.
+  ///
+  /// \param inverses the inverses '& ~P' that are applied to the generic param.
+  /// \param protocols the existing required protocols, to which defaults will
+  ///                  be appended.
+  static void expandDefaults(ASTContext &ctx,
+                             InvertibleProtocolSet inverses,
+                             SmallVectorImpl<ProtocolDecl*> &protocols);
 };
 
 } // end namespace swift

lib/AST/Requirement.cpp

@@ -342,27 +342,64 @@ void InverseRequirement::enumerateDefaultedParams(
     add(gtpd->getDeclaredInterfaceType());
 }
 
-InvertibleProtocolSet InverseRequirement::expandDefault(Type gp) {
-  assert(gp->isTypeParameter());
-  return InvertibleProtocolSet::full();
-}
-
 void InverseRequirement::expandDefaults(
     ASTContext &ctx,
     ArrayRef<Type> gps,
     SmallVectorImpl<StructuralRequirement> &result) {
-  if (!ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics))
+
+  SmallVector<ProtocolDecl*, NumInvertibleProtocols> defaults;
+  expandDefaults(ctx, /*inverses=*/{}, defaults);
+
+  // Fast-path.
+  if (defaults.empty())
     return;
 
   for (auto gp : gps) {
-    auto protos = InverseRequirement::expandDefault(gp);
-    for (auto ip : protos) {
-      auto proto = ctx.getProtocol(getKnownProtocolKind(ip));
-      assert(proto && "missing Copyable/Escapable from stdlib!");
-      
+    for (auto *proto : defaults) {
       auto protoTy = proto->getDeclaredInterfaceType();
       result.push_back({{RequirementKind::Conformance, gp, protoTy},
                         SourceLoc()});
     }
   }
 }
+
+void InverseRequirement::expandDefaults(
+    ASTContext &ctx,
+    InvertibleProtocolSet inverses,
+    SmallVectorImpl<ProtocolDecl*> &protocols) {
+
+  // Skip unless noncopyable generics is enabled
+  if (!ctx.LangOpts.hasFeature(swift::Feature::NoncopyableGenerics))
+    return;
+
+  // Try to add all invertible protocols, unless:
+  //  - an inverse was provided
+  //  - an existing protocol already requires it
+  for (auto ip : InvertibleProtocolSet::full()) {
+    // This matches with `lookupExistentialConformance`'s use of 'inheritsFrom'.
+    bool alreadyRequired = false;
+    for (auto proto : protocols) {
+      if (proto->isSpecificProtocol(getKnownProtocolKind(ip))
+          || proto->requiresInvertible(ip)) {
+        alreadyRequired = true;
+        break;
+      }
+    }
+
+    // If some protocol member already implies P, then we don't need to
+    // add a requirement for P.
+    if (alreadyRequired) {
+      assert(!inverses.contains(ip) && "cannot require P and ~P");
+      continue;
+    }
+
+    // Nothing implies P, so unless there's an inverse ~P, add the requirement.
+    if (inverses.contains(ip))
+      continue;
+
+    auto proto = ctx.getProtocol(getKnownProtocolKind(ip));
+    assert(proto && "missing Copyable/Escapable from stdlib!");
+
+    protocols.push_back(proto);
+  }
+}

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -926,8 +926,11 @@ StructuralRequirementsRequest::evaluate(Evaluator &evaluator,
                       SourceLoc()});
 
     desugarRequirements(result, inverses, errors);
-    InverseRequirement::expandDefaults(ctx, needsDefaultRequirements, result);
-    applyInverses(ctx, needsDefaultRequirements, inverses, result, errors);
+
+    SmallVector<StructuralRequirement, 2> defaults;
+    InverseRequirement::expandDefaults(ctx, needsDefaultRequirements, defaults);
+    applyInverses(ctx, needsDefaultRequirements, inverses, defaults, errors);
+    result.append(defaults);
 
     diagnoseRequirementErrors(ctx, errors,
                               AllowConcreteTypePolicy::NestedAssocTypes);
@@ -994,11 +997,13 @@ StructuralRequirementsRequest::evaluate(Evaluator &evaluator,
 
   desugarRequirements(result, inverses, errors);
 
+  SmallVector<StructuralRequirement, 2> defaults;
   // We do not expand defaults for invertible protocols themselves.
   if (!proto->getInvertibleProtocolKind())
-    InverseRequirement::expandDefaults(ctx, needsDefaultRequirements, result);
+    InverseRequirement::expandDefaults(ctx, needsDefaultRequirements, defaults);
 
-  applyInverses(ctx, needsDefaultRequirements, inverses, result, errors);
+  applyInverses(ctx, needsDefaultRequirements, inverses, defaults, errors);
+  result.append(defaults);
 
   diagnoseRequirementErrors(ctx, errors,
                             AllowConcreteTypePolicy::NestedAssocTypes);

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -667,8 +667,10 @@ AbstractGenericSignatureRequest::evaluate(
       paramsAsTypes.push_back(gtpt);
   }
 
-  InverseRequirement::expandDefaults(ctx, paramsAsTypes, requirements);
-  applyInverses(ctx, paramsAsTypes, inverses, requirements, errors);
+  SmallVector<StructuralRequirement, 2> defaults;
+  InverseRequirement::expandDefaults(ctx, paramsAsTypes, defaults);
+  applyInverses(ctx, paramsAsTypes, inverses, defaults, errors);
+  requirements.append(defaults);
 
   auto &rewriteCtx = ctx.getRewriteContext();
 
@@ -882,8 +884,10 @@ InferredGenericSignatureRequest::evaluate(
     paramTypes.append(genericParams.begin() + numOuterParams, genericParams.end());
   }
 
-  InverseRequirement::expandDefaults(ctx, paramTypes, requirements);
-  applyInverses(ctx, paramTypes, inverses, requirements, errors);
+  SmallVector<StructuralRequirement, 2> defaults;
+  InverseRequirement::expandDefaults(ctx, paramTypes, defaults);
+  applyInverses(ctx, paramTypes, inverses, defaults, errors);
+  requirements.append(defaults);
 
   auto &rewriteCtx = ctx.getRewriteContext();
 

lib/AST/Type.cpp

@@ -278,50 +278,7 @@ bool TypeBase::allowsOwnership(const GenericSignatureImpl *sig) {
   return getCanonicalType().allowsOwnership(sig);
 }
 
-/// Adds the inferred default protocols for an ExistentialLayout with respect
-/// to that existential's inverses and existing protocols. For example, if an
-/// inverse ~P exists, then P will not be added to the protocols list.
-///
-/// Similarly, if the protocols list has a protocol Q that already implies
-/// Copyable, then we will not add `Copyable` to the protocols list.
-///
-/// \param inverses the inverses '& ~P' that are in the existential's type.
-/// \param protocols the output vector of protocols for an ExistentialLayout
-///                  to be modified.
-static void expandDefaultProtocols(
-    ASTContext &ctx,
-    InvertibleProtocolSet inverses,
-    SmallVectorImpl<ProtocolDecl*> &protocols) {
-
-  // Skip unless noncopyable generics is enabled
-  if (!ctx.LangOpts.hasFeature(swift::Feature::NoncopyableGenerics))
-    return;
 
-  // Try to add all invertible protocols, unless:
-  //  - an inverse was provided
-  //  - an existing protocol already requires it
-  for (auto ip : InvertibleProtocolSet::full()) {
-    if (inverses.contains(ip))
-      continue;
-
-    // This matches with `lookupExistentialConformance`'s use of 'inheritsFrom'.
-    bool alreadyRequired = false;
-    for (auto proto : protocols) {
-      if (proto->requiresInvertible(ip)) {
-        alreadyRequired = true;
-        break;
-      }
-    }
-
-    if (alreadyRequired)
-      continue;
-
-    auto proto = ctx.getProtocol(getKnownProtocolKind(ip));
-    assert(proto && "missing Copyable/Escapable from stdlib!");
-
-    protocols.push_back(proto);
-  }
-}
 
 ExistentialLayout::ExistentialLayout(CanProtocolType type) {
   auto *protoDecl = type->getDecl();
@@ -336,7 +293,7 @@ ExistentialLayout::ExistentialLayout(CanProtocolType type) {
   protocols.push_back(protoDecl);
 
   // NOTE: all the invertible protocols are usable from ObjC.
-  expandDefaultProtocols(type->getASTContext(), {}, protocols);
+  InverseRequirement::expandDefaults(type->getASTContext(), {}, protocols);
 }
 
 ExistentialLayout::ExistentialLayout(CanProtocolCompositionType type) {
@@ -373,7 +330,9 @@ ExistentialLayout::ExistentialLayout(CanProtocolCompositionType type) {
       hasExplicitAnyObject && !explicitSuperclass && getProtocols().empty();
 
   // NOTE: all the invertible protocols are usable from ObjC.
-  expandDefaultProtocols(type->getASTContext(), type->getInverses(), protocols);
+  InverseRequirement::expandDefaults(type->getASTContext(),
+                                     type->getInverses(),
+                                     protocols);
 }
 
 ExistentialLayout::ExistentialLayout(CanParameterizedProtocolType type)
@@ -3939,7 +3898,7 @@ Type ProtocolCompositionType::get(const ASTContext &C,
                                   ArrayRef<Type> Members,
                                   InvertibleProtocolSet Inverses,
                                   bool HasExplicitAnyObject) {
-  // Fast path for 'AnyObject' and 'Any'.
+  // Fast path for 'AnyObject', 'Any', and '~Copyable'.
   if (Members.empty()) {
     return build(C, Members, Inverses, HasExplicitAnyObject);
   }
@@ -3994,6 +3953,13 @@ Type ProtocolCompositionType::get(const ASTContext &C,
       }
     }
 
+    // Drop any explicitly provided invertible protocols.
+    if (auto ip = proto->getInvertibleProtocolKind()) {
+      // We diagnose '~Copyable & Copyable' before forming the PCT.
+      assert(!Inverses.contains(*ip) && "opposing invertible constraints!");
+      continue;
+    }
+
     CanTypes.push_back(proto->getDeclaredInterfaceType());
   }
 

lib/Basic/LangOptions.cpp

@@ -47,6 +47,13 @@ LangOptions::LangOptions() {
 #endif
 
   // Note: Introduce default-on language options here.
+
+  // Default-on NoncopyableGenerics when the build-script setting is enabled.
+  if (SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS) {
+    Features.insert(Feature::NoncopyableGenerics);
+    EnableExperimentalAssociatedTypeInference = true;
+  }
+
   // Enable any playground options that are enabled by default.
 #define PLAYGROUND_OPTION(OptionName, Description, DefaultOn, HighPerfOn) \
   if (DefaultOn) \

lib/DriverTool/sil_opt_main.cpp

@@ -645,8 +645,6 @@ int sil_opt_main(ArrayRef<const char *> argv, void *MainAddr) {
     Invocation.getLangOptions().enableFeature(
         Feature::OldOwnershipOperatorSpellings);
   }
-  if (SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS)
-    Invocation.getLangOptions().enableFeature(Feature::NoncopyableGenerics);
 
   Invocation.getLangOptions().BypassResilienceChecks =
       options.BypassResilienceChecks;

lib/Frontend/CompilerInvocation.cpp

@@ -895,11 +895,6 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
 
   Opts.enableFeature(Feature::LayoutPrespecialization);
 
-  if (SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS) {
-    Opts.enableFeature(Feature::NoncopyableGenerics);
-    Opts.EnableExperimentalAssociatedTypeInference = true;
-  }
-
   Opts.EnableAppExtensionLibraryRestrictions |= Args.hasArg(OPT_enable_app_extension_library);
   Opts.EnableAppExtensionRestrictions |= Args.hasArg(OPT_enable_app_extension);
   Opts.EnableAppExtensionRestrictions |= Opts.EnableAppExtensionLibraryRestrictions;

lib/Sema/TypeCheckType.cpp

@@ -5401,6 +5401,46 @@ NeverNullType TypeResolver::resolveTupleType(TupleTypeRepr *repr,
   return TupleType::get(elements, ctx);
 }
 
+/// \returns the inverse ~P that is conflicted if a protocol in \c tys
+/// requires P. For example, `Q & ~Copyable` is a conflict, if `Q` requires
+/// or is equal to `Copyable`
+static std::optional<InvertibleProtocolKind>
+hasConflictedInverse(ArrayRef<Type> tys, InvertibleProtocolSet inverses) {
+  // Fast-path: no inverses that could be conflicted!
+  if (inverses.empty())
+    return std::nullopt;
+
+  for (auto ty : tys) {
+    // Handle nested PCT's recursively since we haven't flattened them away yet.
+    if (auto pct = dyn_cast<ProtocolCompositionType>(ty)) {
+      if (auto conflict = hasConflictedInverse(pct->getMembers(), inverses))
+        return conflict;
+      continue;
+    }
+
+    // Dig out a protocol.
+    ProtocolDecl *decl = nullptr;
+    if (auto protoTy = dyn_cast<ProtocolType>(ty))
+      decl = protoTy->getDecl();
+    else if (auto paramProtoTy = dyn_cast<ParameterizedProtocolType>(ty))
+      decl = paramProtoTy->getProtocol();
+
+    if (!decl)
+      continue;
+
+    // If an inverse ~I exists for this protocol member of the PCT that
+    // requires I, then it's a conflict.
+    for (auto inverse : inverses) {
+      if (decl->isSpecificProtocol(getKnownProtocolKind(inverse))
+          || decl->requiresInvertible(inverse)) {
+        return inverse;
+      }
+    }
+  }
+
+  return std::nullopt;
+}
+
 NeverNullType
 TypeResolver::resolveCompositionType(CompositionTypeRepr *repr,
                                      TypeResolutionOptions options) {
@@ -5496,6 +5536,13 @@ TypeResolver::resolveCompositionType(CompositionTypeRepr *repr,
     IsInvalid = true;
   }
 
+  // Cannot provide an inverse in the same composition requiring the protocol.
+  if (auto conflict = hasConflictedInverse(Members, Inverses)) {
+    diagnose(repr->getLoc(),
+       diag::inverse_conflicts_explicit_composition,
+       getProtocolName(getKnownProtocolKind(*conflict)));
+    IsInvalid = true;
+  }
 
   if (IsInvalid) {
     repr->setInvalid();