Merge pull request #4914 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

CMakeLists.txt

@@ -877,8 +877,14 @@ endif()
 
 # When we have the early SwiftSyntax build, we can include its parser.
 if(SWIFT_PATH_TO_EARLYSWIFTSYNTAX_BUILD_DIR)
-  set(SWIFT_SWIFT_PARSER TRUE)
-  include(${SWIFT_PATH_TO_EARLYSWIFTSYNTAX_BUILD_DIR}/cmake/SwiftSyntaxTargets.cmake)
+  set(SWIFT_PATH_TO_EARLYSWIFTSYNTAX_TARGETS
+    ${SWIFT_PATH_TO_EARLYSWIFTSYNTAX_BUILD_DIR}/cmake/SwiftSyntaxTargets.cmake)
+  if(NOT EXISTS "${SWIFT_PATH_TO_EARLYSWIFTSYNTAX_TARGETS}")
+    message(STATUS "Skipping Swift Swift parser integration due to missing early SwiftSyntax")
+  else()
+    set(SWIFT_SWIFT_PARSER TRUE)
+    include(${SWIFT_PATH_TO_EARLYSWIFTSYNTAX_TARGETS})
+  endif()
 endif()
 
 

cmake/modules/AddSwiftUnittests.cmake

@@ -81,6 +81,7 @@ function(add_swift_unittest test_dirname)
 
   if (SWIFT_SWIFT_PARSER)
     _add_swift_runtime_link_flags(${test_dirname} "../../lib" "")
+    set_property(TARGET ${test_dirname} PROPERTY BUILD_WITH_INSTALL_RPATH OFF)
   endif()
 endfunction()
 

include/swift/AST/Decl.h

@@ -1049,6 +1049,12 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
 
   bool isAvailableAsSPI() const;
 
+  /// Whether the declaration is considered unavailable through either being
+  /// explicitly marked as such, or has a parent decl that is semantically
+  /// unavailable. This is a broader notion of unavailability than is checked by
+  /// \c AvailableAttr::isUnavailable.
+  bool isSemanticallyUnavailable() const;
+
   // List the SPI groups declared with @_spi or inherited by this decl.
   //
   // SPI groups are inherited from the parent contexts only if the local decl

include/swift/AST/DiagnosticsSema.def

@@ -3014,8 +3014,8 @@ NOTE(spi_only_import_conflict_here,none,
      "imported for SPI only here", ())
 
 ERROR(error_public_import_of_private_module,none,
-        "private module %0 is imported publicly from the public module %1",
-        (Identifier, Identifier))
+      "private module %0 is imported publicly from the public module %1",
+      (Identifier, Identifier))
 
 ERROR(implementation_only_decl_non_override,none,
       "'@_implementationOnly' can only be used on overrides", ())

include/swift/AST/TypeCheckRequests.h

@@ -3489,6 +3489,22 @@ class RenamedDeclRequest
   bool isCached() const { return true; }
 };
 
