fix: Add support for unresolved fields from mixins

scip_indexer/BUILD

@@ -30,6 +30,8 @@ cc_library(
     srcs = [
         "Debug.cc",
         "Debug.h",
+        "SCIPFieldResolve.cc",
+        "SCIPFieldResolve.h",
         "SCIPIndexer.cc",
         "SCIPProtoExt.cc",
         "SCIPProtoExt.h",

scip_indexer/Debug.h

@@ -42,7 +42,7 @@ template <typename T, typename Fn> std::string showSet(const sorbet::UnorderedSe
     return out.str();
 }
 
-template <typename T, typename Fn> std::string showVec(const std::vector<T> &v, Fn f) {
+template <typename V, typename Fn> std::string showVec(const V &v, Fn f) {
     std::ostringstream out;
     out << "[";
     for (auto i = 0; i < v.size(); ++i) {

scip_indexer/SCIPFieldResolve.cc

@@ -0,0 +1,137 @@
+#include <vector>
+
+#include "absl/strings/ascii.h"
+
+#include "common/common.h"
+#include "core/GlobalState.h"
+#include "core/SymbolRef.h"
+#include "core/Symbols.h"
+
+#include "scip_indexer/Debug.h"
+#include "scip_indexer/SCIPFieldResolve.h"
+
+using namespace std;
+
+namespace sorbet::scip_indexer {
+
+string FieldQueryResult::showRaw(const core::GlobalState &gs) const {
+    if (this->mixedIn->empty()) {
+        return fmt::format("FieldQueryResult(inherited: {})", this->inherited.showFullName(gs));
+    }
+    return fmt::format(
+        "FieldQueryResult(inherited: {}, mixins: {})", this->inherited.showFullName(gs),
+        showVec(*this->mixedIn.get(), [&gs](const auto &mixin) -> string { return mixin.showFullName(gs); }));
+}
+
+void FieldResolver::resetMixins() {
+    this->mixinQueue.clear();
+}
+
+// Compute all transitively included modules which mention the field being queried.
+//
+// If an include chain for a field looks like class C.@f <- module M2.@f <- module M1.@f,
+// both M1 and M2 will be included in the results (this avoids any kind of postprocessing
+// of a transitive closure of relationships at the cost of a larger index).
+void FieldResolver::findUnresolvedFieldInMixinsTransitive(const core::GlobalState &gs, FieldQuery query,
+                                                          vector<core::ClassOrModuleRef> &out) {
+    this->mixinQueue.clear();
+    for (auto mixin : query.start.data(gs)->mixins()) {
+        this->mixinQueue.push_back(mixin);
+    }
+    auto field = query.field;
+    while (auto m = this->mixinQueue.try_pop_front()) {
+        auto mixin = m.value();
+        auto sym = mixin.data(gs)->findMember(gs, field);
+        if (sym.exists()) {
+            out.push_back(mixin);
+            continue;
+        }
+        auto it = gs.unresolvedFields.find(mixin);
+        if (it != gs.unresolvedFields.end() && it->second.contains(field)) {
+            out.push_back(mixin);
+        }
+    }
+}
+
+core::ClassOrModuleRef FieldResolver::normalizeParentForClassVar(const core::GlobalState &gs,
+                                                                 core::ClassOrModuleRef klass, std::string_view name) {
+    auto isClassVar = name.size() >= 2 && name[0] == '@' && name[1] == '@';
+    if (isClassVar && !klass.data(gs)->isSingletonClass(gs)) {
+        // Triggered when undeclared class variables are accessed from instance methods.
+        return klass.data(gs)->lookupSingletonClass(gs);
+    }
+    return klass;
+}
+
+core::ClassOrModuleRef FieldResolver::findUnresolvedFieldInInheritanceChain(const core::GlobalState &gs,
+                                                                            FieldQuery query, core::Loc debugLoc) {
+    auto start = query.start;
+    auto field = query.field;
+
+    auto fieldText = query.field.shortName(gs);
+    auto isInstanceVar = fieldText.size() >= 2 && fieldText[0] == '@' && fieldText[1] != '@';
+    auto isClassInstanceVar = isInstanceVar && start.data(gs)->isSingletonClass(gs);
+    // Class instance variables are not inherited, unlike ordinary instance
+    // variables or class variables.
+    if (isClassInstanceVar) {
+        return start;
+    }
+    start = FieldResolver::normalizeParentForClassVar(gs, start, fieldText);
+
+    if (gs.unresolvedFields.find(start) == gs.unresolvedFields.end() ||
+        !gs.unresolvedFields.find(start)->second.contains(field)) {
+        // Triggered by code patterns like:
+        //   # top-level
+        //   def MyClass.method
+        //     # blah
+        //   end
+        // which is not supported by Sorbet.
+        LOG_DEBUG(gs, debugLoc,
+                  fmt::format("couldn't find field {} in class {};\n"
+                              "are you using a code pattern like def MyClass.method which is unsupported by Sorbet?",
+                              field.exists() ? field.toString(gs) : "<non-existent>",
+                              start.exists() ? start.showFullName(gs) : "<non-existent>"));
+        // As a best-effort guess, assume that the definition is
+        // in this class but we somehow missed it.
+        return start;
+    }
+
+    auto best = start;
+    auto cur = start;
+    while (cur.exists()) {
+        auto klass = cur.data(gs);
+        auto sym = klass->findMember(gs, field);
+        if (sym.exists()) { // TODO(varun): Is this early exit justified?
+                            // Maybe it is possible to hit this in multiple ancestors?
+            return cur;
+        }
+        auto it = gs.unresolvedFields.find(cur);
+        if (it != gs.unresolvedFields.end() && it->second.contains(field)) {
+            best = cur;
+        }
+
+        if (cur == klass->superClass()) {
+            break;
+        }
+        cur = klass->superClass();
+    }
+    return best;
+}
+
+FieldQueryResult FieldResolver::findUnresolvedFieldTransitive(const core::GlobalState &gs, FieldQuery query,
+                                                              core::Loc debugLoc) {
+    ENFORCE(query.field.exists());
+    auto cacheIt = this->cache.find(query);
+    if (cacheIt != this->cache.end()) {
+        return cacheIt->second;
+    }
+    auto inherited = this->findUnresolvedFieldInInheritanceChain(gs, query, debugLoc);
+    vector<core::ClassOrModuleRef> mixins;
+    findUnresolvedFieldInMixinsTransitive(gs, query, mixins);
+    auto [it, inserted] =
+        this->cache.insert({query, FieldQueryResult{inherited, make_shared<decltype(mixins)>(move(mixins))}});
+    ENFORCE(inserted);
+    return it->second;
+}
+
+} // namespace sorbet::scip_indexer

scip_indexer/SCIPFieldResolve.h

@@ -0,0 +1,87 @@
+
+#ifndef SORBET_SCIP_FIELD_RESOLVE
+#define SORBET_SCIP_FIELD_RESOLVE
+
+#include <memory>
+#include <optional>
+#include <vector>
+
+#include "core/FileRef.h"
+#include "core/NameRef.h"
+#include "core/SymbolRef.h"
+
+namespace sorbet::scip_indexer {
+
+struct FieldQuery final {
+    core::FileRef file;
+    sorbet::core::ClassOrModuleRef start;
+    sorbet::core::NameRef field;
+
+    bool operator==(const FieldQuery &other) const noexcept {
+        return this->file == other.file && this->start == other.start && this->field == other.field;
+    }
+};
+
+template <typename H> H AbslHashValue(H h, const FieldQuery &q) {
+    return H::combine(std::move(h), q.file, q.start, q.field);
+}
+
+struct FieldQueryResult final {
+    core::ClassOrModuleRef inherited;
+    std::shared_ptr<std::vector<core::ClassOrModuleRef>> mixedIn;
+
+    std::string showRaw(const core::GlobalState &gs) const;
+};
+
+// Non-shrinking queue for cheap-to-copy types.
+template <typename T> class BasicQueue final {
+    std::vector<T> storage;
+    size_t current;
+
+public:
+    BasicQueue() = default;
+    BasicQueue(BasicQueue &&) = default;
+    BasicQueue &operator=(BasicQueue &&) = default;
+    BasicQueue(const BasicQueue &) = delete;
+    BasicQueue &operator=(const BasicQueue &) = delete;
+
+    void clear() {
+        this->storage.clear();
+        this->current = 0;
+    }
+    void push_back(T val) {
+        this->storage.push_back(val);
+    }
+    std::optional<T> try_pop_front() {
+        if (this->current >= this->storage.size()) {
+            return {};
+        }
+        auto ret = this->storage[this->current];
+        this->current++;
+        return ret;
+    }
+};
+
+class FieldResolver final {
+    sorbet::UnorderedMap<FieldQuery, FieldQueryResult> cache;
+    BasicQueue<sorbet::core::ClassOrModuleRef> mixinQueue;
+
+public:
+    FieldQueryResult findUnresolvedFieldTransitive(const core::GlobalState &gs, FieldQuery query, core::Loc debugLoc);
+
+    static core::ClassOrModuleRef normalizeParentForClassVar(const core::GlobalState &gs, core::ClassOrModuleRef klass,
+                                                             std::string_view name);
+
+private:
+    void resetMixins();
+
+    void findUnresolvedFieldInMixinsTransitive(const sorbet::core::GlobalState &gs, FieldQuery query,
+                                               std::vector<core::ClassOrModuleRef> &out);
+
+    core::ClassOrModuleRef findUnresolvedFieldInInheritanceChain(const core::GlobalState &gs, FieldQuery query,
+                                                                 core::Loc debugLoc);
+};
+
+} // namespace sorbet::scip_indexer
+
+#endif // SORBET_SCIP_FIELD_RESOLVE