Merge pull request swiftlang#41183 from DougGregor/implicitly-open-existentials

Author: DougGregor

include/swift/AST/Decl.h

@@ -2159,9 +2159,9 @@ class PoundDiagnosticDecl : public Decl {
 class OpaqueTypeDecl;
 
 /// Describes the least favorable positions at which a requirement refers
-/// to 'Self' in terms of variance, for use in the is-inheritable and
-/// is-available-existential checks.
-class SelfReferenceInfo final {
+/// to a given generic parameter in terms of variance, for use in the
+/// is-inheritable and is-available-existential checks.
+class GenericParameterReferenceInfo final {
   using OptionalTypePosition = OptionalEnum<decltype(TypePosition::Covariant)>;
 
 public:
@@ -2171,27 +2171,27 @@ class SelfReferenceInfo final {
   OptionalTypePosition assocTypeRef;
 
   /// A reference to 'Self'.
-  static SelfReferenceInfo forSelfRef(TypePosition position) {
-    return SelfReferenceInfo(false, position, llvm::None);
+  static GenericParameterReferenceInfo forSelfRef(TypePosition position) {
+    return GenericParameterReferenceInfo(false, position, llvm::None);
   }
 
   /// A reference to 'Self' through an associated type.
-  static SelfReferenceInfo forAssocTypeRef(TypePosition position) {
-    return SelfReferenceInfo(false, llvm::None, position);
+  static GenericParameterReferenceInfo forAssocTypeRef(TypePosition position) {
+    return GenericParameterReferenceInfo(false, llvm::None, position);
   }
 
-  SelfReferenceInfo &operator|=(const SelfReferenceInfo &other);
+  GenericParameterReferenceInfo &operator|=(const GenericParameterReferenceInfo &other);
 
   explicit operator bool() const {
     return hasCovariantSelfResult || selfRef || assocTypeRef;
   }
 
-  SelfReferenceInfo()
+  GenericParameterReferenceInfo()
       : hasCovariantSelfResult(false), selfRef(llvm::None),
         assocTypeRef(llvm::None) {}
 
 private:
-  SelfReferenceInfo(bool hasCovariantSelfResult, OptionalTypePosition selfRef,
+  GenericParameterReferenceInfo(bool hasCovariantSelfResult, OptionalTypePosition selfRef,
                     OptionalTypePosition assocTypeRef)
       : hasCovariantSelfResult(hasCovariantSelfResult), selfRef(selfRef),
         assocTypeRef(assocTypeRef) {}
@@ -2682,7 +2682,7 @@ class ValueDecl : public Decl {
   /// is considered covariant only when it appears as the immediate type of a
   /// property, or the uncurried result type of a method/subscript, e.g.
   /// '() -> () -> Self'.
-  SelfReferenceInfo findExistentialSelfReferences(
+  GenericParameterReferenceInfo findExistentialSelfReferences(
       Type baseTy, bool treatNonResultCovariantSelfAsInvariant) const;
 };
 
@@ -7800,6 +7800,14 @@ class MissingMemberDecl : public Decl {
   }
 };
 
+/// Find references to the given generic paramaeter in the generic signature
+/// and the type of the given value.
+GenericParameterReferenceInfo findGenericParameterReferences(
+    const ValueDecl *value,
+    CanGenericSignature sig, GenericTypeParamType *genericParam,
+    bool treatNonResultCovarianceAsInvariant,
+    Optional<unsigned> skipParamIndex);
+
 inline bool AbstractStorageDecl::isSettable(const DeclContext *UseDC,
                                             const DeclRefExpr *base) const {
   if (auto vd = dyn_cast<VarDecl>(this))

include/swift/Basic/LangOptions.h

@@ -313,6 +313,10 @@ namespace swift {
     /// `func f() -> <T> T`.
     bool EnableExperimentalNamedOpaqueTypes = false;
 
+    /// Enable support for implicitly opening existential argument types
+    /// in calls to generic functions.
+    bool EnableOpenedExistentialTypes = false;
+
     /// Enable support for protocol types parameterized by primary
     /// associated type.
     bool EnableParameterizedProtocolTypes = false;

include/swift/Option/FrontendOptions.td

@@ -514,6 +514,14 @@ def enable_parameterized_protocol_types :
   Flag<["-"], "enable-parameterized-protocol-types">,
   HelpText<"Enable experimental support for primary associated types and parameterized protocols">;
 
+def enable_experimental_opened_existential_types :
+  Flag<["-"], "enable-experimental-opened-existential-types">,
+  HelpText<"Enable experimental support for implicitly opened existentials">;
+
+def disable_experimental_opened_existential_types :
+  Flag<["-"], "disble-experimental-opened-existential-types">,
+  HelpText<"Disable experimental support for implicitly opened existentials">;
+
 def enable_deserialization_recovery :
   Flag<["-"], "enable-deserialization-recovery">,
   HelpText<"Attempt to recover from missing xrefs (etc) in swiftmodules">;

include/swift/Sema/ConstraintSystem.h

@@ -3353,6 +3353,11 @@ class ConstraintSystem {
   ConstraintLocator *getOpenOpaqueLocator(
       ConstraintLocatorBuilder locator, OpaqueTypeDecl *opaqueDecl);
 
+  /// Open the given existential type, recording the opened type in the
+  /// constraint system and returning both it and the root opened archetype.
+  std::pair<Type, OpenedArchetypeType *> openExistentialType(
+      Type type, ConstraintLocator *locator);
+
   /// Retrive the constraint locator for the given anchor and
   /// path, uniqued and automatically infer the summary flags
   ConstraintLocator *
@@ -5506,20 +5511,16 @@ matchCallArguments(
     MatchCallArgumentListener &listener,
     Optional<TrailingClosureMatching> trailingClosureMatching);
 
-ConstraintSystem::TypeMatchResult
-matchCallArguments(ConstraintSystem &cs,
-                   FunctionType *contextualType,
-                   ArgumentList *argumentList,
-                   ArrayRef<AnyFunctionType::Param> args,
-                   ArrayRef<AnyFunctionType::Param> params,
-                   ConstraintKind subKind,
-                   ConstraintLocatorBuilder locator,
-                   Optional<TrailingClosureMatching> trailingClosureMatching);
-
 /// Given an expression that is the target of argument labels (for a call,
 /// subscript, etc.), find the underlying target expression.
 Expr *getArgumentLabelTargetExpr(Expr *fn);
 
+/// Given a type that includes an existential type that has been opened to
+/// the given type variable, type-erase occurences of that opened type
+/// variable and anything that depends on it to their non-dependent bounds.
+Type typeEraseOpenedExistentialReference(Type type, Type existentialBaseType,
+                                         TypeVariableType *openedTypeVar);
+
 /// Returns true if a reference to a member on a given base type will apply
 /// its curried self parameter, assuming it has one.
 ///