chore: Merge upstream master into scip-ruby/master (#168)

Co-authored-by: Reese Williams <[email protected]>
Co-authored-by: Nathan Froyd <[email protected]>
Co-authored-by: Thomas Marshall <[email protected]>
Co-authored-by: aadi-stripe <[email protected]>
Co-authored-by: Mariano Simone <[email protected]>
Co-authored-by: Jake Zimmerman <[email protected]>
Co-authored-by: Reese Williams <[email protected]>

Author: 8 people

ast/Trees.cc

@@ -421,6 +421,15 @@ template <class T> void printArgs(const core::GlobalState &gs, fmt::memory_buffe
 
 } // namespace
 
+core::FoundClass::Kind ClassDef::kindToFoundClassKind(Kind kind) {
+    switch (kind) {
+        case Kind::Module:
+            return core::FoundClass::Kind::Module;
+        case Kind::Class:
+            return core::FoundClass::Kind::Class;
+    }
+}
+
 string ClassDef::toStringWithTabs(const core::GlobalState &gs, int tabs) const {
     fmt::memory_buffer buf;
     if (kind == ClassDef::Kind::Module) {

ast/Trees.h

@@ -352,8 +352,13 @@ EXPRESSION(ClassDef) {
     core::LocOffsets declLoc;
     core::ClassOrModuleRef symbol;
 
-    using Kind = core::FoundClass::Kind;
+    enum class Kind : uint8_t {
+        Module,
+        Class,
+    };
     Kind kind;
+
+    static core::FoundClass::Kind kindToFoundClassKind(Kind kind);
     static constexpr int EXPECTED_RHS_COUNT = 4;
     using RHS_store = InlinedVector<ExpressionPtr, EXPECTED_RHS_COUNT>;
 

common/BUILD

@@ -1,20 +1,13 @@
 cc_library(
     name = "common",
-    srcs = [
-        "os/os.h",
-        "os/os.cc",
-    ] + glob(
+    srcs = glob(
         [
             "*.cc",
             "*.h",
         ],
         # workaround https://github.com/flycheck/flycheck/issues/248 in emacs
         exclude = ["flycheck_*"],
-    ) + select({
-        "//tools/config:darwin": ["os/mac.cc"],
-        "//tools/config:webasm": ["os/emscripten.cc"],
-        "//conditions:default": ["os/linux.cc"],
-    }),
+    ),
     hdrs = [
         "FileOps.h",
         "FileSystem.h",
@@ -35,6 +28,10 @@ cc_library(
     }),
     visibility = ["//visibility:public"],
     deps = [
+        "//common/concurrency",
+        "//common/enforce_no_timer",
+        "//common/exception",
+        "//common/os",
         "//sorbet_version",
         "//third_party/progressbar",
         "@com_google_absl//absl/algorithm:container",

common/EarlyReturnWithCode.h

@@ -1,7 +1,7 @@
 #ifndef SORBET_COMMON_EARLYRETURNWITHCODE_H
 #define SORBET_COMMON_EARLYRETURNWITHCODE_H
 
-#include "Exception.h"
+#include "exception/Exception.h"
 
 namespace sorbet {
 

common/FileOps.h

@@ -7,6 +7,7 @@
 #include <vector>
 
 namespace sorbet {
+class WorkerPool;
 
 class FileOps final {
 public:
@@ -16,36 +17,42 @@ class FileOps final {
         std::optional<std::string> output = std::nullopt;
     };
 
-    static bool exists(std::string_view filename);
+    static bool exists(const std::string &filename);
     static bool isFile(std::string_view path, std::string_view ignorePattern, const int pos);
     static bool isFolder(std::string_view path, std::string_view ignorePattern, const int pos);
-    static std::string read(std::string_view filename);
-    static void write(std::string_view filename, const std::vector<uint8_t> &data);
-    static void append(std::string_view filename, std::string_view text);
-    static void write(std::string_view filename, std::string_view text);
-    static bool writeIfDifferent(std::string_view filename, std::string_view text);
-    static bool dirExists(std::string_view path);
-    static void createDir(std::string_view path);
+    static std::string read(const std::string &filename);
+    static void write(const std::string &filename, const std::vector<uint8_t> &data);
+    static void append(const std::string &filename, std::string_view text);
+    static void write(const std::string &filename, std::string_view text);
+    static bool writeIfDifferent(const std::string &filename, std::string_view text);
+    static bool dirExists(const std::string &path);
+    static void createDir(const std::string &path);
 
     // This differs from createDir, as it will not raise an exception if the directory already exists. Returns true when
     // the directory was created, and false if it already existed.
     //
     // NOTE: This does not create parent directories if they exist.
-    static bool ensureDir(std::string_view path);
+    static bool ensureDir(const std::string &path);
 
     static std::string getCurrentDir();
 
     // NOTE: this is a minimal wrapper around rmdir, and as such will raise an exception if the directory is not empty
     // when it's removed.
-    static void removeDir(std::string_view path);
+    static void removeDir(const std::string &path);
+
+    // NOTE: this is a minimal wrapper around rmdir, and will return false if the directory is not empty
+    // when it's removed. For any other errno, it will throw an exception. This exists as an convenience function to
+    // prevent the caller from needing to try/catch removeDir.
+    static bool removeEmptyDir(const std::string &path);
+
+    static void removeFile(const std::string &path);
 
-    static void removeFile(std::string_view path);
     /**
      * Returns a list of all files in the given directory. Returns paths that include the path to directory.
      * Throws FileNotFoundException if path does not exist, and FileNotDirException if path is not a directory.
      */
     static std::vector<std::string> listFilesInDir(std::string_view path, const UnorderedSet<std::string> &extensions,
-                                                   bool recursive,
+                                                   WorkerPool &workers, bool recursive,
                                                    const std::vector<std::string> &absoluteIgnorePatterns,
                                                    const std::vector<std::string> &relativeIgnorePatterns);
     /**

common/FileSystem.cc

@@ -1,25 +1,37 @@
 #include "common/FileSystem.h"
 #include "common/FileOps.h"
+#include "common/concurrency/WorkerPool.h"
 
 namespace sorbet {
 using namespace std;
 
-string OSFileSystem::readFile(string_view path) const {
+string OSFileSystem::readFile(const string &path) const {
     return FileOps::read(path);
 }
 
-void OSFileSystem::writeFile(string_view filename, string_view text) {
+void OSFileSystem::writeFile(const string &filename, string_view text) {
     return FileOps::write(filename, text);
 }
 
 std::string OSFileSystem::getCurrentDir() const {
     return FileOps::getCurrentDir();
 }
 
+vector<string> FileSystem::listFilesInDir(std::string_view path, const UnorderedSet<std::string> &extensions,
+                                          bool recursive, const std::vector<std::string> &absoluteIgnorePatterns,
+                                          const std::vector<std::string> &relativeIgnorePatterns) const {
+    unique_ptr<WorkerPool> workerPool = WorkerPool::create(0, *spdlog::default_logger());
+
+    return this->listFilesInDir(path, extensions, *workerPool, recursive, absoluteIgnorePatterns,
+                                relativeIgnorePatterns);
+}
+
 vector<string> OSFileSystem::listFilesInDir(string_view path, const UnorderedSet<std::string> &extensions,
-                                            bool recursive, const std::vector<std::string> &absoluteIgnorePatterns,
+                                            WorkerPool &workerPool, bool recursive,
+                                            const std::vector<std::string> &absoluteIgnorePatterns,
                                             const std::vector<std::string> &relativeIgnorePatterns) const {
-    return FileOps::listFilesInDir(path, extensions, recursive, absoluteIgnorePatterns, relativeIgnorePatterns);
+    return FileOps::listFilesInDir(path, extensions, workerPool, recursive, absoluteIgnorePatterns,
+                                   relativeIgnorePatterns);
 }
 
 } // namespace sorbet

common/FileSystem.h

@@ -2,6 +2,8 @@
 #define COMMON_FILESYSTEM_H
 
 #include "common/common.h"
+#include "common/concurrency/WorkerPool.h"
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -16,10 +18,10 @@ class FileSystem {
     virtual ~FileSystem() = default;
 
     /** Read the file at the given path. Throws a `FileNotFoundException` if not found. */
-    virtual std::string readFile(std::string_view path) const = 0;
+    virtual std::string readFile(const std::string &path) const = 0;
 
     /** Writes the specified data to the given file. */
-    virtual void writeFile(std::string_view filename, std::string_view text) = 0;
+    virtual void writeFile(const std::string &filename, std::string_view text) = 0;
 
     /** Gets the path for the current directory. */
     virtual std::string getCurrentDir() const = 0;
@@ -34,9 +36,14 @@ class FileSystem {
      * Throws FileNotFoundException if path does not exist, and FileNotDirException if path is not a directory.
      */
     virtual std::vector<std::string> listFilesInDir(std::string_view path, const UnorderedSet<std::string> &extensions,
-                                                    bool recursive,
+                                                    WorkerPool &workerPool, bool recursive,
                                                     const std::vector<std::string> &absoluteIgnorePatterns,
                                                     const std::vector<std::string> &relativeIgnorePatterns) const = 0;
+
+    virtual std::vector<std::string> listFilesInDir(std::string_view path, const UnorderedSet<std::string> &extensions,
+                                                    bool recursive,
+                                                    const std::vector<std::string> &absoluteIgnorePatterns,
+                                                    const std::vector<std::string> &relativeIgnorePatterns) const;
 };
 
 /**
@@ -46,14 +53,15 @@ class OSFileSystem final : public FileSystem {
 public:
     OSFileSystem() = default;
 
-    std::string readFile(std::string_view path) const override;
-    void writeFile(std::string_view filename, std::string_view text) override;
+    std::string readFile(const std::string &path) const override;
+    void writeFile(const std::string &filename, std::string_view text) override;
     std::string getCurrentDir() const override;
     std::vector<std::string> listFilesInDir(std::string_view path, const UnorderedSet<std::string> &extensions,
-                                            bool recursive, const std::vector<std::string> &absoluteIgnorePatterns,
+                                            WorkerPool &workerPool, bool recursive,
+                                            const std::vector<std::string> &absoluteIgnorePatterns,
                                             const std::vector<std::string> &relativeIgnorePatterns) const override;
 };
 
 } // namespace sorbet
 
-#endif // COMMON_FILESYSTEM_H
+#endif // COMMON_FILESYSTEM_H