Merge pull request #3931 from swiftwasm/maxd/main-merge

Resolve conflicts with upstream `main`

Author: MaxDesiatov

benchmark/cmake/modules/AddSwiftBenchmarkSuite.cmake

@@ -708,7 +708,10 @@ function(swift_benchmark_compile)
   cmake_parse_arguments(SWIFT_BENCHMARK_COMPILE "" "PLATFORM" "" ${ARGN})
 
   if(NOT SWIFT_BENCHMARK_BUILT_STANDALONE)
-    set(stdlib_dependencies "swift-frontend")
+    set(stdlib_dependencies "swift-frontend" "swiftCore-${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}")
+    if(${SWIFT_HOST_VARIANT_SDK} IN_LIST SWIFT_DARWIN_PLATFORMS)
+      list(APPEND stdlib_dependencies "swiftDarwin-${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}")
+    endif()
     foreach(stdlib_dependency ${UNIVERSAL_LIBRARY_NAMES_${SWIFT_BENCHMARK_COMPILE_PLATFORM}})
       string(FIND "${stdlib_dependency}" "Unittest" find_output)
       if("${find_output}" STREQUAL "-1")

cmake/modules/AddSwift.cmake

@@ -802,16 +802,6 @@ macro(add_swift_lib_subdirectory name)
   add_llvm_subdirectory(SWIFT LIB ${name})
 endmacro()
 
-function(_link_built_compatibility_libs executable)
-  set(platform ${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR})
-  target_link_directories(${executable} PRIVATE
-    ${SWIFTLIB_DIR}/${platform})
-  add_dependencies(${executable}
-    "swiftCompatibility50-${platform}"
-    "swiftCompatibility51-${platform}"
-    "swiftCompatibilityDynamicReplacements-${platform}")
-endfunction()
-
 function(add_swift_host_tool executable)
   set(options HAS_LIBSWIFT)
   set(single_parameter_options SWIFT_COMPONENT BOOTSTRAPPING)
@@ -910,24 +900,26 @@ function(add_swift_host_tool executable)
         list(APPEND RPATH_LIST "/usr/lib/swift")
 
       elseif(LIBSWIFT_BUILD_MODE STREQUAL "BOOTSTRAPPING-WITH-HOSTLIBS")
-        # Pick up the built libswiftCompatibility<n>.a libraries
-        _link_built_compatibility_libs(${executable})
-
         # Add the SDK directory for the host platform.
         target_link_directories(${executable} PRIVATE "${sdk_dir}")
 
+        # A backup in case the toolchain doesn't have one of the compatibility libraries.
+        target_link_directories(${executable} PRIVATE
+          "${SWIFTLIB_DIR}/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}")
+
         # Include the abi stable system stdlib in our rpath.
         list(APPEND RPATH_LIST "/usr/lib/swift")
 
       elseif(LIBSWIFT_BUILD_MODE STREQUAL "BOOTSTRAPPING")
-        # Pick up the built libswiftCompatibility<n>.a libraries
-        _link_built_compatibility_libs(${executable})
-
         # At build time link against the built swift libraries from the
         # previous bootstrapping stage.
         get_bootstrapping_swift_lib_dir(bs_lib_dir "${ASHT_BOOTSTRAPPING}")
         target_link_directories(${executable} PRIVATE ${bs_lib_dir})
 
+        # Required to pick up the built libswiftCompatibility<n>.a libraries
+        target_link_directories(${executable} PRIVATE
+          "${SWIFTLIB_DIR}/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}")
+
         # At runtime link against the built swift libraries from the current
         # bootstrapping stage.
         list(APPEND RPATH_LIST "@executable_path/../lib/swift/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}")

cmake/modules/StandaloneOverlay.cmake

