[circt-verilog-lsp] Add -C option command files, gotoDefinition

This patch adds **"textDocument/definition"** support to the Verilog LSP server using Slang.
Currently only project-level module definition lookups work, but helpers are provided to add
buffer-local lookups as well.

- **New `SlangProjectLookup`**
  - Map LSP positions => Slang `SourceLocation`
  - Walk syntax tree to find the smallest node
  - Resolve definitions via `Compilation::tryFindDefinitionAt`

- **Server integration**
  - Advertise `"definitionProvider": true`
  - Handle `"textDocument/definition"` requests
  - Return single `Location` or `null`

- **Command file support**
  - Add `-C/--commandFiles` option
  - Preload command files into per-buffer drivers

- **Other changes**
  - Absolute path normalization for URIs and command files
  - New `getDefinitionAt` in `VerilogDocument`
  - `VerilogServer::findDefinition` API

Author: Scheremo

include/circt/Tools/circt-verilog-lsp-server/CirctVerilogLspServerMain.h

@@ -34,10 +34,11 @@ class JSONTransport;
 namespace circt {
 namespace lsp {
 struct VerilogServerOptions {
-  VerilogServerOptions(const std::vector<std::string> &libDirs)
-      : libDirs(libDirs) {}
-  /// Additional list of RTL directories to search.
+  VerilogServerOptions(const std::vector<std::string> &libDirs,
+                       std::vector<std::string> &commandFiles)
+      : libDirs(libDirs), commandFiles(commandFiles) {}
   const std::vector<std::string> &libDirs;
+  const std::vector<std::string> &commandFiles;
 };
 // namespace lsp
 

lib/Tools/circt-verilog-lsp-server/LSPServer.cpp

@@ -8,6 +8,7 @@
 
 #include "LSPServer.h"
 #include "VerilogServerImpl/VerilogServer.h"
+#include "llvm/Support/JSON.h"
 #include "llvm/Support/LSP/Protocol.h"
 #include "llvm/Support/LSP/Transport.h"
 #include <optional>
@@ -43,6 +44,13 @@ struct LSPServer {
   void onDocumentDidClose(const DidCloseTextDocumentParams &params);
   void onDocumentDidChange(const DidChangeTextDocumentParams &params);
 
+  //===--------------------------------------------------------------------===//
+  // Definition
+  //===--------------------------------------------------------------------===//
+
+  void onDocumentDefinition(const TextDocumentPositionParams &params,
+                            Callback<llvm::json::Value> reply);
+
   //===--------------------------------------------------------------------===//
   // Fields
   //===--------------------------------------------------------------------===//
@@ -73,7 +81,8 @@ void LSPServer::onInitialize(const InitializeParams &params,
            {"openClose", true},
            {"change", (int)TextDocumentSyncKind::Incremental},
            {"save", true},
-       }}};
+       }},
+      {"definitionProvider", true}};
 
   json::Object result{
       {{"serverInfo", json::Object{{"name", "circt-verilog-lsp-server"},
@@ -124,6 +133,21 @@ void LSPServer::onDocumentDidChange(const DidChangeTextDocumentParams &params) {
   publishDiagnostics(diagParams);
 }
 
+//===----------------------------------------------------------------------===//
+// Definition
+//===----------------------------------------------------------------------===//
+
+void LSPServer::onDocumentDefinition(
+    const llvm::lsp::TextDocumentPositionParams &params,
+    Callback<llvm::json::Value> reply) {
+  auto loc = server.findDefinition(params.textDocument.uri, params.position);
+  if (loc) {
+    reply(*loc); // return a single Location
+  } else {
+    reply(llvm::json::Value(nullptr));
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // Entry Point
 //===----------------------------------------------------------------------===//
@@ -147,6 +171,10 @@ LogicalResult circt::lsp::runVerilogLSPServer(VerilogServer &server,
   messageHandler.notification("textDocument/didChange", &lspServer,
                               &LSPServer::onDocumentDidChange);
 
+  // Definition
+  messageHandler.method("textDocument/definition", &lspServer,
+                        &LSPServer::onDocumentDefinition);
+
   // Diagnostics
   lspServer.publishDiagnostics =
       messageHandler.outgoingNotification<PublishDiagnosticsParams>(

lib/Tools/circt-verilog-lsp-server/VerilogServerImpl/CMakeLists.txt

@@ -2,6 +2,7 @@
 include(SlangCompilerOptions)
 
 add_circt_library(CIRCTVerilogLspServerImpl
+  SlangProjectLookup.cpp
   VerilogServer.cpp
 
   ADDITIONAL_HEADER_DIRS

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

@@ -0,0 +1,266 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the SlangProjectLookup class, which is responsible
+// for trying to resolve definitions within one compile unit, as specified
+// by the `-C` argument.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SlangProjectLookup.h"
+
+#include "slang/ast/Compilation.h"
+#include "slang/ast/Lookup.h"
+#include "slang/ast/Scope.h"
+#include "slang/ast/Symbol.h"
+#include "slang/ast/Scope.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"
+
+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 &root, DefIndex &out) {
+  llvm::SmallVector<const slang::syntax::SyntaxNode *, 32> worklist;
+  worklist.push_back(&root);
+
+  while (!worklist.empty()) {
+    const slang::syntax::SyntaxNode *node = worklist.pop_back_val();
+
+    // Collect declarators at this node.
+    indexDeclarators(*node, out);
+
+    // Push children to the stack.
+    for (size_t i = 0, e = node->getChildCount(); i < e; ++i) {
+      if (auto *c = node->childNode(i))
+        worklist.push_back(c);
+    }
+  }
+}
+
+static bool isLocationInRange(slang::SourceRange r, slang::SourceLocation loc) {
+  if (!r.start() || !r.end())
+    return false;
+  auto o = loc.offset();
+  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, const 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;
+  const DefIndex &defIndex;
+};
+
+} // namespace
+
+slang::SourceLocation
+SlangProjectLookup::lspPositionToSlangLocation(slang::BufferID buf,
+                                               const llvm::lsp::Position &pos) {
+  std::string_view text = sourceManager.getSourceText(buf);
+  size_t line = (size_t)pos.line, col = (size_t)pos.character;
+
+  size_t off = 0;
+  for (size_t i = 0; i < line && off < text.size(); ++i) {
+    size_t nl = text.find('\n', off);
+    if (nl == std::string_view::npos) {
+      off = text.size();
+      break;
+    }
+    off = nl + 1;
+  }
+  size_t eol = text.find('\n', off);
+  if (eol == std::string_view::npos)
+    eol = text.size();
+  size_t len =
+      (eol > off && text[eol - 1] == '\r') ? (eol - off - 1) : (eol - off);
+  if (col > len)
+    col = len;
+  return slang::SourceLocation(buf, off + col);
+}
+
+const SyntaxNode *
+SlangProjectLookup::findSmallestNodeAt(const SyntaxNode &root,
+                                       slang::SourceLocation loc) {
+
+  if (!isLocationInRange(root.sourceRange(), loc))
+    return nullptr;
+
+  const SyntaxNode *cur = &root;
+
+  while (true) {
+    const SyntaxNode *bestChild = nullptr;
+    uint32_t bestSpan = std::numeric_limits<uint32_t>::max();
+
+    // Scan all children; pick the *tightest* range that still contains 'loc'.
+    for (size_t i = 0, e = cur->getChildCount(); i < e; ++i) {
+      const SyntaxNode *ch = cur->childNode(i);
+      if (!ch)
+        continue;
+
+      auto r = ch->sourceRange();
+      if (!r.start() || !r.end())
+        continue;
+      if (!isLocationInRange(r, loc))
+        continue;
+
+      uint32_t span = r.end().offset() - r.start().offset();
+      if (span < bestSpan) {
+        bestSpan = span;
+        bestChild = ch;
+      }
+    }
+
+    if (!bestChild)
+      return cur; // no deeper child contains 'loc' => 'cur' is the smallest
+
+    cur = bestChild;
+  }
+}
+
+llvm::FailureOr<const SyntaxNode *>
+SlangProjectLookup::getSyntaxNodeAt(slang::BufferID mainBufferId,
+                                    slang::SourceLocation loc) {
+
+  // Find the syntax tree that owns this buffer.
+  const SyntaxTree *tree = nullptr;
+  for (const auto &t : compilation.getSyntaxTrees()) {
+    auto r = t->root().sourceRange();
+    if (r.start().buffer() == mainBufferId) {
+      tree = t.get();
+      break;
+    }
+  }
+
+  if (!tree)
+    return llvm::failure();
+
+  const auto &root = tree->root();
+  // Climb down the tree to get the smallest node matching our location
+  return findSmallestNodeAt(root, loc);
+}
+
+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, 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) {
+    if (auto hit = p->visit(v))
+      return *hit;
+  }
+
+  // Don't really know what this node is :/
+  return llvm::failure();
+}