Add simple indexer

Author: Moritz Scherer

lib/Tools/circt-verilog-lsp-server/VerilogServerImpl/SlangProjectLookup.cpp

@@ -18,17 +18,55 @@
 #include "slang/ast/Lookup.h"
 #include "slang/ast/Scope.h"
 #include "slang/ast/Symbol.h"
+#include "slang/ast/symbols/CompilationUnitSymbols.h"
 #include "slang/diagnostics/Diagnostics.h"
 #include "slang/syntax/AllSyntax.h"
+#include "slang/syntax/SyntaxFacts.h"
 #include "slang/syntax/SyntaxKind.h"
+#include "slang/syntax/SyntaxNode.h"
 #include "slang/syntax/SyntaxTree.h"
 #include "slang/syntax/SyntaxVisitor.h"
 #include "slang/text/SourceLocation.h"
 #include "slang/text/SourceManager.h"
 #include "llvm/Support/LSP/Protocol.h"
-#include "llvm/Support/SourceMgr.h"
 
+using namespace slang;
 using namespace slang::syntax;
+using namespace slang::ast;
+
+struct DefIndex {
+  // For now: name -> location (first hit wins). Upgrade to multimap if needed.
+  std::unordered_map<std::string, slang::SourceLocation> byName;
+};
+
+
+static void indexDeclarators(const slang::syntax::SyntaxNode &node,
+                             DefIndex &out) {
+  using namespace slang::syntax;
+
+  switch (node.kind) {
+  case SyntaxKind::Declarator:
+    if (auto *decl = node.as_if<DeclaratorSyntax>()) {
+      auto nameText = decl->name.valueText(); // strips trivia
+      auto loc = decl->name.location();
+      if (!nameText.empty() && loc)
+        out.byName.emplace(std::string(nameText), loc);
+    }
+    break;
+  default:
+    break;
+  }
+}
+
+/// Walk the syntax tree from its root down to collect all declarators;
+/// declarators contain symbol definitions we can lookup later.
+static void walk(const slang::syntax::SyntaxNode &node, DefIndex &out) {
+  indexDeclarators(node, out);
+
+  for (size_t i = 0, e = node.getChildCount(); i < e; ++i)
+    if (auto *c = node.childNode(i))
+      walk(*c, out);
+}
 
 static bool isLocationInRange(slang::SourceRange r, slang::SourceLocation loc) {
   if (!r.start() || !r.end())
@@ -37,6 +75,65 @@ static bool isLocationInRange(slang::SourceRange r, slang::SourceLocation loc) {
   return r.start().offset() <= o && o < r.end().offset();
 }
 
+namespace {
+/// Visitor that tries to produce a definition `SourceLocation` for a node.
+struct DefinitionVisitor : public slang::syntax::SyntaxVisitor<
+                               std::optional<slang::SourceLocation>> {
+  using Base = SyntaxVisitor<std::optional<slang::SourceLocation>>;
+  using Base::visit;
+
+  DefinitionVisitor(const slang::ast::Compilation &comp,
+                    const slang::ast::Scope &rootScope,
+                    slang::SourceLocation queryLoc, DefIndex &defIndex)
+      : comp(comp), rootScope(rootScope), queryLoc(queryLoc),
+        defIndex(defIndex) {}
+
+  // Hierarchy instantiation -> resolve the *type* globally.
+  std::optional<slang::SourceLocation>
+  visit(const HierarchyInstantiationSyntax &n) {
+    auto res = comp.tryGetDefinition(n.type.valueText(), rootScope);
+    if (res.definition)
+      return res.definition->location;
+    return std::nullopt;
+  }
+
+  // Declaration name (e.g., "logic x;") — treat cursor as the def.
+  std::optional<slang::SourceLocation> visit(const DeclaratorSyntax &) {
+    return queryLoc;
+  }
+
+  // Module header (cursor on module name) — treat cursor as the def.
+  std::optional<slang::SourceLocation> visit(const ModuleHeaderSyntax &) {
+    return queryLoc;
+  }
+
+  // Instance name (u0) — TODO (not implemented).
+  std::optional<slang::SourceLocation> visit(const InstanceNameSyntax &) {
+    return std::nullopt;
+  }
+
+  // Generic name — TODO: local scope lookup.
+  std::optional<slang::SourceLocation> visit(const IdentifierNameSyntax &node) {
+    auto it = defIndex.byName.find(std::string(node.identifier.valueText()));
+    if (it == defIndex.byName.end())
+      return std::nullopt;
+    return it->second;
+  }
+
+  // Fallback for all other node kinds.
+  template <typename T>
+  std::optional<slang::SourceLocation> visit(const T &) {
+    return std::nullopt;
+  }
+
+  const slang::ast::Compilation &comp;
+  const slang::ast::Scope &rootScope;
+  slang::SourceLocation queryLoc;
+  DefIndex &defIndex;
+};
+
+} // namespace
+
 slang::SourceLocation
 SlangProjectLookup::lspPositionToSlangLocation(slang::BufferID buf,
                                                const llvm::lsp::Position &pos) {
@@ -123,79 +220,33 @@ SlangProjectLookup::getSyntaxNodeAt(slang::BufferID mainBufferId,
   return findSmallestNodeAt(root, loc);
 }
 
-namespace {
-/// Visitor that tries to produce a definition `SourceLocation` for a node.
-struct DefinitionVisitor
-  : public slang::syntax::SyntaxVisitor<std::optional<slang::SourceLocation>> {
-  using Base = SyntaxVisitor<std::optional<slang::SourceLocation>>;
-  using Base::visit;
-
-  DefinitionVisitor(const slang::ast::Compilation &comp, const slang::ast::Scope &rootScope,
-                    slang::SourceLocation queryLoc)
-      : comp(comp), rootScope(rootScope), queryLoc(queryLoc) {}
-
-  // Hierarchy instantiation -> resolve the *type* globally.
-  std::optional<slang::SourceLocation>
-  visit(const HierarchyInstantiationSyntax &n) {
-    llvm::dbgs() << "valueText: " << n.type.valueText() << "\n";
-    auto res = comp.tryGetDefinition(n.type.valueText(), rootScope);
-    if (res.definition)
-      return res.definition->location;
-    return std::nullopt;
-  }
-
-  // Declaration name (e.g., "logic x;") — treat cursor as the def.
-  std::optional<slang::SourceLocation> visit(const DeclaratorSyntax &) {
-    return queryLoc;
-  }
-
-  // Module header (cursor on module name) — treat cursor as the def.
-  std::optional<slang::SourceLocation> visit(const ModuleHeaderSyntax &) {
-    return queryLoc;
-  }
-
-  // Instance name (u0) — TODO (not implemented).
-  std::optional<slang::SourceLocation> visit(const InstanceNameSyntax &) {
-    return std::nullopt;
-  }
-
-  // Generic name — TODO: local scope lookup.
-  std::optional<slang::SourceLocation> visit(const NameSyntax &) {
-    return std::nullopt;
-  }
-
-  // Fallback for all other node kinds.
-  template <typename T>
-  std::optional<slang::SourceLocation> visit(const T &) {
-    return std::nullopt;
-  }
-
-  const slang::ast::Compilation &comp;
-  const slang::ast::Scope &rootScope;
-  slang::SourceLocation queryLoc;
-};
-
-} // namespace
-
 llvm::FailureOr<const slang::SourceLocation>
 SlangProjectLookup::tryFindDefinitionAt(slang::BufferID mainBufferId,
                                         slang::SourceLocation loc) {
 
   const SyntaxNode *node;
   llvm::FailureOr<const SyntaxNode *> n = getSyntaxNodeAt(mainBufferId, loc);
+
   if (failed(n))
     return llvm::failure();
   node = n.value();
 
+  // Find the root (topmost) syntax node of this tree.
+  const SyntaxNode *root = node;
+  for (const SyntaxNode *cur = node; cur; cur = cur->parent)
+    root = cur; // root ends up as the last non-null
+
+  DefIndex d;
+  walk(*root, d);
 
-  DefinitionVisitor v{compilation, rootSymbol, loc};
+  DefinitionVisitor v{compilation, rootSymbol, loc, d};
 
   // Try at the node first…
   if (auto hit = node->visit(v))
     return *hit;
 
   // …then walk up parents to broaden the context.
-  for (const SyntaxNode* p = node->parent; p; p = p->parent) {
+  for (const SyntaxNode *p = node->parent; p; p = p->parent) {
     if (auto hit = p->visit(v))
       return *hit;
   }

lib/Tools/circt-verilog-lsp-server/VerilogServerImpl/SlangProjectLookup.h

@@ -11,7 +11,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Support/LSP/Logging.h"
 #include "llvm/Support/LSP/Protocol.h"
 
 namespace slang {
@@ -28,14 +27,17 @@ namespace ast {
 class Compilation;
 class Scope;
 } // namespace ast
+namespace analysis {
+class AnalyzedDesign;
+} // namespace analysis
 } // namespace slang
 
 /// A helper for translating between LLVM::LSP and Slang.
 struct SlangProjectLookup {
   SlangProjectLookup(const slang::ast::Compilation &compilation,
                      const slang::ast::Scope &rootSymbol,
                      const slang::SourceManager &sourceManager)
-      : compilation(compilation), rootSymbol(rootSymbol),
+    : compilation(compilation), rootSymbol(rootSymbol),
         sourceManager(sourceManager) {}
 
   /// Convert an LSP `Position` (line / character) into a Slang `SourceLocation`

lib/Tools/circt-verilog-lsp-server/VerilogServerImpl/VerilogServer.cpp

@@ -19,11 +19,9 @@
 #include "circt/Tools/circt-verilog-lsp-server/CirctVerilogLspServerMain.h"
 #include "slang/ast/Compilation.h"
 #include "slang/ast/Scope.h"
-#include "slang/ast/symbols/CompilationUnitSymbols.h"
 #include "slang/diagnostics/DiagnosticClient.h"
 #include "slang/diagnostics/Diagnostics.h"
 #include "slang/driver/Driver.h"
-#include "slang/syntax/AllSyntax.h"
 #include "slang/syntax/SyntaxTree.h"
 #include "slang/text/SourceLocation.h"
 #include "slang/text/SourceManager.h"
@@ -225,14 +223,14 @@ VerilogDocument::VerilogDocument(
 
   // --- Apply project command files (the “-C”s) to this per-buffer driver ---
   for (const std::string &cmdFile : context.getPreloadedCommandFiles()) {
-    if (!driver.processCommandFiles(cmdFile, true, true)) {
+    if (!driver.processCommandFiles(cmdFile, false, true)) {
       circt::lsp::Logger::error(Twine("Failed to open command file ") +
                                 cmdFile);
     }
   }
 
   driver.options.compilationFlags.emplace(
-      slang::ast::CompilationFlags::LintMode, false);
+                                          slang::ast::CompilationFlags::LintMode, false);
   driver.options.compilationFlags.emplace(
       slang::ast::CompilationFlags::DisableInstanceCaching, false);
 
@@ -296,7 +294,8 @@ VerilogDocument::getDefinitionAt(const llvm::lsp::Position &pos) {
   auto &comp = getSlangCompilation();
   const auto &sm = comp.getSourceManager();
 
-  SlangProjectLookup sl = SlangProjectLookup(comp, comp.getRoot(), *sm);
+  SlangProjectLookup sl =
+      SlangProjectLookup(comp, comp.getRootNoFinalize(), *sm);
   slang::SourceLocation loc = sl.lspPositionToSlangLocation(mainBufferId, pos);
 
   // Identify a name-like syntax under the cursor.