Merge pull request #2922 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

include/swift/Basic/Features.def

@@ -43,5 +43,6 @@ LANGUAGE_FEATURE(RethrowsProtocol, 0, "@rethrows protocol", true)
 LANGUAGE_FEATURE(GlobalActors, 0, "Global actors", langOpts.EnableExperimentalConcurrency)
 LANGUAGE_FEATURE(BuiltinJob, 0, "Builtin.Job type", true)
 LANGUAGE_FEATURE(Sendable, 0, "Sendable and @Sendable", true)
+LANGUAGE_FEATURE(BuiltinContinuation, 0, "Continuation builtins", true)
 
 #undef LANGUAGE_FEATURE

include/swift/IDE/SourceEntityWalker.h

@@ -41,6 +41,16 @@ namespace swift {
 /// An abstract class used to traverse the AST and provide source information.
 /// Visitation happens in source-order and compiler-generated semantic info,
 /// like implicit declarations, is ignored.
+///
+/// If \c walkTo*Pre returns \c true, the children are visited and \c
+/// walkTo*Post is called after all children have been visited.
+/// If \c walkTo*Pre returns \c false, the corresponding \c walkTo*Post call
+/// will not be issued.
+///
+/// If \c walkTo*Post returns \c false, the traversal is terminated. No more
+/// \c walk* calls are issued. Nodes that have already received a \c walkTo*Pre
+/// call will *not* receive a \c walkTo*Post call.
+/// If \c walkTo*Post returns \c true, the traversal continues.
 class SourceEntityWalker {
 public:
   /// Walks the provided source file.

lib/AST/ASTPrinter.cpp

@@ -2720,6 +2720,10 @@ static bool usesFeatureBuiltinJob(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureBuiltinContinuation(Decl *decl) {
+  return false;
+}
+
 /// Determine the set of "new" features used on a given declaration.
 ///
 /// Note: right now, all features we check for are "new". At some point, we'll

lib/AST/InlinableText.cpp

@@ -11,8 +11,9 @@
 //===----------------------------------------------------------------------===//
 #include "InlinableText.h"
 #include "swift/AST/ASTContext.h"
-#include "swift/AST/ASTWalker.h"
 #include "swift/AST/ASTNode.h"
+#include "swift/AST/ASTVisitor.h"
+#include "swift/AST/ASTWalker.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Expr.h"
 #include "swift/Parse/Lexer.h"
@@ -43,6 +44,40 @@ getEffectiveEndLoc(SourceManager &sourceMgr, const IfConfigClause *clause,
 }
 
 namespace {
+
+class IsFeatureCheck : public ASTWalker {
+public:
+  bool foundFeature = false;
+
+  std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
+    if (auto unresolved = dyn_cast<UnresolvedDeclRefExpr>(expr)) {
+      if (unresolved->getName().getBaseName().userFacingName().startswith("$"))
+        foundFeature = true;
+    }
+
+    return { !foundFeature, expr };
+  }
+};
+
+bool clauseIsFeatureCheck(Expr *cond) {
+  IsFeatureCheck checker;
+  cond->walk(checker);
+  return checker.foundFeature;
+}
+
+/// Whether any of the clauses here involves a feature check
+/// (e.g., $AsyncAwait).
+bool anyClauseIsFeatureCheck(ArrayRef<IfConfigClause> clauses) {
+  for (const auto &clause : clauses) {
+    if (Expr *cond = clause.Cond) {
+      if (clauseIsFeatureCheck(cond))
+        return true;
+    }
+  }
+
+  return false;
+}
+
 /// A walker that searches through #if declarations, finding all text that does
 /// not contribute to the final evaluated AST.
 ///
@@ -93,6 +128,13 @@ struct ExtractInactiveRanges : public ASTWalker {
       return false;
     }
 
+    // If the clause is checking for a particular feature with $, keep
+    // the whole thing.
+    if (anyClauseIsFeatureCheck(icd->getClauses())) {
+      addRange(start, end);
+      return false;
+    }
+
     // Ignore range from beginning of '#if', '#elseif', or '#else' to the
     // beginning of the elements of this clause.
     auto elementsBegin = clause->Loc;

lib/ClangImporter/ImportDecl.cpp

@@ -172,8 +172,8 @@ static FuncDecl *createFuncOrAccessor(ASTContext &ctx, SourceLoc funcLoc,
                                 accessorInfo->Kind, accessorInfo->Storage,
                                 /*StaticLoc*/ SourceLoc(),
                                 StaticSpellingKind::None,
-                                throws, /*ThrowsLoc=*/SourceLoc(),
                                 async, /*AsyncLoc=*/SourceLoc(),
+                                throws, /*ThrowsLoc=*/SourceLoc(),
                                 genericParams, bodyParams,
                                 resultTy, dc, clangNode);
   } else {

lib/IDE/IDERequests.cpp

@@ -815,12 +815,33 @@ struct RangeResolver::Implementation {
     analyzeDecl(D);
     auto &DCInfo = getCurrentDC();
 
-    auto NodeRange = Node.getSourceRange();
-
     // Widen the node's source range to include all attributes to get a range
     // match if a function with its attributes has been selected.
-    if (auto D = Node.dyn_cast<Decl *>())
-      NodeRange = D->getSourceRangeIncludingAttrs();
+    auto getSourceRangeIncludingAttrs = [](ASTNode N) -> SourceRange {
+      if (auto D = N.dyn_cast<Decl *>()) {
+        return D->getSourceRangeIncludingAttrs();
+      } else {
+        return N.getSourceRange();
+      }
+    };
+
+    auto NodeRange = getSourceRangeIncludingAttrs(Node);
+
+    // SemaAnnotator walks the AST in source order, but considers source order
+    // for declarations to be defined by their range *excluding* attributes.
+    // In RangeResolver, we attributes as belonging to their decl (see comment
+    // on getSourceRAngeIncludingAttrs above).
+    // Thus, for the purpose RangeResolver, we need to assume that SemaAnnotator
+    // hands us the nodes in arbitrary order.
+    //
+    // Remove any nodes that are contained by the newly added one.
+    auto removeIterator = std::remove_if(
+        ContainedASTNodes.begin(), ContainedASTNodes.end(),
+        [&](ASTNode ContainedNode) {
+          return SM.rangeContains(NodeRange,
+                                  getSourceRangeIncludingAttrs(ContainedNode));
+        });
+    ContainedASTNodes.erase(removeIterator, ContainedASTNodes.end());
 
     switch (getRangeMatchKind(NodeRange)) {
       case RangeMatchKind::NoneMatch: {
@@ -848,11 +869,16 @@ struct RangeResolver::Implementation {
 
     // If no parent is considered as a contained node; this node should be
     // a top-level contained node.
+    // If a node that contains this one is later discovered, this node will be
+    // removed from ContainedASTNodes again.
     if (std::none_of(ContainedASTNodes.begin(), ContainedASTNodes.end(),
-      [&](ASTNode N) { return SM.rangeContains(N.getSourceRange(),
-                                               Node.getSourceRange()); })) {
-        ContainedASTNodes.push_back(Node);
-      }
+                     [&](ASTNode ContainedNode) {
+                       return SM.rangeContains(
+                           getSourceRangeIncludingAttrs(ContainedNode),
+                           NodeRange);
+                     })) {
+      ContainedASTNodes.push_back(Node);
+    }
 
     if (DCInfo.isMultiStatement()) {
       postAnalysis(DCInfo.EndMatches.back());