Merge pull request #4297 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

include/swift/AST/Expr.h

@@ -491,6 +491,7 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
     return getSemanticsProvidingExpr()->getKind() == ExprKind::InOut;
   }
 
+  bool printConstExprValue(llvm::raw_ostream *OS) const;
   bool isSemanticallyConstExpr() const;
 
   /// Returns false if this expression needs to be wrapped in parens when

include/swift/AST/SearchPathOptions.h

@@ -36,10 +36,9 @@ enum class ModuleSearchPathKind {
 
 /// A single module search path that can come from different sources, e.g.
 /// framework search paths, import search path etc.
-struct ModuleSearchPath {
-  /// The actual path of the module search path. References a search path string
-  /// stored inside \c SearchPathOptions, which must outlive this reference.
-  StringRef Path;
+class ModuleSearchPath : public llvm::RefCountedBase<ModuleSearchPath> {
+  /// The actual path of the module search path.
+  std::string Path;
 
   /// The kind of the search path.
   ModuleSearchPathKind Kind;
@@ -52,6 +51,18 @@ struct ModuleSearchPath {
   /// different file names in \c searchPathsContainingFile.
   unsigned Index;
 
+public:
+  ModuleSearchPath(StringRef Path, ModuleSearchPathKind Kind, bool IsSystem,
+                   unsigned Index)
+      : Path(Path), Kind(Kind), IsSystem(IsSystem), Index(Index) {}
+
+  StringRef getPath() const { return Path; }
+  ModuleSearchPathKind getKind() const { return Kind; }
+
+  bool isSystem() const { return IsSystem; }
+
+  unsigned getIndex() const { return Index; }
+
   bool operator<(const ModuleSearchPath &Other) const {
     if (this->Kind == Other.Kind) {
       return this->Index < Other.Index;
@@ -61,6 +72,8 @@ struct ModuleSearchPath {
   }
 };
 
+using ModuleSearchPathPtr = llvm::IntrusiveRefCntPtr<ModuleSearchPath>;
+
 class SearchPathOptions;
 
 /// Maintains a mapping of filenames to search paths that contain a file with
@@ -97,7 +110,7 @@ class ModuleSearchPathLookup {
     const SearchPathOptions *Opts;
   } State;
 
-  llvm::StringMap<SmallVector<ModuleSearchPath, 4>> LookupTable;
+  llvm::StringMap<SmallVector<ModuleSearchPathPtr, 4>> LookupTable;
 
   /// Scan the directory at \p SearchPath for files and add those files to the
   /// lookup table. \p Kind specifies the search path kind and \p Index the

include/swift/SILOptimizer/Utils/CFGOptUtils.h

@@ -144,6 +144,22 @@ SILBasicBlock *splitBasicBlockAndBranch(SILBuilder &builder,
                                         DominanceInfo *domInfo,
                                         SILLoopInfo *loopInfo);
 
+/// A version of splitBasicBlockAndBranch that takes a SILBuilderContext instead
+/// of a SILBuilder. We generally are trying to eliminate APIs that take in
+/// SILBuilder directly since that can cause weird downstream mistakes around
+/// debug info scopes. So this provides a better choice for engineers.
+///
+/// TODO: Migrate all callers of splitBasicBlockAndBranch to use this entry
+/// point.
+inline SILBasicBlock *splitBasicBlockAndBranch(SILBuilderContext &builderCtx,
+                                               SILInstruction *splitBeforeInst,
+                                               DominanceInfo *domInfo,
+                                               SILLoopInfo *loopInfo) {
+  // Make sure we have the right debug scope from split before inst.
+  SILBuilderWithScope builder(splitBeforeInst, builderCtx);
+  return splitBasicBlockAndBranch(builder, splitBeforeInst, domInfo, loopInfo);
+}
+
 /// Return true if the function has a critical edge, false otherwise.
 bool hasCriticalEdges(SILFunction &f, bool onlyNonCondBr);
 

lib/APIDigester/ModuleAnalyzerNodes.cpp

@@ -2220,8 +2220,12 @@ static parseJsonEmit(SDKContext &Ctx, StringRef FileName) {
   return {std::move(FileBufOrErr.get()), Result};
 }
 enum class ConstKind: uint8_t {
-  String = 0,
-  Int,
+  StringLiteral = 0,
+  IntegerLiteral,
+  FloatLiteral,
+  BooleanLiteral,
+  Array,
+  Dictionary,
 };
 
 struct ConstExprInfo {
@@ -2230,9 +2234,11 @@ struct ConstExprInfo {
   unsigned offset = 0;
   unsigned length = 0;
   StringRef value;
+  StringRef referencedD;
   ConstExprInfo(StringRef filePath, ConstKind kind, unsigned offset,
-                unsigned length, StringRef value):
-    filePath(filePath), kind(kind), offset(offset), length(length), value(value) {}
+                unsigned length, StringRef value, StringRef referencedD):
+    filePath(filePath), kind(kind), offset(offset), length(length), value(value),
+    referencedD(referencedD) {}
   ConstExprInfo() = default;
 };
 
@@ -2242,7 +2248,7 @@ class ConstExtractor: public ASTWalker {
   SourceManager &SM;
   std::vector<ConstExprInfo> allConsts;
 
-  void record(Expr *E, ConstKind kind, StringRef Value) {
+  void record(Expr *E, ConstKind kind, StringRef Value, StringRef ReferencedD) {
     auto startLoc = E->getStartLoc();
     // Asserts?
     if (startLoc.isInvalid())
@@ -2254,14 +2260,70 @@ class ConstExtractor: public ASTWalker {
     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);
+    allConsts.emplace_back(file, kind, offset, length, Value, ReferencedD);
+  }
+
+  void record(Expr *E, Expr *ValueProvider, StringRef ReferecedD = "") {
+    std::string content;
+    llvm::raw_string_ostream os(content);
+    ValueProvider->printConstExprValue(&os);
+    assert(!content.empty());
+    auto buffered = SCtx.buffer(content);
+    switch(ValueProvider->getKind()) {
+#define CASE(X) case ExprKind::X: record(E, ConstKind::X, buffered, ReferecedD); break;
+      CASE(StringLiteral)
+      CASE(IntegerLiteral)
+      CASE(FloatLiteral)
+      CASE(BooleanLiteral)
+      CASE(Dictionary)
+      CASE(Array)
+#undef CASE
+    default:
+      return;
+    }
+  }
+
+  StringRef getDeclName(Decl *D) {
+    if (auto *VD = dyn_cast<ValueDecl>(D)) {
+      std::string content;
+      llvm::raw_string_ostream os(content);
+      VD->getName().print(os);
+      return SCtx.buffer(content);
+    }
+    return StringRef();
   }
 
+  bool handleSimpleReference(Expr *E) {
+    assert(E);
+    Decl *ReferencedDecl = nullptr;
+    if (auto *MRE = dyn_cast<MemberRefExpr>(E)) {
+      ReferencedDecl = MRE->getDecl().getDecl();
+    } else if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
+      ReferencedDecl = DRE->getDecl();
+    } else {
+      return false;
+    }
+    assert(ReferencedDecl);
+    if (auto *VAR = dyn_cast<VarDecl>(ReferencedDecl)) {
+      if (!VAR->getAttrs().hasAttribute<CompileTimeConstAttr>()) {
+        return false;
+      }
+      if (auto *PD = VAR->getParentPatternBinding()) {
+        if (auto *init = PD->getInit(PD->getPatternEntryIndexForVarDecl(VAR))) {
+          record(E, init, getDeclName(ReferencedDecl));
+          return true;
+        }
+      }
+    }
+    return false;
+  }
   std::pair<bool, Expr *> walkToExprPre(Expr *E) override {
     if (E->isSemanticallyConstExpr()) {
-      if (auto *SL = dyn_cast<StringLiteralExpr>(E)) {
-        record(SL, ConstKind::String, SL->getValue());
-      }
+      record(E, E);
+      return { false, E };
+    }
+    if (handleSimpleReference(E)) {
+      return { false, E };
     }
     return { true, E };
   }
@@ -2279,14 +2341,20 @@ template <> struct swift::json::ObjectTraits<ConstExprInfo> {
     StringRef kind;
     switch(info.kind) {
 #define CASE(X) case ConstKind::X: kind = #X; break;
-    CASE(String)
-    CASE(Int)
+    CASE(StringLiteral)
+    CASE(IntegerLiteral)
+    CASE(FloatLiteral)
+    CASE(BooleanLiteral)
+    CASE(Dictionary)
+    CASE(Array)
 #undef CASE
     }
     out.mapRequired("kind", kind);
     out.mapRequired("offset", info.offset);
     out.mapRequired("length", info.length);
     out.mapRequired("value", info.value);
+    if (!info.referencedD.empty())
+      out.mapRequired("decl", info.referencedD);
   }
 };
 

lib/AST/Expr.cpp

@@ -198,42 +198,83 @@ Expr *Expr::getSemanticsProvidingExpr() {
   return this;
 }
 
-bool Expr::isSemanticallyConstExpr() const {
-  auto E = getSemanticsProvidingExpr();
-  if (!E) {
-    return false;
+bool Expr::printConstExprValue(llvm::raw_ostream *OS) const {
+  auto print = [&](StringRef text) {
+    if (OS) {
+      *OS << text;
+    }
+  };
+  auto *E = getSemanticsProvidingExpr();
+  assert(E);
+  switch(getKind()) {
+  case ExprKind::BooleanLiteral: {
+    auto isTrue = cast<BooleanLiteralExpr>(E)->getValue();
+    print(isTrue ? "true" : "false");
+    return true;
   }
-  switch(E->getKind()) {
   case ExprKind::IntegerLiteral:
-  case ExprKind::NilLiteral:
-  case ExprKind::BooleanLiteral:
-  case ExprKind::FloatLiteral:
-  case ExprKind::StringLiteral:
-  case ExprKind::KeyPath:
+  case ExprKind::FloatLiteral:  {
+    auto digits = cast<NumberLiteralExpr>(E)->getDigitsText();
+    assert(!digits.empty());
+    print(digits);
     return true;
+  }
+  case ExprKind::NilLiteral: {
+    print("nil");
+    return true;
+  }
+  case ExprKind::StringLiteral: {
+    auto *LE = cast<StringLiteralExpr>(E);
+    print("\"");
+    print(LE->getValue());
+    print("\"");
+    return true;
+  }
+  case ExprKind::KeyPath: {
+    // FIXME: print keypath
+    print("\\.<NOT_IMPLEMENTED>");
+    return true;
+  }
   case ExprKind::Array:
   case ExprKind::Dictionary: {
+    print("[");
     auto *CE = cast<CollectionExpr>(E);
-    for (auto *EL: CE->getElements()) {
-      if (!EL->isSemanticallyConstExpr())
+    for (unsigned N = CE->getNumElements(), I = 0; I != N; I ++) {
+      auto Ele = CE->getElement(I);
+      auto needComma = I + 1 != N;
+      if (!Ele->printConstExprValue(OS)) {
         return false;
+      }
+      if (needComma)
+        print(", ");
     }
+    print("]");
     return true;
   }
   case ExprKind::Tuple: {
+    print("(");
     auto *TE = cast<TupleExpr>(E);
-    for (auto *EL: TE->getElements()) {
-      if (!EL->isSemanticallyConstExpr()) {
+    for (unsigned N = TE->getNumElements(), I = 0; I != N; I ++) {
+      auto Ele = TE->getElement(I);
+      auto needComma = I + 1 != N;
+      if (!Ele->printConstExprValue(OS)) {
         return false;
       }
+      if (needComma)
+        print(", ");
     }
+    print(")");
     return true;
   }
   default:
     return false;
   }
 }
 
+bool Expr::isSemanticallyConstExpr() const {
+  return printConstExprValue(nullptr);
+}
+
 Expr *Expr::getValueProvidingExpr() {
   Expr *E = getSemanticsProvidingExpr();
 

lib/AST/SearchPathOptions.cpp

@@ -19,16 +19,24 @@ void ModuleSearchPathLookup::addFilesInPathToLookupTable(
     llvm::vfs::FileSystem *FS, StringRef SearchPath, ModuleSearchPathKind Kind,
     bool IsSystem, unsigned SearchPathIndex) {
   std::error_code Error;
-  assert(llvm::all_of(LookupTable, [&](const auto &LookupTableEntry) {
-    return llvm::none_of(LookupTableEntry.second, [&](const ModuleSearchPath &ExistingSearchPath) -> bool {
-      return ExistingSearchPath.Kind == Kind && ExistingSearchPath.Index == SearchPathIndex;
+  auto entryAlreadyExists = [this](ModuleSearchPathKind Kind,
+                                   unsigned SearchPathIndex) -> bool {
+    return llvm::any_of(LookupTable, [&](const auto &LookupTableEntry) {
+      return llvm::any_of(
+          LookupTableEntry.second, [&](ModuleSearchPathPtr ExistingSearchPath) {
+            return ExistingSearchPath->getKind() == Kind &&
+                   ExistingSearchPath->getIndex() == SearchPathIndex;
+          });
     });
-  }) && "Search path with this kind and index already exists");
+  };
+  assert(!entryAlreadyExists(Kind, SearchPathIndex) &&
+         "Search path with this kind and index already exists");
+  ModuleSearchPathPtr TableEntry =
+      new ModuleSearchPath(SearchPath, Kind, IsSystem, SearchPathIndex);
   for (auto Dir = FS->dir_begin(SearchPath, Error);
        !Error && Dir != llvm::vfs::directory_iterator(); Dir.increment(Error)) {
     StringRef Filename = llvm::sys::path::filename(Dir->path());
-    LookupTable[Filename].push_back(
-        {SearchPath, Kind, IsSystem, SearchPathIndex});
+    LookupTable[Filename].push_back(TableEntry);
   }
 }
 
@@ -92,8 +100,9 @@ ModuleSearchPathLookup::searchPathsContainingFile(
 
   for (auto &Filename : Filenames) {
     for (auto &Entry : LookupTable[Filename]) {
-      if (ResultIds.insert(std::make_pair(Entry.Kind, Entry.Index)).second) {
-        Result.push_back(&Entry);
+      if (ResultIds.insert(std::make_pair(Entry->getKind(), Entry->getIndex()))
+              .second) {
+        Result.push_back(Entry.get());
       }
     }
   }