Add support for parsing debug data attributes

liblangutil/DebugData.h

@@ -19,6 +19,7 @@
 #pragma once
 
 #include <liblangutil/SourceLocation.h>
+#include <libsolutil/JSON.h>
 #include <optional>
 #include <memory>
 
@@ -28,27 +29,32 @@ namespace solidity::langutil
 struct DebugData
 {
 	typedef typename std::shared_ptr<DebugData const> ConstPtr;
+	typedef std::optional<std::vector<std::shared_ptr<Json>>> Attributes;
 
 	explicit DebugData(
 		langutil::SourceLocation _nativeLocation = {},
 		langutil::SourceLocation _originLocation = {},
-		std::optional<int64_t> _astID = {}
+		std::optional<int64_t> _astID = {},
+		Attributes _attributes = {}
 	):
 		nativeLocation(std::move(_nativeLocation)),
 		originLocation(std::move(_originLocation)),
-		astID(_astID)
+		astID(_astID),
+		attributes(std::move(_attributes))
 	{}
 
 	static DebugData::ConstPtr create(
 		langutil::SourceLocation _nativeLocation,
 		langutil::SourceLocation _originLocation = {},
-		std::optional<int64_t> _astID = {}
+		std::optional<int64_t> _astID = {},
+		Attributes _attributes = {}
 	)
 	{
 		return std::make_shared<DebugData>(
 			std::move(_nativeLocation),
 			std::move(_originLocation),
-			_astID
+			_astID,
+			std::move(_attributes)
 		);
 	}
 
@@ -65,6 +71,8 @@ struct DebugData
 	langutil::SourceLocation originLocation;
 	/// ID in the (Solidity) source AST.
 	std::optional<int64_t> astID;
+	/// Additional debug data attributes.
+	Attributes attributes;
 };
 
 } // namespace solidity::langutil

libsolutil/CMakeLists.txt

