Merge pull request #41436 from xedin/allow-specialization-from-default-expr

[TypeChecker] Allow inference from default expressions in certain scenarios (under a flag)

Author: xedin

include/swift/AST/Decl.h

@@ -5504,6 +5504,7 @@ enum class ParamSpecifier : uint8_t {
 class ParamDecl : public VarDecl {
   friend class DefaultArgumentInitContextRequest;
   friend class DefaultArgumentExprRequest;
+  friend class DefaultArgumentTypeRequest;
 
   enum class ArgumentNameFlags : uint8_t {
     /// Whether or not this parameter is destructed.
@@ -5524,6 +5525,9 @@ class ParamDecl : public VarDecl {
   struct alignas(1 << StoredDefaultArgumentAlignInBits) StoredDefaultArgument {
     PointerUnion<Expr *, VarDecl *> DefaultArg;
 
+    /// The type of the default argument expression.
+    Type ExprType;
+
     /// Stores the context for the default argument as well as a bit to
     /// indicate whether the default expression has been type-checked.
     llvm::PointerIntPair<Initializer *, 1, bool> InitContextAndIsTypeChecked;
@@ -5641,6 +5645,10 @@ class ParamDecl : public VarDecl {
     return nullptr;
   }
 
+  /// Retrieve the type of the default expression (if any) associated with
+  /// this parameter declaration.
+  Type getTypeOfDefaultExpr() const;
+
   VarDecl *getStoredProperty() const {
     if (auto stored = DefaultValueAndFlags.getPointer())
       return stored->DefaultArg.dyn_cast<VarDecl *>();
@@ -5655,6 +5663,10 @@ class ParamDecl : public VarDecl {
   /// parameter's fully type-checked default argument.
   void setDefaultExpr(Expr *E, bool isTypeChecked);
 
+  /// Sets a type of default expression associated with this parameter.
+  /// This should only be called by deserialization.
+  void setDefaultExprType(Type type);
+
   void setStoredProperty(VarDecl *var);
 
   /// Retrieve the initializer context for the parameter's default argument.

include/swift/AST/DiagnosticsSema.def

@@ -38,6 +38,8 @@ NOTE(extended_type_declared_here,none,
      "extended type declared here", ())
 NOTE(opaque_return_type_declared_here,none,
      "opaque return type declared here", ())
+NOTE(default_value_declared_here,none,
+     "default value declared here", ())
 
 //------------------------------------------------------------------------------
 // MARK: Constraint solver diagnostics
@@ -6240,5 +6242,28 @@ ERROR(type_sequence_on_non_generic_param, none,
       "'@_typeSequence' must appear on a generic parameter",
       ())
 
+//------------------------------------------------------------------------------
+// MARK: Type inference from default expressions
+//------------------------------------------------------------------------------
+
+ERROR(cannot_default_generic_parameter_inferrable_from_another_parameter, none,
+      "cannot use default expression for inference of %0 because it "
+      "is inferrable from parameters %1",
+      (Type, StringRef))
+
+ERROR(cannot_default_generic_parameter_inferrable_through_same_type, none,
+      "cannot use default expression for inference of %0 because it "
+      "is inferrable through same-type requirement: '%1'",
+      (Type, StringRef))
+
+ERROR(cannot_default_generic_parameter_invalid_requirement, none,
+      "cannot use default expression for inference of %0 because "
+      "requirement '%1' refers to other generic parameters",
+      (Type, StringRef))
+
+ERROR(cannot_convert_default_value_type_to_argument_type, none,
+      "cannot convert default value of type %0 to expected argument type %1 for parameter #%2",
+      (Type, Type, unsigned))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/TypeCheckRequests.h

@@ -41,6 +41,7 @@ class AccessorDecl;
 enum class AccessorKind;
 class ContextualPattern;
 class DefaultArgumentExpr;
+class DefaultArgumentType;
 class ClosureExpr;
 class GenericParamList;
 class PrecedenceGroupDecl;
@@ -2665,6 +2666,26 @@ class DefaultArgumentExprRequest
   void cacheResult(Expr *expr) const;
 };
 
+/// Computes the type of the default expression for a given parameter.
+class DefaultArgumentTypeRequest
+    : public SimpleRequest<DefaultArgumentTypeRequest, Type(ParamDecl *),
+                           RequestFlags::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  Type evaluate(Evaluator &evaluator, ParamDecl *param) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<Type> getCachedResult() const;
+  void cacheResult(Type type) const;
+};
+
 /// Computes the fully type-checked caller-side default argument within the
 /// context of the call site that it will be inserted into.
 class CallerSideDefaultArgExprRequest

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -59,6 +59,8 @@ SWIFT_REQUEST(TypeChecker, CustomAttrTypeRequest,
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DefaultArgumentExprRequest,
               Expr *(ParamDecl *), SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, DefaultArgumentTypeRequest,
+              Type(ParamDecl *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DefaultArgumentInitContextRequest,
               Initializer *(ParamDecl *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DefaultDefinitionTypeRequest,

include/swift/Basic/LangOptions.h

@@ -718,6 +718,10 @@ namespace swift {
     /// closures.
     bool EnableMultiStatementClosureInference = false;
 
+    /// Enable experimental support for generic parameter inference in
+    /// parameter positions from associated default expressions.
+    bool EnableTypeInferenceFromDefaultArguments = false;
+
     /// See \ref FrontendOptions.PrintFullConvention
     bool PrintFullConvention = false;
   };

include/swift/Option/FrontendOptions.td

@@ -861,6 +861,10 @@ def experimental_multi_statement_closures :
   Flag<["-"], "experimental-multi-statement-closures">,
   HelpText<"Enable experimental support for type inference in multi-statement closures">;
 
+def experimental_type_inference_from_defaults :
+  Flag<["-"], "enable-experimental-type-inference-from-defaults">,
+  HelpText<"Enable experimental support for generic parameter inference from default values">;
+
 def prebuilt_module_cache_path :
   Separate<["-"], "prebuilt-module-cache-path">,
   HelpText<"Directory of prebuilt modules for loading module interfaces">;

include/swift/Sema/CSFix.h

@@ -382,6 +382,10 @@ enum class FixKind : uint8_t {
 
   /// Produce an error for not getting a compile-time constant
   NotCompileTimeConst,
+
+  /// Ignore a type mismatch while trying to infer generic parameter type
+  /// from default expression.
+  IgnoreDefaultExprTypeMismatch,
 };
 
 class ConstraintFix {
@@ -2896,6 +2900,29 @@ class AllowSwiftToCPointerConversion final : public ConstraintFix {
                                                 ConstraintLocator *locator);
 };
 
+class IgnoreDefaultExprTypeMismatch : public AllowArgumentMismatch {
+protected:
+  IgnoreDefaultExprTypeMismatch(ConstraintSystem &cs, Type argType,
+                                Type paramType, ConstraintLocator *locator)
+      : AllowArgumentMismatch(cs, FixKind::IgnoreDefaultExprTypeMismatch,
+                              argType, paramType, locator) {}
+
+public:
+  std::string getName() const override {
+    return "allow default expression conversion mismatch";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  static IgnoreDefaultExprTypeMismatch *create(ConstraintSystem &cs,
+                                               Type argType, Type paramType,
+                                               ConstraintLocator *locator);
+
+  static bool classof(const ConstraintFix *fix) {
+    return fix->getKind() == FixKind::IgnoreDefaultExprTypeMismatch;
+  }
+};
+
 } // end namespace constraints
 } // end namespace swift
 

include/swift/Sema/ConstraintSystem.h

@@ -80,6 +80,8 @@ Optional<constraints::SolutionApplicationTarget>
 typeCheckExpression(constraints::SolutionApplicationTarget &target,
                     OptionSet<TypeCheckExprFlags> options);
 
+Type typeCheckParameterDefault(Expr *&, DeclContext *, Type, bool);
+
 } // end namespace TypeChecker
 
 } // end namespace swift
@@ -3045,6 +3047,10 @@ class ConstraintSystem {
   swift::TypeChecker::typeCheckExpression(
       SolutionApplicationTarget &target, OptionSet<TypeCheckExprFlags> options);
 
+  friend Type swift::TypeChecker::typeCheckParameterDefault(Expr *&,
+                                                            DeclContext *, Type,
+                                                            bool);
+
   /// Emit the fixes computed as part of the solution, returning true if we were
   /// able to emit an error message, or false if none of the fixits worked out.
   bool applySolutionFixes(const Solution &solution);
@@ -4167,6 +4173,13 @@ class ConstraintSystem {
                              OpenedTypeMap &replacements,
                              ConstraintLocatorBuilder locator);
 
+  /// Open a generic parameter into a type variable and record
+  /// it in \c replacements.
+  TypeVariableType *openGenericParameter(DeclContext *outerDC,
+                                         GenericTypeParamType *parameter,
+                                         OpenedTypeMap &replacements,
+                                         ConstraintLocatorBuilder locator);
+
   /// Given generic signature open its generic requirements,
   /// using substitution function, and record them in the
   /// constraint system for further processing.
@@ -4176,6 +4189,14 @@ class ConstraintSystem {
                                ConstraintLocatorBuilder locator,
                                llvm::function_ref<Type(Type)> subst);
 
+  // Record the given requirement in the constraint system.
+  void openGenericRequirement(DeclContext *outerDC,
+                              unsigned index,
+                              const Requirement &requirement,
+                              bool skipProtocolSelfConstraint,
+                              ConstraintLocatorBuilder locator,
+                              llvm::function_ref<Type(Type)> subst);
+
   /// Record the set of opened types for the given locator.
   void recordOpenedTypes(
          ConstraintLocatorBuilder locator,

lib/AST/Decl.cpp

@@ -6992,6 +6992,18 @@ Expr *ParamDecl::getTypeCheckedDefaultExpr() const {
   return new (ctx) ErrorExpr(getSourceRange(), ErrorType::get(ctx));
 }
 
+Type ParamDecl::getTypeOfDefaultExpr() const {
+  auto &ctx = getASTContext();
+
+  if (Type type = evaluateOrDefault(
+          ctx.evaluator,
+          DefaultArgumentTypeRequest{const_cast<ParamDecl *>(this)}, nullptr)) {
+    return type;
+  }
+
+  return Type();
+}
+
 void ParamDecl::setDefaultExpr(Expr *E, bool isTypeChecked) {
   if (!DefaultValueAndFlags.getPointer()) {
     if (!E) return;
@@ -7009,9 +7021,20 @@ void ParamDecl::setDefaultExpr(Expr *E, bool isTypeChecked) {
            "Can't overwrite type-checked default with un-type-checked default");
   }
   defaultInfo->DefaultArg = E;
+  defaultInfo->ExprType = E->getType();
   defaultInfo->InitContextAndIsTypeChecked.setInt(isTypeChecked);
 }
 
+void ParamDecl::setDefaultExprType(Type type) {
+  if (!DefaultValueAndFlags.getPointer()) {
+    DefaultValueAndFlags.setPointer(
+        getASTContext().Allocate<StoredDefaultArgument>());
+  }
+
+  auto *defaultInfo = DefaultValueAndFlags.getPointer();
+  defaultInfo->ExprType = type;
+}
+
 void ParamDecl::setStoredProperty(VarDecl *var) {
   if (!DefaultValueAndFlags.getPointer()) {
     if (!var) return;

lib/AST/TypeCheckRequests.cpp

@@ -1206,6 +1206,27 @@ void DefaultArgumentExprRequest::cacheResult(Expr *expr) const {
   param->setDefaultExpr(expr, /*isTypeChecked*/ true);
 }
 
+//----------------------------------------------------------------------------//
+// DefaultArgumentTypeRequest computation.
+//----------------------------------------------------------------------------//
+
+Optional<Type> DefaultArgumentTypeRequest::getCachedResult() const {
+  auto *param = std::get<0>(getStorage());
+  auto *defaultInfo = param->DefaultValueAndFlags.getPointer();
+  if (!defaultInfo)
+    return None;
+
+  if (!defaultInfo->InitContextAndIsTypeChecked.getInt())
+    return None;
+
+  return defaultInfo->ExprType;
+}
+
+void DefaultArgumentTypeRequest::cacheResult(Type type) const {
+  auto *param = std::get<0>(getStorage());
+  param->setDefaultExprType(type);
+}
+
 //----------------------------------------------------------------------------//
 // CallerSideDefaultArgExprRequest computation.
 //----------------------------------------------------------------------------//

lib/Frontend/CompilerInvocation.cpp

@@ -1051,6 +1051,9 @@ static bool ParseTypeCheckerArgs(TypeCheckerOptions &Opts, ArgList &Args,
   Opts.EnableMultiStatementClosureInference |=
       Args.hasArg(OPT_experimental_multi_statement_closures);
 
+  Opts.EnableTypeInferenceFromDefaultArguments |=
+      Args.hasArg(OPT_experimental_type_inference_from_defaults);
+
   Opts.PrintFullConvention |=
       Args.hasArg(OPT_experimental_print_full_convention);
 

lib/SIL/IR/TypeLowering.cpp

@@ -2456,8 +2456,16 @@ static CanAnyFunctionType getDefaultArgGeneratorInterfaceType(
                                                      TypeConverter &TC,
                                                      SILDeclRef c) {
   auto *vd = c.getDecl();
-  auto resultTy = getParameterAt(vd,
-                                 c.defaultArgIndex)->getInterfaceType();
+  auto *pd = getParameterAt(vd, c.defaultArgIndex);
+
+  Type resultTy;
+
+  if (auto type = pd->getTypeOfDefaultExpr()) {
+    resultTy = type->mapTypeOutOfContext();
+  } else {
+    resultTy = pd->getInterfaceType();
+  }
+
   assert(resultTy && "Didn't find default argument?");
 
   // The result type might be written in terms of type parameters

lib/Sema/CSDiagnostics.cpp

@@ -257,6 +257,11 @@ ValueDecl *RequirementFailure::getDeclRef() const {
       return cast<ValueDecl>(getDC()->getAsDecl());
     }
 
+    if (contextualPurpose == CTP_DefaultParameter ||
+        contextualPurpose == CTP_AutoclosureDefaultParameter) {
+      return cast<ValueDecl>(getDC()->getParent()->getAsDecl());
+    }
+
     return getAffectedDeclFromType(contextualTy);
   }
 
@@ -8087,3 +8092,27 @@ bool SwiftToCPointerConversionInInvalidContext::diagnoseAsError() {
                  paramType, callee->getDescriptiveKind(), callee->getName());
   return true;
 }
+
+bool DefaultExprTypeMismatch::diagnoseAsError() {
+  auto *locator = getLocator();
+
+  unsigned paramIdx =
+      locator->castLastElementTo<LocatorPathElt::ApplyArgToParam>()
+          .getParamIdx();
+
+  emitDiagnostic(diag::cannot_convert_default_value_type_to_argument_type,
+                 getFromType(), getToType(), paramIdx);
+
+  auto overload = getCalleeOverloadChoiceIfAvailable(locator);
+  assert(overload);
+
+  auto *PD = getParameterList(overload->choice.getDecl())->get(paramIdx);
+
+  auto note = emitDiagnosticAt(PD->getLoc(), diag::default_value_declared_here);
+
+  if (auto *defaultExpr = PD->getTypeCheckedDefaultExpr()) {
+    note.highlight(defaultExpr->getSourceRange());
+  }
+
+  return true;
+}

lib/Sema/CSDiagnostics.h

@@ -2665,6 +2665,28 @@ class SwiftToCPointerConversionInInvalidContext final
   bool diagnoseAsError() override;
 };
 
+/// Diagnose situations where the type of default expression doesn't
+/// match expected type of the argument i.e. generic parameter type
+/// was inferred from result:
+///
+/// \code
+/// func test<T>(_: T = 42) -> T { ... }
+///
+/// let _: String = test() // conflict between `String` and `Int`.
+/// \endcode
+class DefaultExprTypeMismatch final : public ContextualFailure {
+public:
+  DefaultExprTypeMismatch(const Solution &solution, Type argType,
+                          Type paramType, ConstraintLocator *locator)
+      : ContextualFailure(solution, argType, paramType, locator) {}
+
+  SourceLoc getLoc() const override {
+    return constraints::getLoc(getLocator()->getAnchor());
+  }
+
+  bool diagnoseAsError() override;
+};
+
 } // end namespace constraints
 } // end namespace swift