HackStudio: Rename HackStudio::ServerConnection=>ConnectionToServer

Also renames ServerConnectionWrapper=>ConnectionToServerWrapper
and ServerConnectionInstances=>ConnectionToServerInstances

This was done with CLion's automatic rename feature.

Userland/DevTools/HackStudio/Editor.cpp

@@ -658,10 +658,10 @@ void Editor::set_language_client_for(const CodeDocument& document)
         return;
 
     if (document.language() == Language::Cpp)
-        m_language_client = get_language_client<LanguageClients::Cpp::ServerConnection>(project().root_path());
+        m_language_client = get_language_client<LanguageClients::Cpp::ConnectionToServer>(project().root_path());
 
     if (document.language() == Language::Shell)
-        m_language_client = get_language_client<LanguageClients::Shell::ServerConnection>(project().root_path());
+        m_language_client = get_language_client<LanguageClients::Shell::ConnectionToServer>(project().root_path());
 
     if (m_language_client) {
         m_language_client->on_tokens_info_result = [this](Vector<GUI::AutocompleteProvider::TokenInfo> const& tokens_info) {

Userland/DevTools/HackStudio/HackStudio.h

@@ -7,7 +7,7 @@
 #pragma once
 
 #include "EditorWrapper.h"
-#include "LanguageClients/ServerConnections.h"
+#include "LanguageClients/ConnectionsToServer.h"
 #include "Project.h"
 #include <AK/String.h>
 #include <LibGUI/TextEditor.h>

Userland/DevTools/HackStudio/LanguageClient.cpp

@@ -14,7 +14,7 @@
 
 namespace HackStudio {
 
-void ServerConnection::auto_complete_suggestions(const Vector<GUI::AutocompleteProvider::Entry>& suggestions)
+void ConnectionToServer::auto_complete_suggestions(const Vector<GUI::AutocompleteProvider::Entry>& suggestions)
 {
     if (!m_current_language_client) {
         dbgln("Language Server connection has no attached language client");
@@ -23,7 +23,7 @@ void ServerConnection::auto_complete_suggestions(const Vector<GUI::AutocompleteP
     m_current_language_client->provide_autocomplete_suggestions(suggestions);
 }
 
-void ServerConnection::declaration_location(const GUI::AutocompleteProvider::ProjectLocation& location)
+void ConnectionToServer::declaration_location(const GUI::AutocompleteProvider::ProjectLocation& location)
 {
     if (!m_current_language_client) {
         dbgln("Language Server connection has no attached language client");
@@ -32,7 +32,7 @@ void ServerConnection::declaration_location(const GUI::AutocompleteProvider::Pro
     m_current_language_client->declaration_found(location.file, location.line, location.column);
 }
 
-void ServerConnection::parameters_hint_result(Vector<String> const& params, int argument_index)
+void ConnectionToServer::parameters_hint_result(Vector<String> const& params, int argument_index)
 {
     if (!m_current_language_client) {
         dbgln("Language Server connection has no attached language client");
@@ -43,7 +43,7 @@ void ServerConnection::parameters_hint_result(Vector<String> const& params, int
     m_current_language_client->parameters_hint_result(params, static_cast<size_t>(argument_index));
 }
 
-void ServerConnection::tokens_info_result(Vector<GUI::AutocompleteProvider::TokenInfo> const& tokens_info)
+void ConnectionToServer::tokens_info_result(Vector<GUI::AutocompleteProvider::TokenInfo> const& tokens_info)
 {
     if (!m_current_language_client) {
         dbgln("Language Server connection has no attached language client");
@@ -53,7 +53,7 @@ void ServerConnection::tokens_info_result(Vector<GUI::AutocompleteProvider::Toke
     m_current_language_client->on_tokens_info_result(tokens_info);
 }
 
-void ServerConnection::die()
+void ConnectionToServer::die()
 {
     VERIFY(m_wrapper);
     // Wrapper destructs us here
@@ -118,14 +118,14 @@ bool LanguageClient::is_active_client() const
     return m_connection_wrapper.connection()->active_client() == this;
 }
 
-HashMap<String, NonnullOwnPtr<ServerConnectionWrapper>> ServerConnectionInstances::s_instance_for_language;
+HashMap<String, NonnullOwnPtr<ConnectionToServerWrapper>> ConnectionToServerInstances::s_instance_for_language;
 
-void ServerConnection::declarations_in_document(const String& filename, const Vector<GUI::AutocompleteProvider::Declaration>& declarations)
+void ConnectionToServer::declarations_in_document(const String& filename, const Vector<GUI::AutocompleteProvider::Declaration>& declarations)
 {
     ProjectDeclarations::the().set_declared_symbols(filename, declarations);
 }
 
-void ServerConnection::todo_entries_in_document(String const& filename, Vector<Cpp::Parser::TodoEntry> const& todo_entries)
+void ConnectionToServer::todo_entries_in_document(String const& filename, Vector<Cpp::Parser::TodoEntry> const& todo_entries)
 {
     ToDoEntries::the().set_entries(filename, move(todo_entries));
 }
@@ -172,25 +172,25 @@ void LanguageClient::parameters_hint_result(Vector<String> const& params, size_t
     on_function_parameters_hint_result(params, argument_index);
 }
 
-void ServerConnectionInstances::set_instance_for_language(const String& language_name, NonnullOwnPtr<ServerConnectionWrapper>&& connection_wrapper)
+void ConnectionToServerInstances::set_instance_for_language(const String& language_name, NonnullOwnPtr<ConnectionToServerWrapper>&& connection_wrapper)
 {
     s_instance_for_language.set(language_name, move(connection_wrapper));
 }
 
-void ServerConnectionInstances::remove_instance_for_language(const String& language_name)
+void ConnectionToServerInstances::remove_instance_for_language(const String& language_name)
 {
     s_instance_for_language.remove(language_name);
 }
 
-ServerConnectionWrapper* ServerConnectionInstances::get_instance_wrapper(const String& language_name)
+ConnectionToServerWrapper* ConnectionToServerInstances::get_instance_wrapper(const String& language_name)
 {
     if (auto instance = s_instance_for_language.get(language_name); instance.has_value()) {
-        return const_cast<ServerConnectionWrapper*>(instance.value());
+        return const_cast<ConnectionToServerWrapper*>(instance.value());
     }
     return nullptr;
 }
 
-void ServerConnectionWrapper::on_crash()
+void ConnectionToServerWrapper::on_crash()
 {
     show_crash_notification();
     m_connection.clear();
@@ -206,7 +206,7 @@ void ServerConnectionWrapper::on_crash()
         try_respawn_connection();
     }
 }
-void ServerConnectionWrapper::show_frequent_crashes_notification() const
+void ConnectionToServerWrapper::show_frequent_crashes_notification() const
 {
     auto notification = GUI::Notification::construct();
     notification->set_icon(Gfx::Bitmap::try_load_from_file("/res/icons/32x32/app-hack-studio.png").release_value_but_fixme_should_propagate_errors());
@@ -214,7 +214,7 @@ void ServerConnectionWrapper::show_frequent_crashes_notification() const
     notification->set_text("LanguageServer aided features will not be available in this session");
     notification->show();
 }
-void ServerConnectionWrapper::show_crash_notification() const
+void ConnectionToServerWrapper::show_crash_notification() const
 {
     auto notification = GUI::Notification::construct();
     notification->set_icon(Gfx::Bitmap::try_load_from_file("/res/icons/32x32/app-hack-studio.png").release_value_but_fixme_should_propagate_errors());
@@ -223,41 +223,41 @@ void ServerConnectionWrapper::show_crash_notification() const
     notification->show();
 }
 
-ServerConnectionWrapper::ServerConnectionWrapper(const String& language_name, Function<NonnullRefPtr<ServerConnection>()> connection_creator)
+ConnectionToServerWrapper::ConnectionToServerWrapper(const String& language_name, Function<NonnullRefPtr<ConnectionToServer>()> connection_creator)
     : m_language(language_from_name(language_name))
     , m_connection_creator(move(connection_creator))
 {
     create_connection();
 }
 
-void ServerConnectionWrapper::create_connection()
+void ConnectionToServerWrapper::create_connection()
 {
     VERIFY(m_connection.is_null());
     m_connection = m_connection_creator();
     m_connection->set_wrapper(*this);
 }
 
-ServerConnection* ServerConnectionWrapper::connection()
+ConnectionToServer* ConnectionToServerWrapper::connection()
 {
     return m_connection.ptr();
 }
 
-void ServerConnectionWrapper::attach(LanguageClient& client)
+void ConnectionToServerWrapper::attach(LanguageClient& client)
 {
     m_connection->m_current_language_client = &client;
 }
 
-void ServerConnectionWrapper::detach()
+void ConnectionToServerWrapper::detach()
 {
     m_connection->m_current_language_client.clear();
 }
 
-void ServerConnectionWrapper::set_active_client(LanguageClient& client)
+void ConnectionToServerWrapper::set_active_client(LanguageClient& client)
 {
     m_connection->m_current_language_client = &client;
 }
 
-void ServerConnectionWrapper::try_respawn_connection()
+void ConnectionToServerWrapper::try_respawn_connection()
 {
     if (!m_respawn_allowed)
         return;

Userland/DevTools/HackStudio/LanguageClient.h

@@ -23,15 +23,15 @@
 namespace HackStudio {
 
 class LanguageClient;
-class ServerConnectionWrapper;
+class ConnectionToServerWrapper;
 
-class ServerConnection
+class ConnectionToServer
     : public IPC::ConnectionToServer<LanguageClientEndpoint, LanguageServerEndpoint>
     , public LanguageClientEndpoint {
-    friend class ServerConnectionWrapper;
+    friend class ConnectionToServerWrapper;
 
 public:
-    ServerConnection(NonnullOwnPtr<Core::Stream::LocalSocket> socket, const String& project_path)
+    ConnectionToServer(NonnullOwnPtr<Core::Stream::LocalSocket> socket, const String& project_path)
         : IPC::ConnectionToServer<LanguageClientEndpoint, LanguageServerEndpoint>(*this, move(socket))
     {
         m_project_path = project_path;
@@ -52,25 +52,25 @@ protected:
     virtual void todo_entries_in_document(String const&, Vector<Cpp::Parser::TodoEntry> const&) override;
     virtual void parameters_hint_result(Vector<String> const&, int index) override;
     virtual void tokens_info_result(Vector<GUI::AutocompleteProvider::TokenInfo> const&) override;
-    void set_wrapper(ServerConnectionWrapper& wrapper) { m_wrapper = &wrapper; }
+    void set_wrapper(ConnectionToServerWrapper& wrapper) { m_wrapper = &wrapper; }
 
     String m_project_path;
     WeakPtr<LanguageClient> m_current_language_client;
-    ServerConnectionWrapper* m_wrapper { nullptr };
+    ConnectionToServerWrapper* m_wrapper { nullptr };
 };
 
-class ServerConnectionWrapper {
+class ConnectionToServerWrapper {
-    AK_MAKE_NONCOPYABLE(ServerConnectionWrapper);
+    AK_MAKE_NONCOPYABLE(ConnectionToServerWrapper);
 
 public:
-    explicit ServerConnectionWrapper(const String& language_name, Function<NonnullRefPtr<ServerConnection>()> connection_creator);
+    explicit ConnectionToServerWrapper(const String& language_name, Function<NonnullRefPtr<ConnectionToServer>()> connection_creator);
-    ~ServerConnectionWrapper() = default;
+    ~ConnectionToServerWrapper() = default;
 
     template<typename LanguageServerType>
-    static ServerConnectionWrapper& get_or_create(const String& project_path);
+    static ConnectionToServerWrapper& get_or_create(const String& project_path);
 
     Language language() const { return m_language; }
-    ServerConnection* connection();
+    ConnectionToServer* connection();
     void on_crash();
     void try_respawn_connection();
 
@@ -84,27 +84,27 @@ private:
     void show_frequent_crashes_notification() const;
 
     Language m_language;
-    Function<NonnullRefPtr<ServerConnection>()> m_connection_creator;
+    Function<NonnullRefPtr<ConnectionToServer>()> m_connection_creator;
-    RefPtr<ServerConnection> m_connection;
+    RefPtr<ConnectionToServer> m_connection;
 
     Core::ElapsedTimer m_last_crash_timer;
     bool m_respawn_allowed { true };
 };
 
-class ServerConnectionInstances {
+class ConnectionToServerInstances {
 public:
-    static void set_instance_for_language(const String& language_name, NonnullOwnPtr<ServerConnectionWrapper>&& connection_wrapper);
+    static void set_instance_for_language(const String& language_name, NonnullOwnPtr<ConnectionToServerWrapper>&& connection_wrapper);
     static void remove_instance_for_language(const String& language_name);
 
-    static ServerConnectionWrapper* get_instance_wrapper(const String& language_name);
+    static ConnectionToServerWrapper* get_instance_wrapper(const String& language_name);
 
 private:
-    static HashMap<String, NonnullOwnPtr<ServerConnectionWrapper>> s_instance_for_language;
+    static HashMap<String, NonnullOwnPtr<ConnectionToServerWrapper>> s_instance_for_language;
 };
 
 class LanguageClient : public Weakable<LanguageClient> {
 public:
-    explicit LanguageClient(ServerConnectionWrapper& connection_wrapper)
+    explicit LanguageClient(ConnectionToServerWrapper& connection_wrapper)
         : m_connection_wrapper(connection_wrapper)
     {
         if (m_connection_wrapper.connection()) {
@@ -148,26 +148,26 @@ public:
     Function<void(Vector<GUI::AutocompleteProvider::TokenInfo> const&)> on_tokens_info_result;
 
 private:
-    ServerConnectionWrapper& m_connection_wrapper;
+    ConnectionToServerWrapper& m_connection_wrapper;
     WeakPtr<LanguageClient> m_previous_client;
 };
 
-template<typename ServerConnectionT>
+template<typename ConnectionToServerT>
 static inline NonnullOwnPtr<LanguageClient> get_language_client(const String& project_path)
 {
-    return make<LanguageClient>(ServerConnectionWrapper::get_or_create<ServerConnectionT>(project_path));
+    return make<LanguageClient>(ConnectionToServerWrapper::get_or_create<ConnectionToServerT>(project_path));
 }
 
 template<typename LanguageServerType>
-ServerConnectionWrapper& ServerConnectionWrapper::get_or_create(const String& project_path)
+ConnectionToServerWrapper& ConnectionToServerWrapper::get_or_create(const String& project_path)
 {
-    auto* wrapper = ServerConnectionInstances::get_instance_wrapper(LanguageServerType::language_name());
+    auto* wrapper = ConnectionToServerInstances::get_instance_wrapper(LanguageServerType::language_name());
     if (wrapper)
         return *wrapper;
 
-    auto connection_wrapper_ptr = make<ServerConnectionWrapper>(LanguageServerType::language_name(), [project_path]() { return LanguageServerType::try_create(project_path).release_value_but_fixme_should_propagate_errors(); });
+    auto connection_wrapper_ptr = make<ConnectionToServerWrapper>(LanguageServerType::language_name(), [project_path]() { return LanguageServerType::try_create(project_path).release_value_but_fixme_should_propagate_errors(); });
     auto& connection_wrapper = *connection_wrapper_ptr;
-    ServerConnectionInstances::set_instance_for_language(LanguageServerType::language_name(), move(connection_wrapper_ptr));
+    ConnectionToServerInstances::set_instance_for_language(LanguageServerType::language_name(), move(connection_wrapper_ptr));
     return connection_wrapper;
 }
 

Userland/DevTools/HackStudio/LanguageClients/ConnectionsToServer.h

@@ -12,19 +12,19 @@
 #include <DevTools/HackStudio/LanguageServers/LanguageServerEndpoint.h>
 #include <LibIPC/ConnectionToServer.h>
 
-#define LANGUAGE_CLIENT(language_name_, socket_name)                                                  \
+#define LANGUAGE_CLIENT(language_name_, socket_name)                                                    \
-    namespace language_name_ {                                                                        \
+    namespace language_name_ {                                                                          \
-    class ServerConnection final : public HackStudio::ServerConnection {                              \
+    class ConnectionToServer final : public HackStudio::ConnectionToServer {                            \
-        IPC_CLIENT_CONNECTION(ServerConnection, "/tmp/portal/language/" #socket_name)                 \
+        IPC_CLIENT_CONNECTION(ConnectionToServer, "/tmp/portal/language/" #socket_name)                 \
-    public:                                                                                           \
+    public:                                                                                             \
-        static const char* language_name() { return #language_name_; }                                \
+        static const char* language_name() { return #language_name_; }                                  \
-                                                                                                      \
+                                                                                                        \
-    private:                                                                                          \
+    private:                                                                                            \
-        ServerConnection(NonnullOwnPtr<Core::Stream::LocalSocket> socket, const String& project_path) \
+        ConnectionToServer(NonnullOwnPtr<Core::Stream::LocalSocket> socket, const String& project_path) \
-            : HackStudio::ServerConnection(move(socket), project_path)                                \
+            : HackStudio::ConnectionToServer(move(socket), project_path)                                \
-        {                                                                                             \
+        {                                                                                               \
-        }                                                                                             \
+        }                                                                                               \
-    };                                                                                                \
+    };                                                                                                  \
     }
 
 namespace LanguageClients {