Merge pull request #4261 from swiftwasm/main

[pull] swiftwasm from main

Author: MaxDesiatov

include/swift/APIDigester/ModuleAnalyzerNodes.h

@@ -66,6 +66,7 @@ namespace api {
 const uint8_t DIGESTER_JSON_VERSION = 7; // push SDKNodeRoot to lower-level
 const uint8_t DIGESTER_JSON_DEFAULT_VERSION = 0; // Use this version number for files before we have a version number in json.
 const StringRef ABIRootKey = "ABIRoot";
+const StringRef ConstValuesKey = "ConstValues";
 
 class SDKNode;
 typedef SDKNode* NodePtr;
@@ -737,6 +738,8 @@ struct TypeInitInfo {
   StringRef ValueOwnership;
 };
 
+struct PayLoad;
+
 class SwiftDeclCollector: public VisibleDeclConsumer {
   SDKContext &Ctx;
   SDKNode *RootNode;
@@ -757,7 +760,7 @@ class SwiftDeclCollector: public VisibleDeclConsumer {
 
   // Serialize the content of all roots to a given file using JSON format.
   void serialize(StringRef Filename);
-  static void serialize(StringRef Filename, SDKNode *Root);
+  static void serialize(StringRef Filename, SDKNode *Root, PayLoad otherInfo);
 
   // After collecting decls, either from imported modules or from a previously
   // serialized JSON file, using this function to get the root of the SDK.
@@ -806,6 +809,7 @@ SDKNodeRoot *getSDKNodeRoot(SDKContext &SDKCtx,
 
 SDKNodeRoot *getEmptySDKNodeRoot(SDKContext &SDKCtx);
 
+void dumpSDKRoot(SDKNodeRoot *Root, PayLoad load, StringRef OutputFile);
 void dumpSDKRoot(SDKNodeRoot *Root, StringRef OutputFile);
 
 int dumpSDKContent(const CompilerInvocation &InitInvok,

include/swift/AST/ASTContext.h

@@ -367,12 +367,6 @@ class ASTContext final {
   /// i.e. true if the entry is [key: alias_name, value: (real_name, true)].
   mutable llvm::DenseMap<Identifier, std::pair<Identifier, bool>> ModuleAliasMap;
 
-  /// The maximum arity of `_StringProcessing.Tuple{n}`.
-  static constexpr unsigned StringProcessingTupleDeclMaxArity = 8;
-  /// Cached `_StringProcessing.Tuple{n}` declarations.
-  mutable SmallVector<StructDecl *, StringProcessingTupleDeclMaxArity - 2>
-      StringProcessingTupleDecls;
-
   /// Retrieve the allocator for the given arena.
   llvm::BumpPtrAllocator &
   getAllocator(AllocationArena arena = AllocationArena::Permanent) const;
@@ -629,14 +623,6 @@ class ASTContext final {
   /// Retrieve _StringProcessing.Regex.init(_regexString: String, version: Int).
   ConcreteDeclRef getRegexInitDecl(Type regexType) const;
 
-  /// Retrieve the max arity that `_StringProcessing.Tuple{arity}` was
-  /// instantiated for.
-  unsigned getStringProcessingTupleDeclMaxArity() const;
-
-  /// Retrieve the `_StringProcessing.Tuple{arity}` declaration for the given
-  /// arity.
-  StructDecl *getStringProcessingTupleDecl(unsigned arity) const;
-
   /// Retrieve the declaration of Swift.<(Int, Int) -> Bool.
   FuncDecl *getLessThanIntDecl() const;
 

include/swift/AST/DiagnosticsSema.def

@@ -4837,9 +4837,6 @@ ERROR(string_processing_lib_missing,none,
 ERROR(regex_capture_types_failed_to_decode,none,
       "failed to decode capture types for regular expression literal; this may "
       "be a compiler bug", ())
-ERROR(regex_too_many_captures,none,
-      "too many captures in regular expression literal; the current limit is "
-      "%0", (unsigned))
 
 //------------------------------------------------------------------------------
 // MARK: Type Check Types

include/swift/AST/KnownSDKTypes.def

@@ -49,6 +49,5 @@ KNOWN_SDK_TYPE_DECL(Distributed, RemoteCallTarget, StructDecl, 0)
 
 // String processing
 KNOWN_SDK_TYPE_DECL(StringProcessing, Regex, StructDecl, 1)
-KNOWN_SDK_TYPE_DECL(StringProcessing, DynamicCaptures, EnumDecl, 0)
 
 #undef KNOWN_SDK_TYPE_DECL

include/swift/AST/Types.h

@@ -5773,9 +5773,6 @@ class OpenedArchetypeType final : public ArchetypeType,
 
   /// Retrieve the ID number of this opened existential.
   UUID getOpenedExistentialID() const;
-  
-  /// Retrieve the opened existential type
-  Type getOpenedExistentialType() const;
 
   /// Return the archetype that represents the root generic parameter of its
   /// interface type.
@@ -6415,8 +6412,7 @@ inline bool TypeBase::isOpenedExistentialWithError() {
 
   CanType T = getCanonicalType();
   if (auto archetype = dyn_cast<OpenedArchetypeType>(T)) {
-    auto openedExistentialType = archetype->getOpenedExistentialType();
-    return openedExistentialType->isExistentialWithError();
+    return archetype->getExistentialType()->isExistentialWithError();
   }
   return false;
 }

include/swift/SIL/SILBasicBlock.h

@@ -426,6 +426,12 @@ public SwiftObjectHeader {
   /// the debug scope for newly created instructions.
   const SILDebugScope *getScopeOfFirstNonMetaInstruction();
 
+  /// Whether the block has any phi arguments.
+  ///
+  /// Note that a block could have an argument and still return false.  The
+  /// argument must also satisfy SILPhiArgument::isPhiArgument.
+  bool hasPhi() const;
+
   //===--------------------------------------------------------------------===//
   // Debugging
   //===--------------------------------------------------------------------===//

include/swift/SIL/SILCloner.h

@@ -248,8 +248,10 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
     return asImpl().remapASTType(ty);
   }
 
-  void remapOpenedType(CanOpenedArchetypeType archetypeTy) {
-    auto existentialTy = archetypeTy->getOpenedExistentialType()->getCanonicalType();
+  void remapRootOpenedType(CanOpenedArchetypeType archetypeTy) {
+    assert(archetypeTy->isRoot());
+
+    auto existentialTy = archetypeTy->getExistentialType()->getCanonicalType();
     auto replacementTy = OpenedArchetypeType::get(
         getOpASTType(existentialTy),
         archetypeTy->getInterfaceType());
@@ -2199,7 +2201,7 @@ template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitOpenExistentialAddrInst(OpenExistentialAddrInst *Inst) {
   // Create a new archetype for this opened existential type.
-  remapOpenedType(Inst->getType().castTo<OpenedArchetypeType>());
+  remapRootOpenedType(Inst->getType().castTo<OpenedArchetypeType>());
 
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   recordClonedInstruction(
@@ -2212,7 +2214,7 @@ template <typename ImplClass>
 void SILCloner<ImplClass>::visitOpenExistentialValueInst(
     OpenExistentialValueInst *Inst) {
   // Create a new archetype for this opened existential type.
-  remapOpenedType(Inst->getType().castTo<OpenedArchetypeType>());
+  remapRootOpenedType(Inst->getType().castTo<OpenedArchetypeType>());
 
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   recordClonedInstruction(
@@ -2235,7 +2237,7 @@ visitOpenExistentialMetatypeInst(OpenExistentialMetatypeInst *Inst) {
     exType = exMetatype->getExistentialInstanceType()->getCanonicalType();
     openedType = cast<MetatypeType>(openedType).getInstanceType();
   }
-  remapOpenedType(cast<OpenedArchetypeType>(openedType));
+  remapRootOpenedType(cast<OpenedArchetypeType>(openedType));
 
   if (!Inst->getOperand()->getType().canUseExistentialRepresentation(
           ExistentialRepresentation::Class)) {
@@ -2259,7 +2261,7 @@ void
 SILCloner<ImplClass>::
 visitOpenExistentialRefInst(OpenExistentialRefInst *Inst) {
   // Create a new archetype for this opened existential type.
-  remapOpenedType(Inst->getType().castTo<OpenedArchetypeType>());
+  remapRootOpenedType(Inst->getType().castTo<OpenedArchetypeType>());
 
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   recordClonedInstruction(
@@ -2276,7 +2278,7 @@ void
 SILCloner<ImplClass>::
 visitOpenExistentialBoxInst(OpenExistentialBoxInst *Inst) {
   // Create a new archetype for this opened existential type.
-  remapOpenedType(Inst->getType().castTo<OpenedArchetypeType>());
+  remapRootOpenedType(Inst->getType().castTo<OpenedArchetypeType>());
 
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   recordClonedInstruction(Inst, getBuilder().createOpenExistentialBox(
@@ -2290,7 +2292,7 @@ void
 SILCloner<ImplClass>::
 visitOpenExistentialBoxValueInst(OpenExistentialBoxValueInst *Inst) {
   // Create a new archetype for this opened existential type.
-  remapOpenedType(Inst->getType().castTo<OpenedArchetypeType>());
+  remapRootOpenedType(Inst->getType().castTo<OpenedArchetypeType>());
 
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   recordClonedInstruction(

include/swift/SILOptimizer/Analysis/Reachability.h

@@ -26,6 +26,8 @@
 
 #include "swift/SIL/BasicBlockDatastructures.h"
 #include "swift/SIL/SILBasicBlock.h"
+#include "swift/SIL/SILSuccessor.h"
+#include "llvm/ADT/STLExtras.h"
 
 namespace swift {
 
@@ -44,16 +46,19 @@ namespace swift {
 ///   // Mark the beginning of a block reachable. Only called once per block.
 ///   // Typically a BasicBlockSet wrapper.
 ///   void markReachableBegin(SILBasicBlock *block);
-/// 
+///
 ///   // Mark the end of a block reachable. Only called once per block.
 ///   // Typically a BasicBlockSet wrapper.
 ///   void markReachableEnd(SILBasicBlock *block);
 ///
 ///   // Return true if \p inst is a barrier. Called once for each reachable
-///   // instruction, assuming that each lastUse is itself a barrier.
+///   // instruction, assuming that each lastUsePoint is itself a barrier.
 ///   // Used by the data flow client to perform additional book-keeping,
 ///   // such as recording debug_value instructions.
 ///   bool checkReachableBarrier(SILInstruction *inst);
+///
+///   // Return true if any of \p block's phis are barriers.
+///   bool checkReachablePhiBarrier(SILBasicBlock *block);
 /// };
 template <typename BlockReachability>
 class BackwardReachability {
@@ -70,7 +75,8 @@ class BackwardReachability {
   // Initialize data flow starting points before running solveBackward.
   void initLastUse(SILInstruction *lastUsePoint) {
     auto *lastUseBlock = lastUsePoint->getParent();
-    if (canReachBlockBegin(lastUsePoint)) {
+    auto *previous = lastUsePoint->getPreviousInstruction();
+    if (!previous || canReachBlockBegin(previous)) {
       pushPreds(lastUseBlock);
     }
   }
@@ -116,6 +122,10 @@ class BackwardReachability {
 
   // Propagate global data flow from \p succBB to its predecessors.
   void pushPreds(SILBasicBlock *succBB) {
+    if (succBB->hasPhi())
+      if (reachableBlocks.checkReachablePhiBarrier(succBB))
+        return;
+
     reachableBlocks.markReachableBegin(succBB);
 
     for (SILBasicBlock *predBB : succBB->getPredecessorBlocks()) {

include/swift/SILOptimizer/Utils/CanonicalizeBorrowScope.h

@@ -148,7 +148,7 @@ class CanonicalizeBorrowScope {
 };
 
 bool shrinkBorrowScope(
-    BeginBorrowInst *bbi, InstructionDeleter &deleter,
+    BeginBorrowInst const &bbi, InstructionDeleter &deleter,
     SmallVectorImpl<CopyValueInst *> &modifiedCopyValueInsts);
 
 bool foldDestroysOfCopiedLexicalBorrow(BeginBorrowInst *bbi,

lib/APIDigester/ModuleAnalyzerNodes.cpp

@@ -746,6 +746,9 @@ SDKNode* SDKNode::constructSDKNode(SDKContext &Ctx,
     } else if (keyString == ABIRootKey) {
       Result = constructSDKNode(Ctx,
         cast<llvm::yaml::MappingNode>(Pair.getValue()));
+    } else if (keyString == ConstValuesKey) {
+      // We don't need to consume the const values from the compiler-side
+      Pair.skip();
     } else {
       Ctx.diagnose(Pair.getKey(), diag::sdk_node_unrecognized_key,
                               keyString);
@@ -2216,8 +2219,81 @@ static parseJsonEmit(SDKContext &Ctx, StringRef FileName) {
   }
   return {std::move(FileBufOrErr.get()), Result};
 }
+enum class ConstKind: uint8_t {
+  String = 0,
+  Int,
+};
+
+struct ConstExprInfo {
+  StringRef filePath;
+  ConstKind kind;
+  unsigned offset = 0;
+  unsigned length = 0;
+  StringRef value;
+  ConstExprInfo(StringRef filePath, ConstKind kind, unsigned offset,
+                unsigned length, StringRef value):
+    filePath(filePath), kind(kind), offset(offset), length(length), value(value) {}
+  ConstExprInfo() = default;
+};
+
+class ConstExtractor: public ASTWalker {
+  SDKContext &SCtx;
+  ASTContext &Ctx;
+  SourceManager &SM;
+  std::vector<ConstExprInfo> allConsts;
+
+  void record(Expr *E, ConstKind kind, StringRef Value) {
+    auto startLoc = E->getStartLoc();
+    // Asserts?
+    if (startLoc.isInvalid())
+      return;
+    auto endLoc = E->getEndLoc();
+    assert(endLoc.isValid());
+    endLoc = Lexer::getLocForEndOfToken(SM, endLoc);
+    auto bufferId = SM.findBufferContainingLoc(startLoc);
+    auto length = SM.getByteDistance(startLoc, endLoc);
+    auto file = SM.getIdentifierForBuffer(bufferId);
+    auto offset = SM.getLocOffsetInBuffer(startLoc, bufferId);
+    allConsts.emplace_back(file, kind, offset, length, Value);
+  }
+
+  std::pair<bool, Expr *> walkToExprPre(Expr *E) override {
+    if (E->isSemanticallyConstExpr()) {
+      if (auto *SL = dyn_cast<StringLiteralExpr>(E)) {
+        record(SL, ConstKind::String, SL->getValue());
+      }
+    }
+    return { true, E };
+  }
+public:
+  ConstExtractor(SDKContext &SCtx, ASTContext &Ctx): SCtx(SCtx), Ctx(Ctx),
+    SM(Ctx.SourceMgr) {}
+  void extract(ModuleDecl *MD) { MD->walk(*this); }
+  std::vector<ConstExprInfo> &getAllConstValues() { return allConsts; }
+};
 } // End of anonymous namespace
 
+template <> struct swift::json::ObjectTraits<ConstExprInfo> {
+  static void mapping(Output &out, ConstExprInfo &info) {
+    out.mapRequired("filePath", info.filePath);
+    StringRef kind;
+    switch(info.kind) {
+#define CASE(X) case ConstKind::X: kind = #X; break;
+    CASE(String)
+    CASE(Int)
+#undef CASE
+    }
+    out.mapRequired("kind", kind);
+    out.mapRequired("offset", info.offset);
+    out.mapRequired("length", info.length);
+    out.mapRequired("value", info.value);
+  }
+};
+
+struct swift::ide::api::PayLoad {
+  std::vector<ConstExprInfo> *allContsValues = nullptr;
+};
+
 // Construct all roots vector from a given file where a forest was
 // previously dumped.
 void SwiftDeclCollector::deSerialize(StringRef Filename) {
@@ -2226,20 +2302,24 @@ void SwiftDeclCollector::deSerialize(StringRef Filename) {
 }
 
 // Serialize the content of all roots to a given file using JSON format.
-void SwiftDeclCollector::serialize(StringRef Filename, SDKNode *Root) {
+void SwiftDeclCollector::serialize(StringRef Filename, SDKNode *Root,
+                                   PayLoad OtherInfo) {
   std::error_code EC;
   llvm::raw_fd_ostream fs(Filename, EC, llvm::sys::fs::OF_None);
   json::Output yout(fs);
   assert(Root->getKind() == SDKNodeKind::Root);
   SDKNodeRoot &root = *static_cast<SDKNodeRoot*>(Root);
   yout.beginObject();
   yout.mapRequired(ABIRootKey, root);
+  if (auto *constValues = OtherInfo.allContsValues) {
+    yout.mapRequired(ConstValuesKey, *constValues);
+  }
   yout.endObject();
 }
 
 // Serialize the content of all roots to a given file using JSON format.
 void SwiftDeclCollector::serialize(StringRef Filename) {
-  SwiftDeclCollector::serialize(Filename, RootNode);
+  SwiftDeclCollector::serialize(Filename, RootNode, PayLoad());
 }
 
 SDKNodeRoot *
@@ -2305,16 +2385,21 @@ swift::ide::api::getSDKNodeRoot(SDKContext &SDKCtx,
   return Collector.getSDKRoot();
 }
 
-void swift::ide::api::dumpSDKRoot(SDKNodeRoot *Root, StringRef OutputFile) {
+void swift::ide::api::dumpSDKRoot(SDKNodeRoot *Root, PayLoad load,
+                                  StringRef OutputFile) {
   assert(Root);
   auto Opts = Root->getSDKContext().getOpts();
   if (Opts.Verbose)
     llvm::errs() << "Dumping SDK...\n";
-  SwiftDeclCollector::serialize(OutputFile, Root);
+  SwiftDeclCollector::serialize(OutputFile, Root, load);
   if (Opts.Verbose)
     llvm::errs() << "Dumped to "<< OutputFile << "\n";
 }
 
+void swift::ide::api::dumpSDKRoot(SDKNodeRoot *Root, StringRef OutputFile) {
+  dumpSDKRoot(Root, PayLoad(), OutputFile);
+}
+
 int swift::ide::api::dumpSDKContent(const CompilerInvocation &InitInvok,
                                     const llvm::StringSet<> &ModuleNames,
                                     StringRef OutputFile, CheckerOptions Opts) {
@@ -2357,7 +2442,11 @@ void swift::ide::api::dumpModuleContent(ModuleDecl *MD, StringRef OutputFile,
   SDKContext ctx(opts);
   SwiftDeclCollector collector(ctx);
   collector.lookupVisibleDecls({MD});
-  dumpSDKRoot(collector.getSDKRoot(), OutputFile);
+  ConstExtractor extractor(ctx, MD->getASTContext());
+  extractor.extract(MD);
+  PayLoad payload;
+  payload.allContsValues = &extractor.getAllConstValues();
+  dumpSDKRoot(collector.getSDKRoot(), payload, OutputFile);
 }
 
 int swift::ide::api::findDeclUsr(StringRef dumpPath, CheckerOptions Opts) {