[Lldb-commits] [lldb] 7a391e3 - [lldb] Adjusting the naming for gcc11. (#162693)
via lldb-commits
lldb-commits at lists.llvm.org
Thu Oct 9 17:15:23 PDT 2025
Author: John Harrison
Date: 2025-10-09T17:15:19-07:00
New Revision: 7a391e32eaf2f2232bd7c81e651dd949f39cc9e1
URL: https://github.com/llvm/llvm-project/commit/7a391e32eaf2f2232bd7c81e651dd949f39cc9e1
DIFF: https://github.com/llvm/llvm-project/commit/7a391e32eaf2f2232bd7c81e651dd949f39cc9e1.diff
LOG: [lldb] Adjusting the naming for gcc11. (#162693)
In gcc11 we're getting an error with a `using Req = Req` statement. This
changes the name of the types in JSONTransportTest from `Req` >
`Request`, `Evt` > `Event`, `Resp` > `Response`.
Added:
Modified:
lldb/unittests/Host/JSONTransportTest.cpp
Removed:
################################################################################
diff --git a/lldb/unittests/Host/JSONTransportTest.cpp b/lldb/unittests/Host/JSONTransportTest.cpp
index 7db6508aa4a3c..54f1372ca0fff 100644
--- a/lldb/unittests/Host/JSONTransportTest.cpp
+++ b/lldb/unittests/Host/JSONTransportTest.cpp
@@ -49,85 +49,85 @@ namespace {
namespace test_protocol {
-struct Req {
+struct Request {
int id = 0;
std::string name;
std::optional<json::Value> params;
};
-json::Value toJSON(const Req &T) {
+json::Value toJSON(const Request &T) {
return json::Object{{"name", T.name}, {"id", T.id}, {"params", T.params}};
}
-bool fromJSON(const json::Value &V, Req &T, json::Path P) {
+bool fromJSON(const json::Value &V, Request &T, json::Path P) {
json::ObjectMapper O(V, P);
return O && O.map("name", T.name) && O.map("id", T.id) &&
O.map("params", T.params);
}
-bool operator==(const Req &a, const Req &b) {
+bool operator==(const Request &a, const Request &b) {
return a.name == b.name && a.id == b.id && a.params == b.params;
}
-inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Req &V) {
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Request &V) {
OS << toJSON(V);
return OS;
}
-void PrintTo(const Req &message, std::ostream *os) {
+void PrintTo(const Request &message, std::ostream *os) {
std::string O;
llvm::raw_string_ostream OS(O);
OS << message;
*os << O;
}
-struct Resp {
+struct Response {
int id = 0;
int errorCode = 0;
std::optional<json::Value> result;
};
-json::Value toJSON(const Resp &T) {
+json::Value toJSON(const Response &T) {
return json::Object{
{"id", T.id}, {"errorCode", T.errorCode}, {"result", T.result}};
}
-bool fromJSON(const json::Value &V, Resp &T, json::Path P) {
+bool fromJSON(const json::Value &V, Response &T, json::Path P) {
json::ObjectMapper O(V, P);
return O && O.map("id", T.id) && O.mapOptional("errorCode", T.errorCode) &&
O.map("result", T.result);
}
-bool operator==(const Resp &a, const Resp &b) {
+bool operator==(const Response &a, const Response &b) {
return a.id == b.id && a.errorCode == b.errorCode && a.result == b.result;
}
-inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Resp &V) {
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Response &V) {
OS << toJSON(V);
return OS;
}
-void PrintTo(const Resp &message, std::ostream *os) {
+void PrintTo(const Response &message, std::ostream *os) {
std::string O;
llvm::raw_string_ostream OS(O);
OS << message;
*os << O;
}
-struct Evt {
+struct Event {
std::string name;
std::optional<json::Value> params;
};
-json::Value toJSON(const Evt &T) {
+json::Value toJSON(const Event &T) {
return json::Object{{"name", T.name}, {"params", T.params}};
}
-bool fromJSON(const json::Value &V, Evt &T, json::Path P) {
+bool fromJSON(const json::Value &V, Event &T, json::Path P) {
json::ObjectMapper O(V, P);
return O && O.map("name", T.name) && O.map("params", T.params);
}
-bool operator==(const Evt &a, const Evt &b) { return a.name == b.name; }
-inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Evt &V) {
+bool operator==(const Event &a, const Event &b) { return a.name == b.name; }
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Event &V) {
OS << toJSON(V);
return OS;
}
-void PrintTo(const Evt &message, std::ostream *os) {
+void PrintTo(const Event &message, std::ostream *os) {
std::string O;
llvm::raw_string_ostream OS(O);
OS << message;
*os << O;
}
-using Message = std::variant<Req, Resp, Evt>;
+using Message = std::variant<Request, Response, Event>;
json::Value toJSON(const Message &msg) {
return std::visit([](const auto &msg) { return toJSON(msg); }, msg);
}
@@ -139,7 +139,7 @@ bool fromJSON(const json::Value &V, Message &msg, json::Path P) {
}
if (O->find("id") == O->end()) {
- Evt E;
+ Event E;
if (!fromJSON(V, E, P))
return false;
@@ -148,7 +148,7 @@ bool fromJSON(const json::Value &V, Message &msg, json::Path P) {
}
if (O->get("name")) {
- Req R;
+ Request R;
if (!fromJSON(V, R, P))
return false;
@@ -156,7 +156,7 @@ bool fromJSON(const json::Value &V, Message &msg, json::Path P) {
return true;
}
- Resp R;
+ Response R;
if (!fromJSON(V, R, P))
return false;
@@ -187,9 +187,9 @@ bool fromJSON(const json::Value &V, MyFnResult &T, json::Path P) {
struct ProtoDesc {
using Id = int;
- using Req = Req;
- using Resp = Resp;
- using Evt = Evt;
+ using Req = Request;
+ using Resp = Response;
+ using Evt = Event;
static inline Id InitialId() { return 0; }
static inline Req Make(Id id, llvm::StringRef method,
@@ -393,8 +393,8 @@ TEST_F(HTTPDelimitedJSONTransportTest, MalformedRequests) {
}
TEST_F(HTTPDelimitedJSONTransportTest, Read) {
- Write(Req{6, "foo", std::nullopt});
- EXPECT_CALL(message_handler, Received(Req{6, "foo", std::nullopt}));
+ Write(Request{6, "foo", std::nullopt});
+ EXPECT_CALL(message_handler, Received(Request{6, "foo", std::nullopt}));
ASSERT_THAT_ERROR(Run(), Succeeded());
}
@@ -402,17 +402,18 @@ TEST_F(HTTPDelimitedJSONTransportTest, ReadMultipleMessagesInSingleWrite) {
InSequence seq;
Write(
Message{
- Req{6, "one", std::nullopt},
+ Request{6, "one", std::nullopt},
},
Message{
- Evt{"two", std::nullopt},
+ test_protocol::Event{"two", std::nullopt},
},
Message{
- Resp{2, 0, std::nullopt},
+ Response{2, 0, std::nullopt},
});
- EXPECT_CALL(message_handler, Received(Req{6, "one", std::nullopt}));
- EXPECT_CALL(message_handler, Received(Evt{"two", std::nullopt}));
- EXPECT_CALL(message_handler, Received(Resp{2, 0, std::nullopt}));
+ EXPECT_CALL(message_handler, Received(Request{6, "one", std::nullopt}));
+ EXPECT_CALL(message_handler,
+ Received(test_protocol::Event{"two", std::nullopt}));
+ EXPECT_CALL(message_handler, Received(Response{2, 0, std::nullopt}));
ASSERT_THAT_ERROR(Run(), Succeeded());
}
@@ -420,18 +421,18 @@ TEST_F(HTTPDelimitedJSONTransportTest, ReadAcrossMultipleChunks) {
std::string long_str = std::string(
HTTPDelimitedJSONTransport<test_protocol::ProtoDesc>::kReadBufferSize * 2,
'x');
- Write(Req{5, long_str, std::nullopt});
- EXPECT_CALL(message_handler, Received(Req{5, long_str, std::nullopt}));
+ Write(Request{5, long_str, std::nullopt});
+ EXPECT_CALL(message_handler, Received(Request{5, long_str, std::nullopt}));
ASSERT_THAT_ERROR(Run(), Succeeded());
}
TEST_F(HTTPDelimitedJSONTransportTest, ReadPartialMessage) {
- std::string message = Encode(Req{5, "foo", std::nullopt});
+ std::string message = Encode(Request{5, "foo", std::nullopt});
auto split_at = message.size() / 2;
std::string part1 = message.substr(0, split_at);
std::string part2 = message.substr(split_at);
- EXPECT_CALL(message_handler, Received(Req{5, "foo", std::nullopt}));
+ EXPECT_CALL(message_handler, Received(Request{5, "foo", std::nullopt}));
ASSERT_THAT_EXPECTED(input.Write(part1.data(), part1.size()), Succeeded());
loop.AddPendingCallback(
@@ -443,12 +444,12 @@ TEST_F(HTTPDelimitedJSONTransportTest, ReadPartialMessage) {
}
TEST_F(HTTPDelimitedJSONTransportTest, ReadWithZeroByteWrites) {
- std::string message = Encode(Req{6, "foo", std::nullopt});
+ std::string message = Encode(Request{6, "foo", std::nullopt});
auto split_at = message.size() / 2;
std::string part1 = message.substr(0, split_at);
std::string part2 = message.substr(split_at);
- EXPECT_CALL(message_handler, Received(Req{6, "foo", std::nullopt}));
+ EXPECT_CALL(message_handler, Received(Request{6, "foo", std::nullopt}));
ASSERT_THAT_EXPECTED(input.Write(part1.data(), part1.size()), Succeeded());
@@ -500,9 +501,11 @@ TEST_F(HTTPDelimitedJSONTransportTest, InvalidTransport) {
}
TEST_F(HTTPDelimitedJSONTransportTest, Write) {
- ASSERT_THAT_ERROR(transport->Send(Req{7, "foo", std::nullopt}), Succeeded());
- ASSERT_THAT_ERROR(transport->Send(Resp{5, 0, "bar"}), Succeeded());
- ASSERT_THAT_ERROR(transport->Send(Evt{"baz", std::nullopt}), Succeeded());
+ ASSERT_THAT_ERROR(transport->Send(Request{7, "foo", std::nullopt}),
+ Succeeded());
+ ASSERT_THAT_ERROR(transport->Send(Response{5, 0, "bar"}), Succeeded());
+ ASSERT_THAT_ERROR(transport->Send(test_protocol::Event{"baz", std::nullopt}),
+ Succeeded());
output.CloseWriteFileDescriptor();
char buf[1024];
Expected<size_t> bytes_read =
@@ -530,18 +533,20 @@ TEST_F(JSONRPCTransportTest, MalformedRequests) {
}
TEST_F(JSONRPCTransportTest, Read) {
- Write(Message{Req{1, "foo", std::nullopt}});
- EXPECT_CALL(message_handler, Received(Req{1, "foo", std::nullopt}));
+ Write(Message{Request{1, "foo", std::nullopt}});
+ EXPECT_CALL(message_handler, Received(Request{1, "foo", std::nullopt}));
ASSERT_THAT_ERROR(Run(), Succeeded());
}
TEST_F(JSONRPCTransportTest, ReadMultipleMessagesInSingleWrite) {
InSequence seq;
- Write(Message{Req{1, "one", std::nullopt}}, Message{Evt{"two", std::nullopt}},
- Message{Resp{3, 0, "three"}});
- EXPECT_CALL(message_handler, Received(Req{1, "one", std::nullopt}));
- EXPECT_CALL(message_handler, Received(Evt{"two", std::nullopt}));
- EXPECT_CALL(message_handler, Received(Resp{3, 0, "three"}));
+ Write(Message{Request{1, "one", std::nullopt}},
+ Message{test_protocol::Event{"two", std::nullopt}},
+ Message{Response{3, 0, "three"}});
+ EXPECT_CALL(message_handler, Received(Request{1, "one", std::nullopt}));
+ EXPECT_CALL(message_handler,
+ Received(test_protocol::Event{"two", std::nullopt}));
+ EXPECT_CALL(message_handler, Received(Response{3, 0, "three"}));
ASSERT_THAT_ERROR(Run(), Succeeded());
}
@@ -550,8 +555,8 @@ TEST_F(JSONRPCTransportTest, ReadAcrossMultipleChunks) {
// across the chunk boundary.
std::string long_str = std::string(
IOTransport<test_protocol::ProtoDesc>::kReadBufferSize * 2, 'x');
- Write(Req{42, long_str, std::nullopt});
- EXPECT_CALL(message_handler, Received(Req{42, long_str, std::nullopt}));
+ Write(Request{42, long_str, std::nullopt});
+ EXPECT_CALL(message_handler, Received(Request{42, long_str, std::nullopt}));
ASSERT_THAT_ERROR(Run(), Succeeded());
}
@@ -561,7 +566,7 @@ TEST_F(JSONRPCTransportTest, ReadPartialMessage) {
std::string part1 = message.substr(0, 7);
std::string part2 = message.substr(7);
- EXPECT_CALL(message_handler, Received(Req{42, "foo", std::nullopt}));
+ EXPECT_CALL(message_handler, Received(Request{42, "foo", std::nullopt}));
ASSERT_THAT_EXPECTED(input.Write(part1.data(), part1.size()), Succeeded());
loop.AddPendingCallback(
@@ -591,9 +596,11 @@ TEST_F(JSONRPCTransportTest, ReaderWithUnhandledData) {
}
TEST_F(JSONRPCTransportTest, Write) {
- ASSERT_THAT_ERROR(transport->Send(Req{11, "foo", std::nullopt}), Succeeded());
- ASSERT_THAT_ERROR(transport->Send(Resp{14, 0, "bar"}), Succeeded());
- ASSERT_THAT_ERROR(transport->Send(Evt{"baz", std::nullopt}), Succeeded());
+ ASSERT_THAT_ERROR(transport->Send(Request{11, "foo", std::nullopt}),
+ Succeeded());
+ ASSERT_THAT_ERROR(transport->Send(Response{14, 0, "bar"}), Succeeded());
+ ASSERT_THAT_ERROR(transport->Send(test_protocol::Event{"baz", std::nullopt}),
+ Succeeded());
output.CloseWriteFileDescriptor();
char buf[1024];
Expected<size_t> bytes_read =
@@ -624,8 +631,8 @@ TEST_F(TransportBinderTest, OutBoundRequests) {
EXPECT_EQ(result->c, 3);
replied = true;
});
- EXPECT_CALL(remote, Received(Req{1, "add", MyFnParams{1, 2}}));
- EXPECT_THAT_ERROR(from_remote->Send(Resp{1, 0, toJSON(MyFnResult{3})}),
+ EXPECT_CALL(remote, Received(Request{1, "add", MyFnParams{1, 2}}));
+ EXPECT_THAT_ERROR(from_remote->Send(Response{1, 0, toJSON(MyFnResult{3})}),
Succeeded());
Run();
EXPECT_TRUE(replied);
@@ -640,8 +647,8 @@ TEST_F(TransportBinderTest, OutBoundRequestsVoidParams) {
EXPECT_EQ(result->c, 3);
replied = true;
});
- EXPECT_CALL(remote, Received(Req{1, "voidParam", std::nullopt}));
- EXPECT_THAT_ERROR(from_remote->Send(Resp{1, 0, toJSON(MyFnResult{3})}),
+ EXPECT_CALL(remote, Received(Request{1, "voidParam", std::nullopt}));
+ EXPECT_THAT_ERROR(from_remote->Send(Response{1, 0, toJSON(MyFnResult{3})}),
Succeeded());
Run();
EXPECT_TRUE(replied);
@@ -655,8 +662,9 @@ TEST_F(TransportBinderTest, OutBoundRequestsVoidResult) {
EXPECT_THAT_ERROR(std::move(error), Succeeded());
replied = true;
});
- EXPECT_CALL(remote, Received(Req{1, "voidResult", MyFnParams{4, 5}}));
- EXPECT_THAT_ERROR(from_remote->Send(Resp{1, 0, std::nullopt}), Succeeded());
+ EXPECT_CALL(remote, Received(Request{1, "voidResult", MyFnParams{4, 5}}));
+ EXPECT_THAT_ERROR(from_remote->Send(Response{1, 0, std::nullopt}),
+ Succeeded());
Run();
EXPECT_TRUE(replied);
}
@@ -669,8 +677,9 @@ TEST_F(TransportBinderTest, OutBoundRequestsVoidParamsAndVoidResult) {
EXPECT_THAT_ERROR(std::move(error), Succeeded());
replied = true;
});
- EXPECT_CALL(remote, Received(Req{1, "voidParamAndResult", std::nullopt}));
- EXPECT_THAT_ERROR(from_remote->Send(Resp{1, 0, std::nullopt}), Succeeded());
+ EXPECT_CALL(remote, Received(Request{1, "voidParamAndResult", std::nullopt}));
+ EXPECT_THAT_ERROR(from_remote->Send(Response{1, 0, std::nullopt}),
+ Succeeded());
Run();
EXPECT_TRUE(replied);
}
@@ -686,10 +695,10 @@ TEST_F(TransportBinderTest, InBoundRequests) {
return MyFnResult{params.a + params.b + captured_param};
},
2);
- EXPECT_THAT_ERROR(from_remote->Send(Req{1, "add", MyFnParams{3, 4}}),
+ EXPECT_THAT_ERROR(from_remote->Send(Request{1, "add", MyFnParams{3, 4}}),
Succeeded());
- EXPECT_CALL(remote, Received(Resp{1, 0, MyFnResult{9}}));
+ EXPECT_CALL(remote, Received(Response{1, 0, MyFnResult{9}}));
Run();
EXPECT_TRUE(called);
}
@@ -703,9 +712,9 @@ TEST_F(TransportBinderTest, InBoundRequestsVoidParams) {
return MyFnResult{captured_param};
},
2);
- EXPECT_THAT_ERROR(from_remote->Send(Req{2, "voidParam", std::nullopt}),
+ EXPECT_THAT_ERROR(from_remote->Send(Request{2, "voidParam", std::nullopt}),
Succeeded());
- EXPECT_CALL(remote, Received(Resp{2, 0, MyFnResult{2}}));
+ EXPECT_CALL(remote, Received(Response{2, 0, MyFnResult{2}}));
Run();
EXPECT_TRUE(called);
}
@@ -722,9 +731,10 @@ TEST_F(TransportBinderTest, InBoundRequestsVoidResult) {
return llvm::Error::success();
},
2);
- EXPECT_THAT_ERROR(from_remote->Send(Req{3, "voidResult", MyFnParams{3, 4}}),
- Succeeded());
- EXPECT_CALL(remote, Received(Resp{3, 0, std::nullopt}));
+ EXPECT_THAT_ERROR(
+ from_remote->Send(Request{3, "voidResult", MyFnParams{3, 4}}),
+ Succeeded());
+ EXPECT_CALL(remote, Received(Response{3, 0, std::nullopt}));
Run();
EXPECT_TRUE(called);
}
@@ -739,9 +749,9 @@ TEST_F(TransportBinderTest, InBoundRequestsVoidParamsAndResult) {
},
2);
EXPECT_THAT_ERROR(
- from_remote->Send(Req{4, "voidParamAndResult", std::nullopt}),
+ from_remote->Send(Request{4, "voidParamAndResult", std::nullopt}),
Succeeded());
- EXPECT_CALL(remote, Received(Resp{4, 0, std::nullopt}));
+ EXPECT_CALL(remote, Received(Response{4, 0, std::nullopt}));
Run();
EXPECT_TRUE(called);
}
@@ -750,14 +760,14 @@ TEST_F(TransportBinderTest, InBoundRequestsVoidParamsAndResult) {
TEST_F(TransportBinderTest, OutBoundEvents) {
OutgoingEvent<MyFnParams> emitEvent = binder->Bind<MyFnParams>("evt");
emitEvent(MyFnParams{1, 2});
- EXPECT_CALL(remote, Received(Evt{"evt", MyFnParams{1, 2}}));
+ EXPECT_CALL(remote, Received(test_protocol::Event{"evt", MyFnParams{1, 2}}));
Run();
}
TEST_F(TransportBinderTest, OutBoundEventsVoidParams) {
OutgoingEvent<void> emitEvent = binder->Bind<void>("evt");
emitEvent();
- EXPECT_CALL(remote, Received(Evt{"evt", std::nullopt}));
+ EXPECT_CALL(remote, Received(test_protocol::Event{"evt", std::nullopt}));
Run();
}
@@ -773,8 +783,9 @@ TEST_F(TransportBinderTest, InBoundEvents) {
called = true;
},
42);
- EXPECT_THAT_ERROR(from_remote->Send(Evt{"evt", MyFnParams{3, 4}}),
- Succeeded());
+ EXPECT_THAT_ERROR(
+ from_remote->Send(test_protocol::Event{"evt", MyFnParams{3, 4}}),
+ Succeeded());
Run();
EXPECT_TRUE(called);
}
@@ -788,7 +799,9 @@ TEST_F(TransportBinderTest, InBoundEventsVoidParams) {
called = true;
},
42);
- EXPECT_THAT_ERROR(from_remote->Send(Evt{"evt", std::nullopt}), Succeeded());
+ EXPECT_THAT_ERROR(
+ from_remote->Send(test_protocol::Event{"evt", std::nullopt}),
+ Succeeded());
Run();
EXPECT_TRUE(called);
}
More information about the lldb-commits
mailing list