Merge pull request #5437 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

CHANGELOG.md

@@ -5,6 +5,39 @@
 
 ## Swift 5.9
 
+* [SE-0380][]:
+
+  `if` and `switch` statements may now be used as expressions to:
+
+  * Return values from functions, properties, and closures (either with
+    implicit or explicit `return`)
+  * Throw errors using `throw`
+  * Assign values to variables
+  * Declare variables
+
+  Each branch of the `if` or `switch` must be a single expression, the value
+  of which becomes the value of the overall expression when that branch is
+  chosen.
+
+  ```swift
+  let bullet =
+    if isRoot && (count == 0 || !willExpand) { "" }
+    else if count == 0 { "- " }
+    else if maxDepth <= 0 { "▹ " }
+    else { "▿ " }
+  ```
+
+  ```swift
+  public static func width(_ x: Unicode.Scalar) -> Int {
+    switch x.value {
+      case 0..<0x80: 1
+      case 0x80..<0x0800: 2
+      case 0x0800..<0x1_0000: 3
+      default: 4
+    }
+  }
+  ```
+
 * [#64927][]:
 
   Swift 5.9 introduces warnings that catch conversions from an inout
@@ -9732,6 +9765,7 @@ using the `.dynamicType` member to retrieve the type of an expression should mig
 [SE-0370]: <https://github.com/apple/swift-evolution/blob/main/proposals/0370-pointer-family-initialization-improvements.md>
 [SE-0376]: <https://github.com/apple/swift-evolution/blob/main/proposals/0376-function-back-deployment.md>
 [SE-0377]: <https://github.com/apple/swift-evolution/blob/main/proposals/0377-parameter-ownership-modifiers.md>
+[SE-0380]: <https://github.com/apple/swift-evolution/blob/main/proposals/0380-if-switch-expressions.md>
 
 [#64927]: <https://github.com/apple/swift/issues/64927>
 [#42697]: <https://github.com/apple/swift/issues/42697>

include/swift/Frontend/BackDeploymentLibs.def

@@ -21,13 +21,14 @@
 //===----------------------------------------------------------------------===//
 
 #ifndef BACK_DEPLOYMENT_LIB
-#  error "Must define BACK_DEPLOYMENT_LIB(Version, Filter, Library)"
+#  error "Must define BACK_DEPLOYMENT_LIB(Version, Filter, Library, ForceLoad)"
 #endif
 
-BACK_DEPLOYMENT_LIB((5, 0), all, "swiftCompatibility50")
-BACK_DEPLOYMENT_LIB((5, 1), all, "swiftCompatibility51")
-BACK_DEPLOYMENT_LIB((5, 0), executable, "swiftCompatibilityDynamicReplacements")
-BACK_DEPLOYMENT_LIB((5, 4), all, "swiftCompatibilityConcurrency")
-BACK_DEPLOYMENT_LIB((5, 6), all, "swiftCompatibility56")
+BACK_DEPLOYMENT_LIB((5, 0), all, "swiftCompatibility50", true)
+BACK_DEPLOYMENT_LIB((5, 1), all, "swiftCompatibility51", true)
+BACK_DEPLOYMENT_LIB((5, 0), executable, "swiftCompatibilityDynamicReplacements", true)
+BACK_DEPLOYMENT_LIB((5, 4), all, "swiftCompatibilityConcurrency", true)
+BACK_DEPLOYMENT_LIB((5, 6), all, "swiftCompatibility56", true)
+BACK_DEPLOYMENT_LIB((5, 8), all, "swiftCompatibilityPacks", false)
 
 #undef BACK_DEPLOYMENT_LIB

include/swift/IDE/ArgumentCompletion.h

@@ -29,8 +29,8 @@ class ArgumentTypeCheckCompletionCallback : public TypeCheckCompletionCallback {
     Type ExpectedCallType;
     /// True if this is a subscript rather than a function call.
     bool IsSubscript;
-    /// The reference to the FuncDecl or SubscriptDecl associated with the call.
-    ConcreteDeclRef FuncDeclRef;
+    /// The FuncDecl or SubscriptDecl associated with the call.
+    ValueDecl *FuncD;
     /// The type of the function being called.
     AnyFunctionType *FuncTy;
     /// The index of the argument containing the completion location
@@ -50,14 +50,18 @@ class ArgumentTypeCheckCompletionCallback : public TypeCheckCompletionCallback {
     /// Whether the surrounding context is async and thus calling async
     /// functions is supported.
     bool IsInAsyncContext;
+    /// A bitfield to mark whether the parameter at a given index is optional.
+    /// Parameters can be optional if they have a default argument or belong to
+    /// a parameter pack.
+    /// Indices are based on the parameters in \c FuncTy. Note that the number
+    /// of parameters in \c FuncTy and \c FuncD is different when a parameter
+    /// pack has been exploded.
+    llvm::BitVector DeclParamIsOptional;
 
     /// Types of variables that were determined in the solution that produced
     /// this result. This in particular includes parameters of closures that
     /// were type-checked with the code completion expression.
     llvm::SmallDenseMap<const VarDecl *, Type> SolutionSpecificVarTypes;
-
-    /// Return the \c FuncDecl or \c SubscriptDecl associated with this call.
-    ValueDecl *getFuncD() const { return FuncDeclRef.getDecl(); }
   };
 
   CodeCompletionExpr *CompletionExpr;

lib/AST/ASTScopePrinting.cpp

@@ -148,11 +148,10 @@ NullablePtr<const void> ASTScopeImpl::addressForPrinting() const {
 void GenericTypeOrExtensionScope::printSpecifics(llvm::raw_ostream &out) const {
   if (shouldHaveABody() && !doesDeclHaveABody())
     out << "<no body>";
-  // Sadly, the following can trip assertions
-  //  else if (auto *n = getCorrespondingNominalTypeDecl().getPtrOrNull())
-  //    out << "'" << n->getFullName() << "'";
-  //  else
-  //    out << "<no extended nominal?!>";
+  else if (auto *n = getCorrespondingNominalTypeDecl().getPtrOrNull())
+    out << "'" << n->getName() << "'";
+  else
+    out << "<no extended nominal?!>";
 }
 
 void GenericParamScope::printSpecifics(llvm::raw_ostream &out) const {

lib/Basic/TargetInfo.cpp

@@ -23,8 +23,8 @@ using namespace swift;
 /// Print information about a
 static void printCompatibilityLibrary(
     llvm::VersionTuple runtimeVersion, llvm::VersionTuple maxVersion,
-    StringRef filter, StringRef libraryName, bool &printedAny,
-    llvm::raw_ostream &out) {
+    StringRef filter, StringRef libraryName, bool forceLoad,
+    bool &printedAny, llvm::raw_ostream &out) {
   if (runtimeVersion > maxVersion)
     return;
 
@@ -33,16 +33,21 @@ static void printCompatibilityLibrary(
   }
 
   out << "\n";
-  out << "      {\n";
+  out << "      {";
 
-  out << "        \"libraryName\": \"";
+  out << "\n        \"libraryName\": \"";
   swift::writeEscaped(libraryName, out);
-  out << "\",\n";
+  out << "\",";
 
-  out << "        \"filter\": \"";
+  out << "\n        \"filter\": \"";
   swift::writeEscaped(filter, out);
-  out << "\"\n";
-  out << "      }";
+  out << "\"";
+
+  if (!forceLoad) {
+    out << ",\n        \"forceLoad\": false";
+  }
+
+  out << "\n      }";
 
   printedAny = true;
 }
@@ -132,10 +137,10 @@ void targetinfo::printTripleInfo(const llvm::Triple &triple,
     // Compatibility libraries that need to be linked.
     out << "    \"compatibilityLibraries\": [";
     bool printedAnyCompatibilityLibrary = false;
-    #define BACK_DEPLOYMENT_LIB(Version, Filter, LibraryName)           \
-      printCompatibilityLibrary(                                        \
+    #define BACK_DEPLOYMENT_LIB(Version, Filter, LibraryName, ForceLoad)   \
+      printCompatibilityLibrary(                                           \
         *runtimeVersion, llvm::VersionTuple Version, #Filter, LibraryName, \
-        printedAnyCompatibilityLibrary, out);
+        ForceLoad, printedAnyCompatibilityLibrary, out);
     #include "swift/Frontend/BackDeploymentLibs.def"
 
     if (printedAnyCompatibilityLibrary) {

lib/Driver/DarwinToolChains.cpp

@@ -406,6 +406,8 @@ toolchains::Darwin::addArgsToLinkStdlib(ArgStringList &Arguments,
       runtimeCompatibilityVersion = llvm::VersionTuple(5, 5);
     } else if (value.equals("5.6")) {
       runtimeCompatibilityVersion = llvm::VersionTuple(5, 6);
+    } else if (value.equals("5.8")) {
+      runtimeCompatibilityVersion = llvm::VersionTuple(5, 8);
     } else if (value.equals("none")) {
       runtimeCompatibilityVersion = None;
     } else {
@@ -419,7 +421,8 @@ toolchains::Darwin::addArgsToLinkStdlib(ArgStringList &Arguments,
   if (runtimeCompatibilityVersion) {
     auto addBackDeployLib = [&](llvm::VersionTuple version,
                                 BackDeployLibFilter filter,
-                                StringRef libraryName) {
+                                StringRef libraryName,
+                                bool forceLoad) {
       if (*runtimeCompatibilityVersion > version)
         return;
 
@@ -431,14 +434,16 @@ toolchains::Darwin::addArgsToLinkStdlib(ArgStringList &Arguments,
       llvm::sys::path::append(BackDeployLib, "lib" + libraryName + ".a");
 
       if (llvm::sys::fs::exists(BackDeployLib)) {
-        Arguments.push_back("-force_load");
+        if (forceLoad)
+          Arguments.push_back("-force_load");
         Arguments.push_back(context.Args.MakeArgString(BackDeployLib));
       }
     };
 
-    #define BACK_DEPLOYMENT_LIB(Version, Filter, LibraryName) \
-      addBackDeployLib(                                       \
-          llvm::VersionTuple Version, BackDeployLibFilter::Filter, LibraryName);
+    #define BACK_DEPLOYMENT_LIB(Version, Filter, LibraryName, ForceLoad) \
+      addBackDeployLib(                                                  \
+          llvm::VersionTuple Version, BackDeployLibFilter::Filter,       \
+          LibraryName, ForceLoad);
     #include "swift/Frontend/BackDeploymentLibs.def"
   }
 

lib/Frontend/CompilerInvocation.cpp

@@ -2607,6 +2607,8 @@ static bool ParseIRGenArgs(IRGenOptions &Opts, ArgList &Args,
         runtimeCompatibilityVersion = llvm::VersionTuple(5, 5);
       } else if (version.equals("5.6")) {
         runtimeCompatibilityVersion = llvm::VersionTuple(5, 6);
+      } else if (version.equals("5.8")) {
+        runtimeCompatibilityVersion = llvm::VersionTuple(5, 8);
       } else {
         Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value,
                        versionArg->getAsString(Args), version);

lib/IDE/ArgumentCompletion.cpp

@@ -47,25 +47,8 @@ bool ArgumentTypeCheckCompletionCallback::addPossibleParams(
       break;
     }
 
-    // We work with the parameter from the function type and the declaration
-    // because they contain different information that we need.
-    //
-    // Since not all function types are backed by declarations (e.g. closure
-    // paramters), `DeclParam` might be `nullptr`.
     const AnyFunctionType::Param *TypeParam = &ParamsToPass[Idx];
-    const ParamDecl *DeclParam = nullptr;
-    if (Res.FuncDeclRef) {
-      DeclParam = getParameterAt(Res.FuncDeclRef, Idx);
-    }
-
-    bool Required = true;
-    if (DeclParam && DeclParam->isDefaultArgument()) {
-      Required = false;
-    } else if (DeclParam && DeclParam->getType()->is<PackExpansionType>()) {
-      Required = false;
-    } else if (TypeParam->isVariadic()) {
-      Required = false;
-    }
+    bool Required = !Res.DeclParamIsOptional[Idx];
 
     if (TypeParam->hasLabel() && !(IsCompletion && Res.IsNoninitialVariadic)) {
       // Suggest parameter label if parameter has label, we are completing in it
@@ -225,7 +208,7 @@ void ArgumentTypeCheckCompletionCallback::sawSolutionImpl(const Solution &S) {
 
   // If this is a duplicate of any other result, ignore this solution.
   if (llvm::any_of(Results, [&](const Result &R) {
-        return R.FuncDeclRef == Info.ValueRef &&
+        return R.FuncD == Info.getValue() &&
                nullableTypesEqual(R.FuncTy, Info.ValueTy) &&
                nullableTypesEqual(R.BaseType, Info.BaseTy) &&
                R.ParamIdx == ParamIdx &&
@@ -241,11 +224,34 @@ void ArgumentTypeCheckCompletionCallback::sawSolutionImpl(const Solution &S) {
   if (Info.ValueTy) {
     FuncTy = Info.ValueTy->lookThroughAllOptionalTypes()->getAs<AnyFunctionType>();
   }
+
+  // Determine which parameters are optional. We need to do this in
+  // `sawSolutionImpl` because it accesses the substitution map in
+  // `Info.ValueRef`. This substitution map might contain type variables that
+  // are allocated in the constraint system's arena and are freed once we reach
+  // `deliverResults`.
+  llvm::BitVector DeclParamIsOptional;
+  if (FuncTy) {
+    ArrayRef<AnyFunctionType::Param> ParamsToPass = FuncTy->getParams();
+    for (auto Idx : range(0, ParamsToPass.size())) {
+      bool Optional = false;
+      if (Info.ValueRef) {
+        if (const ParamDecl *DeclParam = getParameterAt(Info.ValueRef, Idx)) {
+          Optional |= DeclParam->isDefaultArgument();
+          Optional |= DeclParam->getType()->is<PackExpansionType>();
+        }
+      }
+      const AnyFunctionType::Param *TypeParam = &ParamsToPass[Idx];
+      Optional |= TypeParam->isVariadic();
+      DeclParamIsOptional.push_back(Optional);
+    }
+  }
+
   Results.push_back({ExpectedTy, ExpectedCallType,
-                     isa<SubscriptExpr>(ParentCall), Info.ValueRef, FuncTy,
+                     isa<SubscriptExpr>(ParentCall), Info.getValue(), FuncTy,
                      ArgIdx, ParamIdx, std::move(ClaimedParams),
                      IsNoninitialVariadic, Info.BaseTy, HasLabel, IsAsync,
-                     SolutionSpecificVarTypes});
+                     DeclParamIsOptional, SolutionSpecificVarTypes});
 }
 
 void ArgumentTypeCheckCompletionCallback::computeShadowedDecls(
@@ -254,25 +260,25 @@ void ArgumentTypeCheckCompletionCallback::computeShadowedDecls(
     auto &ResultA = Results[i];
     for (size_t j = i + 1; j < Results.size(); ++j) {
       auto &ResultB = Results[j];
-      if (!ResultA.getFuncD() || !ResultB.getFuncD() || !ResultA.FuncTy ||
+      if (!ResultA.FuncD || !ResultB.FuncD || !ResultA.FuncTy ||
           !ResultB.FuncTy) {
         continue;
       }
-      if (ResultA.getFuncD()->getName() != ResultB.getFuncD()->getName()) {
+      if (ResultA.FuncD->getName() != ResultB.FuncD->getName()) {
         continue;
       }
       if (!ResultA.FuncTy->isEqual(ResultB.FuncTy)) {
         continue;
       }
       ProtocolDecl *inProtocolExtensionA =
-          ResultA.getFuncD()->getDeclContext()->getExtendedProtocolDecl();
+          ResultA.FuncD->getDeclContext()->getExtendedProtocolDecl();
       ProtocolDecl *inProtocolExtensionB =
-          ResultB.getFuncD()->getDeclContext()->getExtendedProtocolDecl();
+          ResultB.FuncD->getDeclContext()->getExtendedProtocolDecl();
 
       if (inProtocolExtensionA && !inProtocolExtensionB) {
-        ShadowedDecls.insert(ResultA.getFuncD());
+        ShadowedDecls.insert(ResultA.FuncD);
       } else if (!inProtocolExtensionA && inProtocolExtensionB) {
-        ShadowedDecls.insert(ResultB.getFuncD());
+        ShadowedDecls.insert(ResultB.FuncD);
       }
     }
   }
@@ -313,37 +319,35 @@ void ArgumentTypeCheckCompletionCallback::deliverResults(
         }
         if ((BaseNominal = BaseTy->getAnyNominal())) {
           SemanticContext = SemanticContextKind::CurrentNominal;
-          if (Result.getFuncD() &&
-              Result.getFuncD()->getDeclContext()->getSelfNominalTypeDecl() !=
+          if (Result.FuncD &&
+              Result.FuncD->getDeclContext()->getSelfNominalTypeDecl() !=
                   BaseNominal) {
             SemanticContext = SemanticContextKind::Super;
           }
         } else if (BaseTy->is<TupleType>() || BaseTy->is<SubstitutableType>()) {
           SemanticContext = SemanticContextKind::CurrentNominal;
         }
       }
-      if (SemanticContext == SemanticContextKind::None && Result.getFuncD()) {
-        if (Result.getFuncD()->getDeclContext()->isTypeContext()) {
+      if (SemanticContext == SemanticContextKind::None && Result.FuncD) {
+        if (Result.FuncD->getDeclContext()->isTypeContext()) {
           SemanticContext = SemanticContextKind::CurrentNominal;
-        } else if (Result.getFuncD()->getDeclContext()->isLocalContext()) {
+        } else if (Result.FuncD->getDeclContext()->isLocalContext()) {
           SemanticContext = SemanticContextKind::Local;
-        } else if (Result.getFuncD()->getModuleContext() ==
-                   DC->getParentModule()) {
+        } else if (Result.FuncD->getModuleContext() == DC->getParentModule()) {
           SemanticContext = SemanticContextKind::CurrentModule;
         }
       }
       if (Result.FuncTy) {
         if (auto FuncTy = Result.FuncTy) {
-          if (ShadowedDecls.count(Result.getFuncD()) == 0) {
+          if (ShadowedDecls.count(Result.FuncD) == 0) {
             // Don't show call pattern completions if the function is
             // overridden.
             if (Result.IsSubscript) {
               assert(SemanticContext != SemanticContextKind::None);
-              auto *SD = dyn_cast_or_null<SubscriptDecl>(Result.getFuncD());
+              auto *SD = dyn_cast_or_null<SubscriptDecl>(Result.FuncD);
               Lookup.addSubscriptCallPattern(FuncTy, SD, SemanticContext);
             } else {
-              auto *FD =
-                  dyn_cast_or_null<AbstractFunctionDecl>(Result.getFuncD());
+              auto *FD = dyn_cast_or_null<AbstractFunctionDecl>(Result.FuncD);
               Lookup.addFunctionCallPattern(FuncTy, FD, SemanticContext);
             }
           }

lib/IRGen/GenDecl.cpp

@@ -511,7 +511,8 @@ void IRGenModule::emitSourceFile(SourceFile &SF) {
   // harmless aside from code size.
   if (!IRGen.Opts.UseJIT) {
     auto addBackDeployLib = [&](llvm::VersionTuple version,
-                                StringRef libraryName) {
+                                StringRef libraryName,
+                                bool forceLoad) {
       Optional<llvm::VersionTuple> compatibilityVersion;
       if (libraryName == "swiftCompatibilityDynamicReplacements") {
         compatibilityVersion = IRGen.Opts.
@@ -532,11 +533,11 @@ void IRGenModule::emitSourceFile(SourceFile &SF) {
 
       this->addLinkLibrary(LinkLibrary(libraryName,
                                        LibraryKind::Library,
-                                       /*forceLoad*/ true));
+                                       forceLoad));
     };
 
-    #define BACK_DEPLOYMENT_LIB(Version, Filter, LibraryName)         \
-      addBackDeployLib(llvm::VersionTuple Version, LibraryName);
+    #define BACK_DEPLOYMENT_LIB(Version, Filter, LibraryName, ForceLoad) \
+      addBackDeployLib(llvm::VersionTuple Version, LibraryName, ForceLoad);
     #include "swift/Frontend/BackDeploymentLibs.def"
   }
 }