[lldb][lldb-dap] Migrate 'Scopes' to structured types.

Author: da-viper

lldb/tools/lldb-dap/Handler/RequestHandler.h

@@ -423,6 +423,17 @@ class PauseRequestHandler : public LegacyRequestHandler {
   void operator()(const llvm::json::Object &request) const override;
 };
 
+class ScopesRequestHandler2 final
+    : public RequestHandler<protocol::ScopesArguments,
+                            llvm::Expected<protocol::ScopesResponseBody>> {
+public:
+  using RequestHandler::RequestHandler;
+  static llvm::StringLiteral GetCommand() { return "scopes"; }
+
+  llvm::Expected<protocol::ScopesResponseBody>
+  Run(const protocol::ScopesArguments &args) const override;
+};
+
 class ScopesRequestHandler : public LegacyRequestHandler {
 public:
   using LegacyRequestHandler::LegacyRequestHandler;

lldb/tools/lldb-dap/Handler/ScopesRequestHandler.cpp

@@ -64,6 +64,12 @@ namespace lldb_dap {
 //     "required": [ "body" ]
 //   }]
 // }
+
+llvm::Expected<protocol::ScopesResponseBody>
+ScopesRequestHandler2::Run(const protocol::ScopesArguments &args) const {
+  // lldb::SBFrame frame = dap.GetLLDBFrame()
+  return llvm::createStringError("something");
+};
 void ScopesRequestHandler::operator()(const llvm::json::Object &request) const {
   llvm::json::Object response;
   FillResponse(request, response);

lldb/tools/lldb-dap/Protocol/ProtocolRequests.cpp

@@ -260,6 +260,19 @@ bool fromJSON(const json::Value &Params, LaunchRequestArguments &LRA,
          O.mapOptional("runInTerminal", LRA.runInTerminal) &&
          parseEnv(Params, LRA.env, P) && parseTimeout(Params, LRA.timeout, P);
 }
+bool fromJSON(const llvm::json::Value &Params, ScopesArguments &SCA,
+              llvm::json::Path P) {
+  json::ObjectMapper O(Params, P);
+  return O && O.map("frameId", SCA.frameId);
+}
+
+llvm::json::Value toJSON(const ScopesResponseBody &SCR) {
+  llvm::json::Array body;
+  for (const Scope &scope : SCR.scopes) {
+    body.emplace_back(toJSON(scope));
+  }
+  return body;
+}
 
 bool fromJSON(const json::Value &Params, SourceArguments &SA, json::Path P) {
   json::ObjectMapper O(Params, P);

lldb/tools/lldb-dap/Protocol/ProtocolRequests.h

@@ -294,6 +294,19 @@ bool fromJSON(const llvm::json::Value &, LaunchRequestArguments &,
 /// field is required.
 using LaunchResponseBody = VoidResponse;
 
+struct ScopesArguments {
+  /// Retrieve the scopes for the stack frame identified by `frameId`. The
+  /// `frameId` must have been obtained in the current suspended state. See
+  /// 'Lifetime of Object References' in the Overview section for details.
+  uint64_t frameId;
+};
+bool fromJSON(const llvm::json::Value &, ScopesArguments &, llvm::json::Path);
+
+struct ScopesResponseBody {
+  std::vector<Scope> scopes;
+};
+llvm::json::Value toJSON(const ScopesResponseBody &);
+
 /// Arguments for `source` request.
 struct SourceArguments {
   /// Specifies the source content to load. Either `source.path` or

lldb/tools/lldb-dap/Protocol/ProtocolTypes.cpp

@@ -16,17 +16,18 @@ using namespace llvm;
 
 namespace lldb_dap::protocol {
 
-bool fromJSON(const json::Value &Params, PresentationHint &PH, json::Path P) {
+bool fromJSON(const json::Value &Params, Source::PresentationHint &PH,
+              json::Path P) {
   auto rawHint = Params.getAsString();
   if (!rawHint) {
     P.report("expected a string");
     return false;
   }
-  std::optional<PresentationHint> hint =
-      StringSwitch<std::optional<PresentationHint>>(*rawHint)
-          .Case("normal", ePresentationHintNormal)
-          .Case("emphasize", ePresentationHintEmphasize)
-          .Case("deemphasize", ePresentationHintDeemphasize)
+  std::optional<Source::PresentationHint> hint =
+      StringSwitch<std::optional<Source::PresentationHint>>(*rawHint)
+          .Case("normal", Source::ePresentationHintNormal)
+          .Case("emphasize", Source::ePresentationHintEmphasize)
+          .Case("deemphasize", Source::ePresentationHintDeemphasize)
           .Default(std::nullopt);
   if (!hint) {
     P.report("unexpected value");
@@ -36,12 +37,38 @@ bool fromJSON(const json::Value &Params, PresentationHint &PH, json::Path P) {
   return true;
 }
 
+llvm::json::Value toJSON(const Source::PresentationHint &PH) {
+  switch (PH) {
+  case Source::ePresentationHintNormal:
+    return "normal";
+  case Source ::ePresentationHintEmphasize:
+    return "emphasize";
+  case Source::ePresentationHintDeemphasize:
+    return "deemphasize";
+  }
+  llvm_unreachable("Fully covered switch above");
+}
+
 bool fromJSON(const json::Value &Params, Source &S, json::Path P) {
   json::ObjectMapper O(Params, P);
   return O && O.map("name", S.name) && O.map("path", S.path) &&
          O.map("presentationHint", S.presentationHint) &&
          O.map("sourceReference", S.sourceReference);
 }
+llvm::json::Value toJSON(const Source &S) {
+  json::Object result;
+
+  if (S.name.has_value())
+    result.insert({"name", S.name});
+  if (S.path.has_value())
+    result.insert({"path", S.path});
+  if (S.sourceReference.has_value())
+    result.insert({"sourceReference", S.sourceReference});
+  if (S.presentationHint.has_value())
+    result.insert({"presentationHint", S.presentationHint});
+
+  return result;
+}
 
 json::Value toJSON(const ExceptionBreakpointsFilter &EBF) {
   json::Object result{{"filter", EBF.filter}, {"label", EBF.label}};
@@ -233,6 +260,55 @@ json::Value toJSON(const Capabilities &C) {
   return result;
 }
 
+llvm::json::Value toJSON(const Scope &SC) {
+  llvm::json::Object result{{"name", SC.name},
+                            {"variablesReference", SC.variablesReference},
+                            {"expensive", SC.expensive}};
+
+  if (SC.presentationHint.has_value()) {
+    llvm::StringRef presentationHint;
+    switch (*SC.presentationHint) {
+    case Scope::ePresentationHintArguments:
+      presentationHint = "arguments";
+      break;
+    case Scope::ePresentationHintLocals:
+      presentationHint = "locals";
+      break;
+    case Scope::ePresentationHintRegisters:
+      presentationHint = "registers";
+      break;
+    case Scope::ePresentationHintReturnValue:
+      presentationHint = "returnValue";
+      break;
+    }
+
+    result.insert({"presentationHint", presentationHint});
+  }
+
+  if (SC.namedVariables.has_value())
+    result.insert({"namedVariables", SC.namedVariables});
+
+  if (SC.indexedVariables.has_value())
+    result.insert({"indexedVariables", SC.indexedVariables});
+
+  if (SC.source.has_value())
+    result.insert({"source", SC.source});
+
+  if (SC.line.has_value())
+    result.insert({"line", SC.line});
+
+  if (SC.column.has_value())
+    result.insert({"column", SC.column});
+
+  if (SC.endLine.has_value())
+    result.insert({"endLine", SC.endLine});
+
+  if (SC.endColumn.has_value())
+    result.insert({"endColumn", SC.endColumn});
+
+  return result;
+}
+
 bool fromJSON(const llvm::json::Value &Params, SteppingGranularity &SG,
               llvm::json::Path P) {
   auto raw_granularity = Params.getAsString();

lldb/tools/lldb-dap/Protocol/ProtocolTypes.h

@@ -23,6 +23,7 @@
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Support/JSON.h"
 #include <cstdint>
+#include <lldb/lldb-enumerations.h>
 #include <optional>
 #include <string>
 
@@ -268,16 +269,15 @@ struct Capabilities {
 };
 llvm::json::Value toJSON(const Capabilities &);
 
-enum PresentationHint : unsigned {
-  ePresentationHintNormal,
-  ePresentationHintEmphasize,
-  ePresentationHintDeemphasize,
-};
-
 /// A `Source` is a descriptor for source code. It is returned from the debug
 /// adapter as part of a `StackFrame` and it is used by clients when specifying
 /// breakpoints.
 struct Source {
+  enum PresentationHint : unsigned {
+    ePresentationHintNormal,
+    ePresentationHintEmphasize,
+    ePresentationHintDeemphasize,
+  };
   /// The short name of the source. Every source returned from the debug adapter
   /// has a name. When sending a source to the debug adapter this name is
   /// optional.
@@ -302,6 +302,74 @@ struct Source {
   // unsupported keys: origin, sources, adapterData, checksums
 };
 bool fromJSON(const llvm::json::Value &, Source &, llvm::json::Path);
+llvm::json::Value toJSON(const Source &);
+
+/// A `Scope` is a named container for variables. Optionally a scope can map to
+/// a source or a range within a source.
+struct Scope {
+  enum PresentationHint : unsigned {
+    ePresentationHintArguments,
+    ePresentationHintLocals,
+    ePresentationHintRegisters,
+    ePresentationHintReturnValue
+  };
+  /// Name of the scope such as 'Arguments', 'Locals', or 'Registers'. This
+  /// string is shown in the UI as is and can be translated.
+  ////
+  std::string name;
+
+  /// A hint for how to present this scope in the UI. If this attribute is
+  /// missing, the scope is shown with a generic UI.
+  /// Values:
+  /// 'arguments': Scope contains method arguments.
+  /// 'locals': Scope contains local variables.
+  /// 'registers': Scope contains registers. Only a single `registers` scope
+  /// should be returned from a `scopes` request.
+  /// 'returnValue': Scope contains one or more return values.
+  /// etc.
+  std::optional<PresentationHint> presentationHint;
+
+  /// The variables of this scope can be retrieved by passing the value of
+  /// `variablesReference` to the `variables` request as long as execution
+  /// remains suspended. See 'Lifetime of Object References' in the Overview
+  /// section for details.
+  ////
+  uint64_t variablesReference;
+
+  /// The number of named variables in this scope.
+  /// The client can use this information to present the variables in a paged UI
+  /// and fetch them in chunks.
+  std::optional<uint64_t> namedVariables;
+
+  /// The number of indexed variables in this scope.
+  /// The client can use this information to present the variables in a paged UI
+  /// and fetch them in chunks.
+  std::optional<uint64_t> indexedVariables;
+
+  /// The source for this scope.
+  std::optional<Source> source;
+
+  /// If true, the number of variables in this scope is large or expensive to
+  /// retrieve.
+  bool expensive;
+
+  /// The start line of the range covered by this scope.
+  std::optional<uint64_t> line;
+
+  /// Start position of the range covered by the scope. It is measured in UTF-16
+  /// code units and the client capability `columnsStartAt1` determines whether
+  /// it is 0- or 1-based.
+  std::optional<uint64_t> column;
+
+  /// The end line of the range covered by this scope.
+  std::optional<uint64_t> endLine;
+
+  /// End position of the range covered by the scope. It is measured in UTF-16
+  /// code units and the client capability `columnsStartAt1` determines whether
+  /// it is 0- or 1-based.
+  std::optional<uint64_t> endColumn;
+};
+llvm::json::Value toJSON(const Scope &);
 
 /// The granularity of one `step` in the stepping requests `next`, `stepIn`,
 /// `stepOut` and `stepBack`.