+class IsSemanticallyUnavailableRequest
+    : public SimpleRequest<IsSemanticallyUnavailableRequest,
+                           bool(const Decl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  bool evaluate(Evaluator &evaluator, const Decl *decl) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 class ClosureEffectsRequest
     : public SimpleRequest<ClosureEffectsRequest,
                            FunctionType::ExtInfo(ClosureExpr *),

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -395,6 +395,9 @@ SWIFT_REQUEST(TypeChecker, GetImplicitSendableRequest,
 SWIFT_REQUEST(TypeChecker, RenamedDeclRequest,
               ValueDecl *(const ValueDecl *, const AvailableAttr *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, IsSemanticallyUnavailableRequest,
+              bool(const Decl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ClosureEffectsRequest,
               FunctionType::ExtInfo(ClosureExpr *),
               Cached, NoLocationInfo)

include/swift/Basic/Features.def

@@ -134,6 +134,10 @@ EXPERIMENTAL_FEATURE(ParserRoundTrip)
 /// Swift parser.
 EXPERIMENTAL_FEATURE(ParserValidation)
 
+/// Whether to fold sequence expressions in the syntax tree produced by the
+/// Swift Swift parser.
+EXPERIMENTAL_FEATURE(ParserSequenceFolding)
+
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE
 #undef SUPPRESSIBLE_LANGUAGE_FEATURE

include/swift/SIL/SILDeclRef.h

@@ -300,6 +300,11 @@ struct SILDeclRef {
   /// Retrieves the ASTContext from the underlying AST node being stored.
   ASTContext &getASTContext() const;
 
+  /// Retrieve the innermost declaration context corresponding to the underlying
+  /// node, which will either be the node itself (if it's also a declaration
+  /// context) or its parent context.
+  DeclContext *getInnermostDeclContext() const;
+
   llvm::Optional<AnyFunctionRef> getAnyFunctionRef() const;
 
   SILLocation getAsRegularLocation() const;

include/swift/SIL/SILProfiler.h

@@ -32,7 +32,7 @@ class SILFunction;
 class SILModule;
 
 /// Returns whether the given AST node requires profiling instrumentation.
-bool doesASTRequireProfiling(SILModule &M, ASTNode N);
+bool doesASTRequireProfiling(SILModule &M, ASTNode N, SILDeclRef Constant);
 
 /// SILProfiler - Maps AST nodes to profile counters.
 class SILProfiler : public SILAllocated<SILProfiler> {

include/swift/Sema/CompletionContextFinder.h

@@ -91,6 +91,10 @@ class CompletionContextFinder : public ASTWalker {
     return CompletionNode.dyn_cast<const KeyPathExpr *>() != nullptr;
   }
 
+  bool hasCompletion() const {
+    return !CompletionNode.isNull();
+  }
+
   /// If we are completing in a key path, returns the \c KeyPath that contains
   /// the code completion component.
   const KeyPathExpr *getKeyPathContainingCompletionComponent() const {

lib/AST/ASTPrinter.cpp

@@ -2945,6 +2945,10 @@ static bool usesFeatureParserValidation(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureParserSequenceFolding(Decl *decl) {
+  return false;
+}
+
 static void suppressingFeatureSpecializeAttributeWithAvailability(
                                         PrintOptions &options,
                                         llvm::function_ref<void()> action) {

lib/AST/Availability.cpp

@@ -20,6 +20,7 @@
 #include "swift/AST/Types.h"
 #include "swift/AST/Availability.h"
 #include "swift/AST/PlatformKind.h"
+#include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/TypeWalker.h"
 #include <map>
 
@@ -194,6 +195,41 @@ bool Decl::isAvailableAsSPI() const {
     .isAvailableAsSPI();
 }
 
+bool IsSemanticallyUnavailableRequest::evaluate(Evaluator &evaluator,
+                                                const Decl *decl) const {
+  // Directly marked unavailable.
+  if (AvailableAttr::isUnavailable(decl))
+    return true;
+
+  // If this is an extension, it's semantically unavailable if its nominal is,
+  // as there is no way to reference or construct the type.
+  if (auto *ext = dyn_cast<ExtensionDecl>(decl)) {
+    if (auto *nom = ext->getExtendedNominal()) {
+      if (nom->isSemanticallyUnavailable())
+        return true;
+    }
+  }
+
+  // If the parent decl is semantically unavailable, then this decl is too.
+  // For local contexts, this means it's a local decl in e.g an unavailable
+  // function, which cannot be accessed. For non-local contexts, this is a
+  // nested type or a member with an unavailable parent, which cannot be
+  // referenced.
+  // Similar to `AvailableAttr::isUnavailable`, don't apply this logic to
+  // Clang decls, as they may be inaccurately parented.
+  if (!decl->hasClangNode()) {
+    auto *DC = decl->getDeclContext();
+    if (auto *parentDecl = DC->getInnermostDeclarationDeclContext())
+      return parentDecl->isSemanticallyUnavailable();
+  }
+  return false;
+}
+
+bool Decl::isSemanticallyUnavailable() const {
+  auto &eval = getASTContext().evaluator;
+  return evaluateOrDefault(eval, IsSemanticallyUnavailableRequest{this}, false);
+}
+
 AvailabilityContext
 AvailabilityInference::annotatedAvailableRangeForAttr(const SpecializeAttr* attr,
                                                       ASTContext &ctx) {

lib/Parse/CMakeLists.txt

@@ -44,18 +44,20 @@ if (SWIFT_SWIFT_PARSER)
   #
   #   target_link_libraries(swiftParse
   #     PRIVATE
-  #     SwiftSyntax::SwiftParser
+  #     SwiftSyntax::SwiftCompilerSupport
   #   )
   target_link_libraries(swiftParse
     PRIVATE
     $<TARGET_OBJECTS:SwiftSyntax::SwiftParser>
     $<TARGET_OBJECTS:SwiftSyntax::SwiftDiagnostics>
     $<TARGET_OBJECTS:SwiftSyntax::SwiftSyntax>
+    $<TARGET_OBJECTS:SwiftSyntax::SwiftOperators>
+    $<TARGET_OBJECTS:SwiftSyntax::SwiftCompilerSupport>
   )
 
   target_include_directories(swiftParse
     PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../../swift-syntax/Sources/SwiftParser
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../../swift-syntax/Sources/SwiftCompilerSupport
   )
 
   target_compile_definitions(swiftParse

lib/Parse/ParseRequests.cpp

@@ -27,7 +27,7 @@
 #include "swift/SyntaxParse/SyntaxTreeCreator.h"
 
 #ifdef SWIFT_SWIFT_PARSER
-#include "SwiftParserCompilerSupport.h"
+#include "SwiftCompilerSupport.h"
 #endif
 
 using namespace swift;
@@ -202,11 +202,14 @@ SourceFileParsingResult ParseSourceFileRequest::evaluate(Evaluator &evaluator,
     unsigned int flags = 0;
 
     if (ctx.LangOpts.hasFeature(Feature::ParserRoundTrip))
-      flags |= SPCC_RoundTrip;
+      flags |= SCC_RoundTrip;
 
     if (!ctx.Diags.hadAnyError() &&
         ctx.LangOpts.hasFeature(Feature::ParserValidation))
-      flags |= SPCC_ParseDiagnostics;
+      flags |= SCC_ParseDiagnostics;
+
+    if (ctx.LangOpts.hasFeature(Feature::ParserSequenceFolding))
+      flags |= SCC_FoldSequences;
 
     int roundTripResult =
       swift_parser_consistencyCheck(

lib/SIL/IR/SILDeclRef.cpp

@@ -195,18 +195,26 @@ Optional<AnyFunctionRef> SILDeclRef::getAnyFunctionRef() const {
   llvm_unreachable("Unhandled case in switch");
 }
 
-ASTContext &SILDeclRef::getASTContext() const {
+DeclContext *SILDeclRef::getInnermostDeclContext() const {
+  if (!loc)
+    return nullptr;
   switch (getLocKind()) {
   case LocKind::Decl:
-    return getDecl()->getASTContext();
+    return getDecl()->getInnermostDeclContext();
   case LocKind::Closure:
-    return getAbstractClosureExpr()->getASTContext();
+    return getAbstractClosureExpr();
   case LocKind::File:
-    return getFileUnit()->getASTContext();
+    return getFileUnit();
   }
   llvm_unreachable("Unhandled case in switch");
 }
 
+ASTContext &SILDeclRef::getASTContext() const {
+  auto *DC = getInnermostDeclContext();
+  assert(DC && "Must have a decl context");
+  return DC->getASTContext();
+}
+
 Optional<AvailabilityContext> SILDeclRef::getAvailabilityForLinkage() const {
   // Back deployment thunks and fallbacks don't have availability since they
   // are non-ABI.

lib/SIL/IR/SILProfiler.cpp

@@ -42,13 +42,30 @@ static bool doesClosureHaveBody(AbstractClosureExpr *ACE) {
 }
 
 /// Check whether a root AST node should be profiled.
-static bool shouldProfile(ASTNode N) {
+static bool shouldProfile(ASTNode N, SILDeclRef Constant) {
   // Do not profile AST nodes with invalid source locations.
   if (N.getStartLoc().isInvalid() || N.getEndLoc().isInvalid()) {
     LLVM_DEBUG(llvm::dbgs()
                << "Skipping ASTNode: invalid start/end locations\n");
     return false;
   }
+  if (!Constant) {
+    // We should only ever have a null SILDeclRef for top-level code, which is
+    // always user-written, and should always be profiled.
+    // FIXME: Once top-level code is unified under a single SILProfiler, this
+    // case can be eliminated.
+    assert(isa<TopLevelCodeDecl>(N.get<Decl *>()));
+    return true;
+  }
+
+  // Do not profile AST nodes in unavailable contexts.
+  auto *DC = Constant.getInnermostDeclContext();
+  if (auto *D = DC->getInnermostDeclarationDeclContext()) {
+    if (D->isSemanticallyUnavailable()) {
+      LLVM_DEBUG(llvm::dbgs() << "Skipping ASTNode: unavailable context\n");
+      return false;
+    }
+  }
 
   if (auto *E = N.dyn_cast<Expr *>()) {
     if (auto *CE = dyn_cast<AbstractClosureExpr>(E)) {
@@ -96,13 +113,13 @@ static bool shouldProfile(ASTNode N) {
 }
 
 namespace swift {
-bool doesASTRequireProfiling(SILModule &M, ASTNode N) {
+bool doesASTRequireProfiling(SILModule &M, ASTNode N, SILDeclRef Constant) {
   // If profiling isn't enabled, don't profile anything.
   auto &Opts = M.getOptions();
   if (Opts.UseProfile.empty() && !Opts.GenerateProfile)
     return false;
 
-  return shouldProfile(N);
+  return shouldProfile(N, Constant);
 }
 } // namespace swift
 
@@ -157,7 +174,7 @@ static bool canCreateProfilerForAST(ASTNode N, SILDeclRef forDecl) {
 
 SILProfiler *SILProfiler::create(SILModule &M, ASTNode N, SILDeclRef Ref) {
   const auto &Opts = M.getOptions();
-  if (!doesASTRequireProfiling(M, N))
+  if (!doesASTRequireProfiling(M, N, Ref))
     return nullptr;
 
   if (!canCreateProfilerForAST(N, Ref)) {

lib/SILGen/SILGen.cpp

@@ -1436,7 +1436,7 @@ void SILGenModule::emitFunction(FuncDecl *fd) {
 
   if (fd->hasBody()) {
     SILDeclRef constant(decl);
-    bool ForCoverageMapping = doesASTRequireProfiling(M, fd);
+    bool ForCoverageMapping = doesASTRequireProfiling(M, fd, constant);
     emitOrDelayFunction(*this, constant,
                         /*forceEmission=*/ForCoverageMapping);
   }

lib/Sema/BuilderTransform.cpp

@@ -2361,9 +2361,11 @@ Optional<BraceStmt *> TypeChecker::applyResultBuilderBodyTransform(
     cs.solveForCodeCompletion(solutions);
 
     CompletionContextFinder analyzer(func, func->getDeclContext());
-    filterSolutionsForCodeCompletion(solutions, analyzer);
-    for (const auto &solution : solutions) {
-      cs.getASTContext().CompletionCallback->sawSolution(solution);
+    if (analyzer.hasCompletion()) {
+      filterSolutionsForCodeCompletion(solutions, analyzer);
+      for (const auto &solution : solutions) {
+        cs.getASTContext().CompletionCallback->sawSolution(solution);
+      }
     }
     return nullptr;
   }

lib/Sema/CompletionContextFinder.cpp

@@ -71,7 +71,6 @@ CompletionContextFinder::walkToExprPost(Expr *E) {
 }
 
 size_t CompletionContextFinder::getKeyPathCompletionComponentIndex() const {
-  assert(hasCompletionKeyPathComponent());
   size_t ComponentIndex = 0;
   auto Components = getKeyPathContainingCompletionComponent()->getComponents();
   for (auto &Component : Components) {

lib/Sema/TypeCheckCodeCompletion.cpp

@@ -518,7 +518,6 @@ static bool hasTypeForCompletion(Solution &solution,
   if (contextAnalyzer.hasCompletionExpr()) {
     return solution.hasType(contextAnalyzer.getCompletionExpr());
   } else {
-    assert(contextAnalyzer.hasCompletionKeyPathComponent());
     return solution.hasType(
         contextAnalyzer.getKeyPathContainingCompletionComponent(),
         contextAnalyzer.getKeyPathCompletionComponentIndex());
@@ -578,8 +577,7 @@ bool TypeChecker::typeCheckForCodeCompletion(
 
   // If there was no completion expr (e.g. if the code completion location was
   // among tokens that were skipped over during parser error recovery) bail.
-  if (!contextAnalyzer.hasCompletionExpr() &&
-      !contextAnalyzer.hasCompletionKeyPathComponent())
+  if (!contextAnalyzer.hasCompletion())
     return false;
 
   // Interpolation components are type-checked separately.

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1900,8 +1900,10 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 #endif
 
         bool isImportOfUnderlying = importer->getName() == target->getName();
+        auto *SF = ID->getDeclContext()->getParentSourceFile();
         bool treatAsError = enableTreatAsError &&
-                            !isImportOfUnderlying;
+                            !isImportOfUnderlying &&
+                            SF->Kind != SourceFileKind::Interface;
         if (!treatAsError)
           inFlight.limitBehavior(DiagnosticBehavior::Warning);
       }

test/CMakeLists.txt

@@ -43,6 +43,10 @@ function(get_test_dependencies SDK result_var_name)
     list(APPEND deps SwiftUnitTests)
   endif()
 
+  if(SWIFT_BUILD_SDK_OVERLAY OR SWIFT_BUILD_TEST_SUPPORT_MODULES)
+    list(APPEND deps sdk-overlay)
+  endif()
+
   set(deps_binaries)
 
   if (SWIFT_INCLUDE_TOOLS)