@@ -85,6 +85,9 @@ set(SWIFT_DARWIN_MODULE_ARCHS "" CACHE STRING
 targets on Darwin platforms. These targets are in addition to the full \
 library targets.")
 
+option(SWIFT_STDLIB_SHORT_MANGLING_LOOKUPS
+       "Build stdlib with fast-path context descriptor lookups based on well-known short manglings."
+       TRUE)
 
 # -----------------------------------------------------------------------------
 # Constants

include/swift/AST/Decl.h

@@ -207,6 +207,9 @@ enum class AssociatedValueCheck {
 /// Diagnostic printing of \c StaticSpellingKind.
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, StaticSpellingKind SSK);
 
+/// Diagnostic printing of \c ReferenceOwnership.
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, ReferenceOwnership RO);
+
 /// Encapsulation of the overload signature of a given declaration,
 /// which is used to determine uniqueness of a declaration within a
 /// given context.

include/swift/AST/DiagnosticsSema.def

@@ -398,22 +398,12 @@ NOTE(generic_parameter_inferred_from_result_context,none,
 ERROR(cannot_pass_type_to_non_ephemeral,none,
       "cannot pass %0 to parameter; argument %1 must be a pointer that "
       "outlives the call%select{| to %3}2", (Type, StringRef, bool, DeclName))
-WARNING(cannot_pass_type_to_non_ephemeral_warning,none,
-        "passing %0 to parameter, but argument %1 should be a pointer that "
-        "outlives the call%select{| to %3}2", (Type, StringRef, bool, DeclName))
 ERROR(cannot_use_inout_non_ephemeral,none,
       "cannot use inout expression here; argument %0 must be a pointer that "
       "outlives the call%select{| to %2}1", (StringRef, bool, DeclName))
-WARNING(cannot_use_inout_non_ephemeral_warning,none,
-        "inout expression creates a temporary pointer, but argument %0 should "
-        "be a pointer that outlives the call%select{| to %2}1",
-        (StringRef, bool, DeclName))
 ERROR(cannot_construct_dangling_pointer,none,
       "initialization of %0 results in a dangling %select{|buffer }1pointer",
       (Type, unsigned))
-WARNING(cannot_construct_dangling_pointer_warning,none,
-        "initialization of %0 results in a dangling %select{|buffer }1pointer",
-        (Type, unsigned))
 NOTE(ephemeral_pointer_argument_conversion_note,none,
      "implicit argument conversion from %0 to %1 produces a pointer valid only "
      "for the duration of the call%select{| to %3}2",
@@ -1881,9 +1871,6 @@ WARNING(spi_attribute_on_import_of_public_module,none,
         (DeclName, StringRef))
 
 // Opaque return types
-ERROR(structural_opaque_types_are_experimental,none,
-      "'opaque' types cannot be nested inside other types; "
-      "structural 'opaque' types are an experimental feature", ())
 ERROR(opaque_type_invalid_constraint,none,
       "an 'opaque' type must specify only 'Any', 'AnyObject', protocols, "
       "and/or a base class", ())
@@ -4878,6 +4865,10 @@ ERROR(opaque_type_unsupported_pattern,none,
 ERROR(opaque_type_in_protocol_requirement,none,
       "'some' type cannot be the return type of a protocol requirement; did you mean to add an associated type?",
       ())
+ERROR(opaque_type_in_parameter,none,
+      "'some' cannot appear in parameter position in result "
+      "type %0",
+      (Type))
 
 // Function differentiability
 ERROR(attr_only_on_parameters_of_differentiable,none,

include/swift/AST/EducationalNotes.def

@@ -25,17 +25,9 @@ EDUCATIONAL_NOTES(could_not_use_member_on_existential,
                   "existential-member-access-limitations.md")
 
 EDUCATIONAL_NOTES(cannot_pass_type_to_non_ephemeral, "temporary-pointers.md")
-EDUCATIONAL_NOTES(cannot_pass_type_to_non_ephemeral_warning,
-                  "temporary-pointers.md")
 EDUCATIONAL_NOTES(cannot_use_inout_non_ephemeral,
                   "temporary-pointers.md")
-EDUCATIONAL_NOTES(cannot_use_inout_non_ephemeral_warning,
-                  "temporary-pointers.md")
 EDUCATIONAL_NOTES(cannot_construct_dangling_pointer, "temporary-pointers.md")
-EDUCATIONAL_NOTES(cannot_construct_dangling_pointer_warning,
-                  "temporary-pointers.md")
-
-
 
 EDUCATIONAL_NOTES(non_nominal_no_initializers, "nominal-types.md")
 EDUCATIONAL_NOTES(non_nominal_extension, "nominal-types.md")

include/swift/AST/LayoutConstraintKind.h

@@ -14,7 +14,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Support/DataTypes.h"
+#include <cstdint>
 
 #ifndef SWIFT_LAYOUT_CONSTRAINTKIND_H
 #define SWIFT_LAYOUT_CONSTRAINTKIND_H

include/swift/AST/Ownership.h

@@ -23,7 +23,6 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/raw_ostream.h"
 #include <assert.h>
 #include <limits.h>
 #include <stdint.h>
@@ -118,9 +117,6 @@ optionalityOf(ReferenceOwnership ownership) {
   llvm_unreachable("impossible");
 }
 
-/// Diagnostic printing of \c StaticSpellingKind.
-llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, ReferenceOwnership RO);
-
 /// Different kinds of value ownership supported by Swift.
 enum class ValueOwnership : uint8_t {
   /// the context-dependent default ownership (sometimes shared,

include/swift/Basic/LangOptions.h

@@ -310,10 +310,6 @@ namespace swift {
     /// `func f() -> <T> T`.
     bool EnableExperimentalNamedOpaqueTypes = false;
 
-    /// Enable experimental support for structural opaque result types, e.g.
-    /// `func f() -> (some P)?`.
-    bool EnableExperimentalStructuralOpaqueTypes = false;
-
     /// Enable experimental flow-sensitive concurrent captures.
     bool EnableExperimentalFlowSensitiveConcurrentCaptures = false;
 

include/swift/SIL/DebugUtils.h

@@ -327,6 +327,34 @@ struct DebugVarCarryingInst {
   }
 };
 
+/// Attempt to discover a StringRef varName for the value \p value. If we fail,
+/// we return the name "unknown".
+inline StringRef getDebugVarName(SILValue value) {
+  if (auto *asi = dyn_cast<AllocStackInst>(value)) {
+    DebugVarCarryingInst debugVar(asi);
+    if (auto varInfo = debugVar.getVarInfo()) {
+      return varInfo->Name;
+    } else {
+      if (auto *decl = debugVar.getDecl()) {
+        return decl->getBaseName().userFacingName();
+      }
+    }
+  }
+
+  StringRef varName = "unknown";
+  if (auto *use = getSingleDebugUse(value)) {
+    DebugVarCarryingInst debugVar(use->getUser());
+    if (auto varInfo = debugVar.getVarInfo()) {
+      varName = varInfo->Name;
+    } else {
+      if (auto *decl = debugVar.getDecl()) {
+        varName = decl->getBaseName().userFacingName();
+      }
+    }
+  }
+  return varName;
+}
+
 } // end namespace swift
 
 #endif // SWIFT_SIL_DEBUGUTILS_H

include/swift/Sema/CSFix.h

@@ -650,9 +650,9 @@ class ContextualMismatch : public ConstraintFix {
   Type LHS, RHS;
 
   ContextualMismatch(ConstraintSystem &cs, Type lhs, Type rhs,
-                     ConstraintLocator *locator)
-      : ConstraintFix(cs, FixKind::ContextualMismatch, locator), LHS(lhs),
-        RHS(rhs) {}
+                     ConstraintLocator *locator, bool warning)
+      : ConstraintFix(cs, FixKind::ContextualMismatch, locator, warning),
+        LHS(lhs), RHS(rhs) {}
 
 protected:
   ContextualMismatch(ConstraintSystem &cs, FixKind kind, Type lhs, Type rhs,
@@ -741,9 +741,9 @@ class MarkExplicitlyEscaping final : public ContextualMismatch {
 /// Mark function type as being part of a global actor.
 class MarkGlobalActorFunction final : public ContextualMismatch {
   MarkGlobalActorFunction(ConstraintSystem &cs, Type lhs, Type rhs,
-                         ConstraintLocator *locator)
+                         ConstraintLocator *locator, bool warning)
       : ContextualMismatch(cs, FixKind::MarkGlobalActorFunction, lhs, rhs,
-                           locator) {
+                           locator, warning) {
   }
 
 public:
@@ -752,7 +752,8 @@ class MarkGlobalActorFunction final : public ContextualMismatch {
   bool diagnose(const Solution &solution, bool asNote = false) const override;
 
   static MarkGlobalActorFunction *create(ConstraintSystem &cs, Type lhs,
-                                         Type rhs, ConstraintLocator *locator);
+                                         Type rhs, ConstraintLocator *locator,
+                                         bool warning);
 
   static bool classof(ConstraintFix *fix) {
     return fix->getKind() == FixKind::MarkGlobalActorFunction;
@@ -787,9 +788,10 @@ class ForceOptional final : public ContextualMismatch {
 /// function types, repair it by adding @Sendable attribute.
 class AddSendableAttribute final : public ContextualMismatch {
   AddSendableAttribute(ConstraintSystem &cs, FunctionType *fromType,
-                       FunctionType *toType, ConstraintLocator *locator)
+                       FunctionType *toType, ConstraintLocator *locator,
+                       bool warning)
       : ContextualMismatch(cs, FixKind::AddSendableAttribute, fromType, toType,
-                           locator) {
+                           locator, warning) {
     assert(fromType->isSendable() != toType->isSendable());
   }
 
@@ -801,7 +803,8 @@ class AddSendableAttribute final : public ContextualMismatch {
   static AddSendableAttribute *create(ConstraintSystem &cs,
                                       FunctionType *fromType,
                                       FunctionType *toType,
-                                      ConstraintLocator *locator);
+                                      ConstraintLocator *locator,
+                                      bool warning);
 
   static bool classof(ConstraintFix *fix) {
     return fix->getKind() == FixKind::AddSendableAttribute;

lib/AST/ModuleDependencies.cpp

@@ -100,7 +100,9 @@ void ModuleDependencies::addModuleDependencies(
     if (!importDecl)
       continue;
 
-    addModuleDependency(importDecl->getModulePath(), &alreadyAddedModules);
+    ImportPath::Builder scratch;
+    auto realPath = importDecl->getRealModulePath(scratch);
+    addModuleDependency(realPath, &alreadyAddedModules);
   }
 
   auto fileName = sf.getFilename();

lib/Frontend/CompilerInvocation.cpp

@@ -438,9 +438,6 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   Opts.EnableExperimentalNamedOpaqueTypes |=
       Args.hasArg(OPT_enable_experimental_named_opaque_types);
 
-  Opts.EnableExperimentalStructuralOpaqueTypes |=
-      Args.hasArg(OPT_enable_experimental_structural_opaque_types);
-
   Opts.EnableExperimentalDistributed |=
     Args.hasArg(OPT_enable_experimental_distributed);
 

lib/Frontend/ModuleInterfaceLoader.cpp

@@ -1685,6 +1685,7 @@ InterfaceSubContextDelegateImpl::runInSubCompilerInstance(StringRef moduleName,
   if (subInstance.setup(subInvocation)) {
     return std::make_error_code(std::errc::not_supported);
   }
+
   info.BuildArguments = BuildArgs;
   info.Hash = CacheHash;
   auto target = *(std::find(BuildArgs.rbegin(), BuildArgs.rend(), "-target") - 1);
@@ -1826,7 +1827,12 @@ std::error_code ExplicitSwiftModuleLoader::findModuleFilesInDirectory(
 
 bool ExplicitSwiftModuleLoader::canImportModule(
     ImportPath::Element mID, llvm::VersionTuple version, bool underlyingVersion) {
-  StringRef moduleName = mID.Item.str();
+  // Look up the module with the real name (physical name on disk);
+  // in case `-module-alias` is used, the name appearing in source files
+  // and the real module name are different. For example, '-module-alias Foo=Bar'
+  // maps Foo appearing in source files, e.g. 'import Foo', to the real module
+  // name Bar (on-disk name), which should be searched for loading.
+  StringRef moduleName = Ctx.getRealModuleName(mID.Item).str();
   auto it = Impl.ExplicitModuleMap.find(moduleName);
   // If no provided explicit module matches the name, then it cannot be imported.
   if (it == Impl.ExplicitModuleMap.end()) {

lib/SILGen/SILGenPattern.cpp

@@ -3007,6 +3007,10 @@ void SILGenFunction::emitCatchDispatch(DoCatchStmt *S, ManagedValue exn,
     // If we don't have a multi-pattern 'catch', we can emit the
     // body inline. Emit the statement here and bail early.
     if (clause->getCaseLabelItems().size() == 1) {
+      // Debug values for catch clause variables must be nested within a scope for
+      // the catch block to avoid name conflicts.
+      DebugScope scope(*this, CleanupLocation(clause));
+
       // If we have case body vars, set them up to point at the matching var
       // decls.
       if (clause->hasCaseBodyVariables()) {
@@ -3027,6 +3031,11 @@ void SILGenFunction::emitCatchDispatch(DoCatchStmt *S, ManagedValue exn,
             // Ok, we found a match. Update the VarLocs for the case block.
             auto v = VarLocs[vd];
             VarLocs[expected] = v;
+
+            // Emit a debug description of the incoming arg, nested within the scope
+            // for the pattern match.
+            SILDebugVariable dbgVar(vd->isLet(), /*ArgNo=*/0);
+            B.emitDebugDescription(vd, v.value, dbgVar);
           }
         }
       }

lib/Sema/CSDiagnostics.cpp

@@ -102,7 +102,10 @@ template <typename... ArgTypes>
 InFlightDiagnostic
 FailureDiagnostic::emitDiagnosticAt(ArgTypes &&... Args) const {
   auto &DE = getASTContext().Diags;
-  return DE.diagnose(std::forward<ArgTypes>(Args)...);
+  auto behavior = isWarning ? DiagnosticBehavior::Warning
+                            : DiagnosticBehavior::Unspecified;
+  return std::move(DE.diagnose(std::forward<ArgTypes>(Args)...)
+                     .limitBehavior(behavior));
 }
 
 Expr *FailureDiagnostic::findParentExpr(const Expr *subExpr) const {
@@ -6779,12 +6782,9 @@ bool NonEphemeralConversionFailure::diagnosePointerInit() const {
     return false;
   }
 
-  auto diagID = DowngradeToWarning
-                    ? diag::cannot_construct_dangling_pointer_warning
-                    : diag::cannot_construct_dangling_pointer;
-
   auto anchor = getRawAnchor();
-  emitDiagnosticAt(::getLoc(anchor), diagID, constructedTy, constructorKind)
+  emitDiagnosticAt(::getLoc(anchor), diag::cannot_construct_dangling_pointer,
+                   constructedTy, constructorKind)
       .highlight(::getSourceRange(anchor));
 
   emitSuggestionNotes();
@@ -6814,20 +6814,12 @@ bool NonEphemeralConversionFailure::diagnoseAsError() {
 
   auto *argExpr = getArgExpr();
   if (isa<InOutExpr>(argExpr)) {
-    auto diagID = DowngradeToWarning
-                      ? diag::cannot_use_inout_non_ephemeral_warning
-                      : diag::cannot_use_inout_non_ephemeral;
-
-    emitDiagnosticAt(argExpr->getLoc(), diagID, argDesc, getCallee(),
-                     getCalleeFullName())
+    emitDiagnosticAt(argExpr->getLoc(), diag::cannot_use_inout_non_ephemeral,
+                     argDesc, getCallee(), getCalleeFullName())
         .highlight(argExpr->getSourceRange());
   } else {
-    auto diagID = DowngradeToWarning
-                      ? diag::cannot_pass_type_to_non_ephemeral_warning
-                      : diag::cannot_pass_type_to_non_ephemeral;
-
-    emitDiagnosticAt(argExpr->getLoc(), diagID, getArgType(), argDesc,
-                     getCallee(), getCalleeFullName())
+    emitDiagnosticAt(argExpr->getLoc(), diag::cannot_pass_type_to_non_ephemeral,
+                     getArgType(), argDesc, getCallee(), getCalleeFullName())
         .highlight(argExpr->getSourceRange());
   }
   emitSuggestionNotes();