[lldb][lldb-dap] add review changes

Author: da-viper

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

@@ -41,9 +41,9 @@ static Scope CreateScope(const llvm::StringRef name, int64_t variablesReference,
   // as the locals scope will not be expanded. It becomes more annoying when
   // the scope has arguments, return_value and locals.
   if (variablesReference == VARREF_LOCALS)
-    scope.presentationHint = Scope::ePresentationHintLocals;
+    scope.presentationHint = Scope::eScopePresentationHintLocals;
   else if (variablesReference == VARREF_REGS)
-    scope.presentationHint = Scope::ePresentationHintRegisters;
+    scope.presentationHint = Scope::eScopePresentationHintRegisters;
 
   scope.variablesReference = variablesReference;
   scope.namedVariables = namedVariables;

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

@@ -25,9 +25,9 @@ bool fromJSON(const json::Value &Params, Source::PresentationHint &PH,
   }
   std::optional<Source::PresentationHint> hint =
       StringSwitch<std::optional<Source::PresentationHint>>(*rawHint)
-          .Case("normal", Source::ePresentationHintNormal)
-          .Case("emphasize", Source::ePresentationHintEmphasize)
-          .Case("deemphasize", Source::ePresentationHintDeemphasize)
+          .Case("normal", Source::eSourcePresentationHintNormal)
+          .Case("emphasize", Source::eSourcePresentationHintEmphasize)
+          .Case("deemphasize", Source::eSourcePresentationHintDeemphasize)
           .Default(std::nullopt);
   if (!hint) {
     P.report("unexpected value");
@@ -43,13 +43,14 @@ bool fromJSON(const json::Value &Params, Source &S, json::Path P) {
          O.map("presentationHint", S.presentationHint) &&
          O.map("sourceReference", S.sourceReference);
 }
+
 llvm::json::Value toJSON(Source::PresentationHint hint) {
   switch (hint) {
-  case Source::ePresentationHintNormal:
+  case Source::eSourcePresentationHintNormal:
     return "normal";
-  case Source::ePresentationHintEmphasize:
+  case Source::eSourcePresentationHintEmphasize:
     return "emphasize";
-  case Source::ePresentationHintDeemphasize:
+  case Source::eSourcePresentationHintDeemphasize:
     return "deemphasize";
   }
   llvm_unreachable("unhandled presentation hint.");
@@ -435,6 +436,41 @@ json::Value toJSON(const Capabilities &C) {
   return result;
 }
 
+bool fromJSON(const json::Value &Params, Scope::PresentationHint &PH,
+              json::Path P) {
+  auto rawHint = Params.getAsString();
+  if (!rawHint) {
+    P.report("expected a string");
+    return false;
+  }
+  const std::optional<Scope::PresentationHint> hint =
+      StringSwitch<std::optional<Scope::PresentationHint>>(*rawHint)
+          .Case("arguments", Scope::eScopePresentationHintArguments)
+          .Case("locals", Scope::eScopePresentationHintLocals)
+          .Case("registers", Scope::eScopePresentationHintRegisters)
+          .Case("returnValue", Scope::eScopePresentationHintReturnValue)
+          .Default(std::nullopt);
+  if (!hint) {
+    P.report("unexpected value");
+    return false;
+  }
+  PH = *hint;
+  return true;
+}
+
+bool fromJSON(const json::Value &Params, Scope &S, json::Path P) {
+  json::ObjectMapper O(Params, P);
+  return O && O.map("name", S.name) &&
+         O.mapOptional("presentationHint", S.presentationHint) &&
+         O.map("variablesReference", S.variablesReference) &&
+         O.mapOptional("namedVariables", S.namedVariables) &&
+         O.map("indexedVariables", S.indexedVariables) &&
+         O.mapOptional("source", S.source) && O.map("expensive", S.expensive) &&
+         O.mapOptional("line", S.line) && O.mapOptional("column", S.column) &&
+         O.mapOptional("endLine", S.endLine) &&
+         O.mapOptional("endColumn", S.endColumn);
+}
+
 llvm::json::Value toJSON(const Scope &SC) {
   llvm::json::Object result{{"name", SC.name},
                             {"variablesReference", SC.variablesReference},
@@ -443,16 +479,16 @@ llvm::json::Value toJSON(const Scope &SC) {
   if (SC.presentationHint.has_value()) {
     llvm::StringRef presentationHint;
     switch (*SC.presentationHint) {
-    case Scope::ePresentationHintArguments:
+    case Scope::eScopePresentationHintArguments:
       presentationHint = "arguments";
       break;
-    case Scope::ePresentationHintLocals:
+    case Scope::eScopePresentationHintLocals:
       presentationHint = "locals";
       break;
-    case Scope::ePresentationHintRegisters:
+    case Scope::eScopePresentationHintRegisters:
       presentationHint = "registers";
       break;
-    case Scope::ePresentationHintReturnValue:
+    case Scope::eScopePresentationHintReturnValue:
       presentationHint = "returnValue";
       break;
     }

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

@@ -290,9 +290,9 @@ llvm::json::Value toJSON(const Capabilities &);
 /// breakpoints.
 struct Source {
   enum PresentationHint : unsigned {
-    ePresentationHintNormal,
-    ePresentationHintEmphasize,
-    ePresentationHintDeemphasize,
+    eSourcePresentationHintNormal,
+    eSourcePresentationHintEmphasize,
+    eSourcePresentationHintDeemphasize,
   };
 
   /// The short name of the source. Every source returned from the debug adapter
@@ -326,10 +326,10 @@ llvm::json::Value toJSON(const Source &);
 /// a source or a range within a source.
 struct Scope {
   enum PresentationHint : unsigned {
-    ePresentationHintArguments,
-    ePresentationHintLocals,
-    ePresentationHintRegisters,
-    ePresentationHintReturnValue
+    eScopePresentationHintArguments,
+    eScopePresentationHintLocals,
+    eScopePresentationHintRegisters,
+    eScopePresentationHintReturnValue
   };
   /// Name of the scope such as 'Arguments', 'Locals', or 'Registers'. This
   /// string is shown in the UI as is and can be translated.
@@ -387,6 +387,9 @@ struct Scope {
   /// it is 0- or 1-based.
   std::optional<uint64_t> endColumn;
 };
+bool fromJSON(const llvm::json::Value &Params, Scope::PresentationHint &PH,
+              llvm::json::Path);
+bool fromJSON(const llvm::json::Value &, Scope &, llvm::json::Path);
 llvm::json::Value toJSON(const Scope &);
 
 /// The granularity of one `step` in the stepping requests `next`, `stepIn`,

lldb/unittests/DAP/ProtocolTypesTest.cpp

@@ -50,7 +50,7 @@ TEST(ProtocolTypesTest, Source) {
   source.name = "testName";
   source.path = "/path/to/source";
   source.sourceReference = 12345;
-  source.presentationHint = ePresentationHintEmphasize;
+  source.presentationHint = Source::eSourcePresentationHintEmphasize;
 
   llvm::Expected<Source> deserialized_source = roundtrip(source);
   ASSERT_THAT_EXPECTED(deserialized_source, llvm::Succeeded());
@@ -292,6 +292,47 @@ TEST(ProtocolTypesTest, Capabilities) {
             deserialized_capabilities->lldbExtVersion);
 }
 
+TEST(ProtocolTypesTest, Scope) {
+  Scope scope;
+  scope.name = "Locals";
+  scope.presentationHint = Scope::eScopePresentationHintLocals;
+  scope.variablesReference = 1;
+  scope.namedVariables = 2;
+  scope.indexedVariables = std::nullopt;
+  scope.expensive = false;
+  scope.line = 2;
+  scope.column = 3;
+  scope.endLine = 10;
+  scope.endColumn = 20;
+
+  scope.source =
+      Source{.name = "testName",
+             .path = "/path/to/source",
+             .sourceReference = 12345,
+             .presentationHint = Source::eSourcePresentationHintNormal};
+
+  llvm::Expected<Scope> deserialized_scope = roundtrip(scope);
+  ASSERT_THAT_EXPECTED(deserialized_scope, llvm::Succeeded());
+  EXPECT_EQ(scope.name, deserialized_scope->name);
+  EXPECT_EQ(scope.presentationHint, deserialized_scope->presentationHint);
+  EXPECT_EQ(scope.variablesReference, deserialized_scope->variablesReference);
+  EXPECT_EQ(scope.namedVariables, deserialized_scope->namedVariables);
+  EXPECT_EQ(scope.indexedVariables, deserialized_scope->indexedVariables);
+  EXPECT_EQ(scope.expensive, deserialized_scope->expensive);
+  EXPECT_EQ(scope.line, deserialized_scope->line);
+  EXPECT_EQ(scope.column, deserialized_scope->column);
+  EXPECT_EQ(scope.endLine, deserialized_scope->endLine);
+  EXPECT_EQ(scope.endColumn, deserialized_scope->endColumn);
+
+  EXPECT_THAT(deserialized_scope->source.has_value(), true);
+  const Source &source = scope.source.value();
+  const Source &deserialized_source = deserialized_scope->source.value();
+
+  EXPECT_EQ(source.path, deserialized_source.path);
+  EXPECT_EQ(source.sourceReference, deserialized_source.sourceReference);
+  EXPECT_EQ(source.presentationHint, deserialized_source.presentationHint);
+}
+
 TEST(ProtocolTypesTest, PresentationHint) {
   // Test all PresentationHint values.
   std::vector<std::pair<PresentationHint, llvm::StringRef>> test_cases = {