LSP: Adds TCP transport (optionally *ONLY* available in debug builds & disabled by default).

Author: christianparpart

solc/CMakeLists.txt

@@ -4,8 +4,21 @@ set(
 	main.cpp
 )
 
+if(${CMAKE_BUILD_TYPE} STREQUAL "Debug")
+	# Since we do not want to depend on networking code on production binaries,
+	# this feature is only available when creating a debug build.
+	# the LSP's TCP listener is exclusively used more convenient debugging.
+	option(SOLC_LSP_TCP "Solidity LSP: Enables TCP listener support (should only be eanbled for debugging purposes)." OFF)
+	if(SOLC_LSP_TCP)
+		set(SOLC_DEFINITIONS SOLC_LSP_TCP=1)
+		list(APPEND sources LSPTCPTransport.cpp LSPTCPTransport.h)
+		set(SOLC_LSP_LIBS pthread)
+	endif()
+endif()
+
 add_executable(solc ${sources})
-target_link_libraries(solc PRIVATE solidity Boost::boost Boost::program_options)
+target_link_libraries(solc PRIVATE solidity Boost::boost Boost::program_options ${SOLC_LSP_LIBS})
+target_compile_definitions(solc PRIVATE ${SOLC_DEFINITIONS})
 
 include(GNUInstallDirs)
 install(TARGETS solc DESTINATION "${CMAKE_INSTALL_BINDIR}")

solc/CommandLineInterface.cpp

@@ -23,6 +23,10 @@
  */
 #include <solc/CommandLineInterface.h>
 
+#if defined(SOLC_LSP_TCP)
+#include <solc/LSPTCPTransport.h>
+#endif
+
 #include "solidity/BuildInfo.h"
 #include "license.h"
 
@@ -938,6 +942,13 @@ General Information)").c_str(),
 			"Enables Language Server (LSP) mode. "
 			"This won't compile input but serves as language server to to clients."
 		)
+#if defined(SOLC_LSP_TCP)
+		(
+			"lsp-port",
+			po::value<unsigned>()->value_name("PORT")->default_value(4040),
+			"TCP listening port an LCP client can connect to instead of using stdio."
+		)
+#endif
 		(
 			"lsp-trace",
 			po::value<string>()->value_name("path"),
@@ -1129,9 +1140,13 @@ General Information)").c_str(),
 		// LSP related arguments.
 		"lsp",
 		"lsp-trace",
+#if defined(SOLC_LSP_TCP)
+		"lsp-port",
+#endif
 		// Defaulted arguments must be listed.
 		g_argModelCheckerEngine,
 		g_argModelCheckerTargets,
+		g_strModelCheckerContracts,
 		g_argOptimizeRuns
 	};
 
@@ -1809,6 +1824,19 @@ bool CommandLineInterface::serveLSP()
 	};
 
 	std::unique_ptr<lsp::Transport> transport = make_unique<lsp::JSONTransport>(traceLevel, traceLogger);
+#if defined(SOLC_LSP_TCP)
+	if (m_args.count("lsp-port"))
+	{
+		unsigned const port = m_args.at("lsp-port").as<unsigned>();
+		if (port > 0xFFFF)
+		{
+			sout() << "LSP port number not in valid port range. " << endl;
+			return false;
+		}
+		transport = make_unique<lsp::LSPTCPTransport>(static_cast<unsigned short>(port), traceLevel, traceLogger);
+	}
+#endif
+
 	lsp::LanguageServer languageServer(traceLogger, move(transport));
 	return languageServer.run();
 }

solc/LSPTCPTransport.cpp