@@ -2,6 +2,7 @@ set(sources
 	Algorithms.h
 	AnsiColorized.h
 	Assertions.h
+	Cache.h
 	Common.h
 	CommonData.cpp
 	CommonData.h

libsolutil/Cache.h

@@ -0,0 +1,126 @@
+/*
+	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
+/** @file Cache.h
+ * @date 2024
+ *
+ * Simple cache.
+ */
+
+#pragma once
+
+#include <liblangutil/Exceptions.h>
+
+#include <libsolutil/FixedHash.h>
+#include <libsolutil/JSON.h>
+#include <libsolutil/Keccak256.h>
+
+#include <boost/functional/hash.hpp>
+
+#include <map>
+
+namespace solidity::util
+{
+
+namespace detail
+{
+
+template<template<typename, typename> typename TCache ,typename THash, typename TValue>
+class CacheBase
+{
+public:
+	typedef THash Hash;
+	typedef TValue Value;
+	typedef TCache<Hash, Value> Cache;
+	typedef std::shared_ptr<Value> Entry;
+	typedef std::shared_ptr<Cache> Ptr;
+
+	Entry set(Hash const& hash, Value const& value)
+	{
+		Entry result;
+		if (m_cache.find(hash) == m_cache.end())
+		{
+			result = std::make_shared<Value>(value);
+			auto [_, inserted] = m_cache.emplace(std::make_pair(hash, result));
+			solAssert(inserted);
+		}
+		else
+			result = m_cache[hash];
+		return result;
+	}
+
+	Entry set(Value const& value) { return set(Cache::hash(value), value); }
+
+	std::map<Hash, Entry> const& cache() { return m_cache; }
+
+	typename std::map<Hash, Entry>::iterator get(Hash const& hash) { return m_cache.find(hash); }
+
+	typename std::map<Hash, Entry>::iterator begin() { return m_cache.begin(); }
+
+	typename std::map<Hash, Entry>::iterator end() { return m_cache.end(); }
+
+private:
+	std::map<Hash, Entry> m_cache;
+};
+
+} // namespace detail
+
+template<typename THash, typename TValue>
+class Cache;
+
+template<typename TValue>
+class Cache<size_t, TValue>: public detail::CacheBase<Cache, size_t, TValue>
+{
+public:
+	static size_t hash(TValue const& value)
+	{
+		boost::hash<TValue> hasher;
+		return hasher(value);
+	}
+};
+
+template<typename TValue>
+class Cache<h256, TValue>: public detail::CacheBase<Cache, h256, TValue>
+{
+public:
+	static h256 hash(TValue const& value)
+	{
+		std::stringstream stream;
+		stream << value;
+		return keccak256(stream.str());
+	}
+};
+
+template<>
+class Cache<size_t, Json>: public detail::CacheBase<Cache, size_t, Json>
+{
+public:
+	static size_t hash(Json const& value)
+	{
+		boost::hash<std::string> hasher;
+		return hasher(value.dump(0));
+	}
+};
+
+template<>
+class Cache<h256, Json>: public detail::CacheBase<Cache, h256, Json>
+{
+public:
+	static h256 hash(Json const& value) { return keccak256(value.dump(0)); }
+};
+
+} // namespace solidity::util

libyul/AsmParser.cpp

@@ -62,14 +62,36 @@ std::optional<int> toInt(std::string const& _value)
 
 langutil::DebugData::ConstPtr Parser::createDebugData() const
 {
+	solAssert(m_debugAttributeCache);
 	switch (m_useSourceLocationFrom)
 	{
-		case UseSourceLocationFrom::Scanner:
-			return DebugData::create(ParserBase::currentLocation(), ParserBase::currentLocation());
-		case UseSourceLocationFrom::LocationOverride:
-			return DebugData::create(m_locationOverride, m_locationOverride);
-		case UseSourceLocationFrom::Comments:
-			return DebugData::create(ParserBase::currentLocation(), m_locationFromComment, m_astIDFromComment);
+	case UseSourceLocationFrom::Scanner:
+		return DebugData::create(
+			ParserBase::currentLocation(),
+			ParserBase::currentLocation(),
+			{},
+			m_currentDebugAttributes.has_value()
+				? DebugData::Attributes({m_debugAttributeCache->set(*m_currentDebugAttributes)})
+				: DebugData::Attributes({})
+		);
+	case UseSourceLocationFrom::LocationOverride:
+		return DebugData::create(
+			m_locationOverride,
+			m_locationOverride,
+			{},
+			m_currentDebugAttributes.has_value()
+				? DebugData::Attributes({m_debugAttributeCache->set(*m_currentDebugAttributes)})
+				: DebugData::Attributes({})
+		);
+	case UseSourceLocationFrom::Comments:
+		return DebugData::create(
+			ParserBase::currentLocation(),
+			m_locationFromComment,
+			m_astIDFromComment,
+			m_currentDebugAttributes.has_value()
+				? DebugData::Attributes({m_debugAttributeCache->set(*m_currentDebugAttributes)})
+				: DebugData::Attributes({})
+		);
 	}
 	solAssert(false, "");
 }
@@ -138,24 +160,20 @@ std::unique_ptr<AST> Parser::parseInline(std::shared_ptr<Scanner> const& _scanne
 langutil::Token Parser::advance()
 {
 	auto const token = ParserBase::advance();
-	if (m_useSourceLocationFrom == UseSourceLocationFrom::Comments)
-		fetchDebugDataFromComment();
+	fetchDebugDataFromComment();
 	return token;
 }
 
 void Parser::fetchDebugDataFromComment()
 {
-	solAssert(m_sourceNames.has_value(), "");
-
 	static std::regex const tagRegex = std::regex(
-		R"~~((?:^|\s+)(@[a-zA-Z0-9\-_]+)(?:\s+|$))~~", // tag, e.g: @src
+		R"~~((?:^|\s+)(@[a-zA-Z0-9\-\._]+)(?:\s+|$))~~", // tag, e.g: @src
 		std::regex_constants::ECMAScript | std::regex_constants::optimize
 	);
 
 	std::string_view commentLiteral = m_scanner->currentCommentLiteral();
 	std::match_results<std::string_view::const_iterator> match;
 
-	langutil::SourceLocation originLocation = m_locationFromComment;
 	// Empty for each new node.
 	std::optional<int> astID;
 
@@ -166,10 +184,14 @@ void Parser::fetchDebugDataFromComment()
 
 		if (match[1] == "@src")
 		{
-			if (auto parseResult = parseSrcComment(commentLiteral, m_scanner->currentCommentLocation()))
-				tie(commentLiteral, originLocation) = *parseResult;
-			else
-				break;
+			if (m_useSourceLocationFrom == UseSourceLocationFrom::Comments)
+			{
+				solAssert(m_sourceNames.has_value(), "");
+				if (auto parseResult = parseSrcComment(commentLiteral, m_scanner->currentCommentLocation()))
+					tie(commentLiteral, m_locationFromComment) = *parseResult;
+				else
+					break;
+			}
 		}
 		else if (match[1] == "@ast-id")
 		{
@@ -178,15 +200,107 @@ void Parser::fetchDebugDataFromComment()
 			else
 				break;
 		}
+		else if (match[1] == "@debug.set")
+		{
+			if (auto parseResult = parseDebugDataAttributeOperationComment(match[1], commentLiteral, m_scanner->currentCommentLocation()))
+			{
+				commentLiteral = parseResult->first;
+				if (parseResult->second.has_value())
+					m_currentDebugAttributes = parseResult->second.value();
+			}
+			else
+				break;
+		}
+		else if (match[1] == "@debug.merge")
+		{
+			if (auto parseResult = parseDebugDataAttributeOperationComment(match[1], commentLiteral, m_scanner->currentCommentLocation()))
+			{
+				commentLiteral = parseResult->first;
+				if (parseResult->second.has_value())
+				{
+					if (!m_currentDebugAttributes.has_value())
+						m_currentDebugAttributes = Json::object();
+					m_currentDebugAttributes->merge_patch(parseResult->second.value());
+				}
+			}
+			else
+				break;
+		}
+		else if (match[1] == "@debug.patch")
+		{
+			if (auto parseResult = parseDebugDataAttributeOperationComment(match[1], commentLiteral, m_scanner->currentCommentLocation()))
+			{
+				commentLiteral = parseResult->first;
+				if (parseResult->second.has_value())
+					applyDebugDataAttributePatch(parseResult->second.value(), m_scanner->currentCommentLocation());
+			}
+			else
+				break;
+		}
 		else
 			// Ignore unrecognized tags.
 			continue;
 	}
 
-	m_locationFromComment = originLocation;
 	m_astIDFromComment = astID;
 }
 
+std::optional<std::pair<std::string_view, std::optional<Json>>> Parser::parseDebugDataAttributeOperationComment(
+	std::string const& _command,
+	std::string_view _arguments,
+	langutil::SourceLocation const& _location
+)
+{
+	std::optional<Json> jsonData;
+	try
+	{
+		jsonData = Json::parse(_arguments.begin(), _arguments.end(), nullptr, true);
+	}
+	catch (nlohmann::json::parse_error& e)
+	{
+		try
+		{
+			jsonData = Json::parse(_arguments.substr(0, e.byte - 1), nullptr, true);
+		}
+		catch(nlohmann::json::parse_error& ee)
+		{
+			m_errorReporter.syntaxError(
+				5721_error,
+				_location,
+			_command + ": Could not parse debug data: " + removeNlohmannInternalErrorIdentifier(ee.what())
+			);
+			jsonData.reset();
+		}
+		_arguments = _arguments.substr(e.byte - 1);
+	}
+	return {{_arguments, jsonData}};
+}
+
+void Parser::applyDebugDataAttributePatch(Json const& _jsonPatch, langutil::SourceLocation const& _location)
+{
+	try
+	{
+		if (!m_currentDebugAttributes.has_value())
+			m_currentDebugAttributes = Json::object();
+		if (_jsonPatch.is_object())
+		{
+			Json array = Json::array();
+			array.push_back(_jsonPatch);
+			m_currentDebugAttributes = m_currentDebugAttributes->patch(array);
+		}
+		else
+			m_currentDebugAttributes = m_currentDebugAttributes->patch(_jsonPatch);
+	}
+	catch(nlohmann::json::parse_error& ee)
+	{
+		m_errorReporter.syntaxError(
+			9426_error,
+			_location,
+			"@debug.patch: Could not patch debug data: " + removeNlohmannInternalErrorIdentifier(ee.what())
+		);
+	}
+}
+
 std::optional<std::pair<std::string_view, SourceLocation>> Parser::parseSrcComment(
 	std::string_view const _arguments,
 	langutil::SourceLocation const& _commentLocation