@@ -0,0 +1,110 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#include <solc/LSPTCPTransport.h>
+
+#include <optional>
+#include <string>
+#include <iostream>
+
+namespace solidity::lsp {
+
+using std::function;
+using std::nullopt;
+using std::optional;
+using std::string_view;
+using std::to_string;
+
+using namespace std::string_literals;
+
+LSPTCPTransport::LSPTCPTransport(unsigned short _port, Trace _traceLevel, function<void(string_view)> _trace):
+	m_io_service(),
+	m_endpoint(boost::asio::ip::make_address("127.0.0.1"), _port),
+	m_acceptor(m_io_service),
+	m_stream(),
+	m_jsonTransport(),
+	m_traceLevel{_traceLevel},
+	m_trace(_trace ? std::move(_trace) : [](string_view) {})
+{
+	m_acceptor.open(m_endpoint.protocol());
+	m_acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
+	m_acceptor.bind(m_endpoint);
+	m_acceptor.listen();
+
+	if (m_traceLevel >= Trace::Messages)
+		m_trace("Listening on tcp://127.0.0.1:"s + to_string(_port));
+}
+
+void LSPTCPTransport::setTraceLevel(Trace _traceLevel)
+{
+	m_traceLevel = _traceLevel;
+
+	if (m_jsonTransport)
+		m_jsonTransport->setTraceLevel(_traceLevel);
+}
+
+bool LSPTCPTransport::closed() const noexcept
+{
+	return !m_acceptor.is_open();
+}
+
+optional<Json::Value> LSPTCPTransport::receive()
+{
+	auto const clientClosed = [&]() { return !m_stream || !m_stream.value().good() || m_stream.value().eof(); };
+
+	if (clientClosed())
+	{
+		m_stream.emplace(m_acceptor.accept());
+		if (clientClosed())
+			return nullopt;
+
+		auto const remoteAddr = m_stream.value().socket().remote_endpoint().address().to_string();
+		auto const remotePort = m_stream.value().socket().remote_endpoint().port();
+		m_trace("New client connected from "s + remoteAddr + ":" + to_string(remotePort) + ".");
+		m_jsonTransport.emplace(m_stream.value(), m_stream.value(), m_traceLevel, [this](auto msg) { m_trace(msg); });
+	}
+	if (auto value = m_jsonTransport.value().receive(); value.has_value())
+		return value;
+
+	if (clientClosed())
+	{
+		m_trace("Client disconnected.");
+		m_jsonTransport.reset();
+		m_stream.reset();
+	}
+	return nullopt;
+}
+
+void LSPTCPTransport::notify(std::string const& _method, Json::Value const& _params)
+{
+	if (m_jsonTransport.has_value())
+		m_jsonTransport.value().notify(_method, _params);
+}
+
+void LSPTCPTransport::reply(MessageID _id, Json::Value const& _result)
+{
+	if (m_jsonTransport.has_value())
+		m_jsonTransport.value().reply(_id, _result);
+}
+
+void LSPTCPTransport::error(MessageID _id, ErrorCode _code, std::string const& _message)
+{
+	if (m_jsonTransport.has_value())
+		m_jsonTransport.value().error(_id, _code, _message);
+}
+
+}

solc/LSPTCPTransport.h

@@ -0,0 +1,48 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#pragma once
+
+#include <libsolidity/lsp/Transport.h>
+
+#include <boost/asio.hpp>
+#include <optional>
+
+namespace solidity::lsp {
+
+class LSPTCPTransport: public lsp::Transport {
+public:
+	LSPTCPTransport(unsigned short _port, Trace _traceLevel, std::function<void(std::string_view)>);
+
+	void setTraceLevel(Trace _traceLevel) override;
+	bool closed() const noexcept override;
+	std::optional<Json::Value> receive() override;
+	void notify(std::string const& _method, Json::Value const& _params) override;
+	void reply(lsp::MessageID _id, Json::Value const& _result) override;
+	void error(lsp::MessageID _id, lsp::ErrorCode _code, std::string const& _message) override;
+
+private:
+	boost::asio::io_service m_io_service;
+	boost::asio::ip::tcp::endpoint m_endpoint;
+	boost::asio::ip::tcp::acceptor m_acceptor;
+	std::optional<boost::asio::ip::tcp::iostream> m_stream;
+	std::optional<lsp::JSONTransport> m_jsonTransport;
+	Trace m_traceLevel;
+	std::function<void(std::string_view)> m_trace;
+};
+
+} // end namespace