Merge pull request #15907 from ethereum/error-and-ice-reporting-tweaks

cameel · web-flow · commit ddc9f0d2e3dc · 2025-03-05T12:36:22.000+01:00
Error and ICE reporting tweaks
diff --git a/Changelog.md b/Changelog.md
@@ -16,6 +16,8 @@ Compiler Features:
 
 
 Bugfixes:
+ * Commandline Interface: Report StackTooDeep errors in compiler mode as proper errors instead of printing diagnostic information meant for internal compiler errors.
+ * Error Reporting: Fix error locations not being shown for source files with empty names.
  * General: Fix internal compiler error when requesting IR AST outputs for interfaces and abstract contracts.
  * Metadata: Fix custom cleanup sequence missing from metadata when other optimizer settings have default values.
  * SMTChecker: Fix internal compiler error when analyzing overflowing expressions or bitwise negation of unsigned types involving constants.
diff --git a/liblangutil/SourceReferenceFormatter.cpp b/liblangutil/SourceReferenceFormatter.cpp
@@ -114,11 +114,11 @@ AnsiColorized SourceReferenceFormatter::diagColored() const
 
 void SourceReferenceFormatter::printSourceLocation(SourceReference const& _ref)
 {
-	if (_ref.sourceName.empty())
-		return; // Nothing we can print here
-
 	if (_ref.position.line < 0)
 	{
+		if (_ref.sourceName.empty())
+			return; // Nothing we can print here
+
 		frameColored() << "-->";
 		m_stream << ' ' << _ref.sourceName << '\n';
 		return; // No line available, nothing else to print
diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
@@ -827,7 +827,12 @@ YulStack CompilerStack::loadGeneratedIR(std::string const& _ir) const
 		yulAnalysisSuccessful,
 		_ir + "\n\n"
 		"Invalid IR generated:\n" +
-		SourceReferenceFormatter::formatErrorInformation(stack.errors(), stack) + "\n"
+		SourceReferenceFormatter::formatErrorInformation(
+			stack.errors(),
+			stack, // _charStreamProvider
+			false, // _colored
+			true   // _withErrorIds
+		) + "\n"
 	);
 
 	return stack;
diff --git a/libsolidity/interface/StandardCompiler.cpp b/libsolidity/interface/StandardCompiler.cpp
@@ -131,7 +131,7 @@ Json formatErrorWithException(
 	);
 
 	if (std::string const* description = _exception.comment())
-		message = ((_message.length() > 0) ? (_message + ":") : "") + *description;
+		message = ((_message.length() > 0) ? (_message + ": ") : "") + *description;
 	else
 		message = _message;
 
@@ -1412,6 +1412,7 @@ Json StandardCompiler::compileSolidity(StandardCompiler::InputsAndSettings _inpu
 				));
 		}
 	}
+	// NOTE: This includes langutil::StackTooDeepError.
 	catch (CompilerError const& _exception)
 	{
 		errors.emplace_back(formatErrorWithException(
@@ -1422,39 +1423,43 @@ Json StandardCompiler::compileSolidity(StandardCompiler::InputsAndSettings _inpu
 			"Compiler error (" + _exception.lineInfo() + ")"
 		));
 	}
-	catch (InternalCompilerError const& _exception)
+	catch (yul::StackTooDeepError const& _exception)
 	{
 		errors.emplace_back(formatErrorWithException(
 			compilerStack,
 			_exception,
+			Error::Type::YulException,
+			"general",
+			"" // No prefix needed. These messages already say it's a "stack too deep" error.
+		));
+	}
+	catch (InternalCompilerError const&)
+	{
+		errors.emplace_back(formatError(
 			Error::Type::InternalCompilerError,
 			"general",
-			"Internal compiler error (" + _exception.lineInfo() + ")"
+			"Internal compiler error:\n" + boost::current_exception_diagnostic_information()
 		));
 	}
 	catch (UnimplementedFeatureError const& _exception)
 	{
 		// let StandardCompiler::compile handle this
 		throw _exception;
 	}
-	catch (yul::YulException const& _exception)
+	catch (YulAssertion const&)
 	{
-		errors.emplace_back(formatErrorWithException(
-			compilerStack,
-			_exception,
+		errors.emplace_back(formatError(
 			Error::Type::YulException,
 			"general",
-			"Yul exception"
+			"Yul assertion failed:\n" + boost::current_exception_diagnostic_information()
 		));
 	}
-	catch (smtutil::SMTLogicError const& _exception)
+	catch (smtutil::SMTLogicError const&)
 	{
-		errors.emplace_back(formatErrorWithException(
-			compilerStack,
-			_exception,
+		errors.emplace_back(formatError(
 			Error::Type::SMTLogicException,
 			"general",
-			"SMT logic exception"
+			"SMT logic error:\n" + boost::current_exception_diagnostic_information()
 		));
 	}
 	catch (...)
@@ -1827,7 +1832,10 @@ Json StandardCompiler::compile(Json const& _input) noexcept
 	}
 	catch (...)
 	{
-		return formatFatalError(Error::Type::InternalCompilerError, "Internal exception in StandardCompiler::compile: " +  boost::current_exception_diagnostic_information());
+		return formatFatalError(
+			Error::Type::InternalCompilerError,
+			"Uncaught exception:\n" + boost::current_exception_diagnostic_information()
+		);
 	}
 }
 
diff --git a/libyul/AsmAnalysis.cpp b/libyul/AsmAnalysis.cpp
@@ -113,7 +113,36 @@ AsmAnalysisInfo AsmAnalyzer::analyzeStrictAssertCorrect(
 		{},
 		std::move(_objectStructure)
 	).analyze(_astRoot);
-	yulAssert(success && !errors.hasErrors(), "Invalid assembly/yul code.");
+
+	if (!success)
+	{
+		auto formatErrors = [](ErrorList const& _errorList) {
+			std::vector<std::string> formattedErrors;
+			for (std::shared_ptr<Error const> const& error: _errorList)
+			{
+				yulAssert(error->comment());
+				formattedErrors.push_back(fmt::format(
+					// Intentionally not showing source locations because we don't have the original
+					// source here and it's unlikely they match the pretty-printed version.
+					// They may not even match the original source if the AST was modified by the optimizer.
+					"- {} {}: {}",
+					Error::formatErrorType(error->type()),
+					error->errorId().error,
+					*error->comment()
+				));
+			}
+			return joinHumanReadable(formattedErrors, "\n");
+		};
+
+		yulAssert(errors.hasErrors(), "Yul analysis failed but did not report any errors.");
+		yulAssert(false, fmt::format(
+			"{}\n\nExpected valid Yul, but errors were reported during analysis:\n{}",
+			AsmPrinter{_dialect}(_astRoot),
+			formatErrors(errorList)
+		));
+	}
+
+	yulAssert(!errors.hasErrors());
 	return analysisInfo;
 }
 
diff --git a/libyul/Exceptions.h b/libyul/Exceptions.h
@@ -36,7 +36,7 @@ namespace solidity::yul
 struct YulException: virtual util::Exception {};
 struct OptimizerException: virtual YulException {};
 struct CodegenException: virtual YulException {};
-struct YulAssertion: virtual YulException {};
+struct YulAssertion: virtual util::Exception {};
 
 struct StackTooDeepError: virtual YulException
 {
diff --git a/solc/CommandLineInterface.cpp b/solc/CommandLineInterface.cpp
@@ -1009,6 +1009,7 @@ void CommandLineInterface::compile()
 		if (!successful)
 			solThrow(CommandLineExecutionError, "");
 	}
+	// NOTE: This includes langutil::StackTooDeepError.
 	catch (CompilerError const& _exception)
 	{
 		m_hasOutput = true;
@@ -1018,6 +1019,15 @@ void CommandLineInterface::compile()
 		);
 		solThrow(CommandLineExecutionError, "");
 	}
+	catch (yul::StackTooDeepError const& _exception)
+	{
+		m_hasOutput = true;
+		formatter.printExceptionInformation(
+			_exception,
+			Error::errorSeverity(Error::Type::YulException)
+		);
+		solThrow(CommandLineExecutionError, "");
+	}
 }
 
 void CommandLineInterface::handleCombinedJSON()
diff --git a/solc/main.cpp b/solc/main.cpp
@@ -51,6 +51,12 @@ int main(int argc, char** argv)
 		std::cerr << boost::diagnostic_information(_exception);
 		return 2;
 	}
+	catch (yul::YulAssertion const& _exception)
+	{
+		std::cerr << "Yul assertion failed:" << std::endl;
+		std::cerr << boost::diagnostic_information(_exception);
+		return 2;
+	}
 	catch (...)
 	{
 		std::cerr << "Uncaught exception:" << std::endl;
diff --git a/test/CommonSyntaxTest.cpp b/test/CommonSyntaxTest.cpp
@@ -197,15 +197,15 @@ void CommonSyntaxTest::printErrorList(
 		for (auto const& error: _errorList)
 		{
 			{
-				util::AnsiColorized scope(
+				util::AnsiColorized formattedStream(
 					_stream,
 					_formatted,
 					{BOLD, SourceReferenceFormatter::errorTextColor(Error::errorSeverity(error.type))}
 				);
-				_stream << _linePrefix << Error::formatErrorType(error.type);
+				formattedStream << _linePrefix << Error::formatErrorType(error.type);
 				if (error.errorId.has_value())
-					_stream << ' ' << error.errorId->error;
-				_stream << ": ";
+					formattedStream << ' ' << error.errorId->error;
+				formattedStream << ": ";
 			}
 			if (!error.sourceName.empty() || error.locationStart >= 0 || error.locationEnd >= 0)
 			{
diff --git a/test/cmdlineTests/stack_too_deep_from_code_transform/args b/test/cmdlineTests/stack_too_deep_from_code_transform/args
@@ -0,0 +1 @@
+--via-ir --bin
diff --git a/test/cmdlineTests/stack_too_deep_from_code_transform/err b/test/cmdlineTests/stack_too_deep_from_code_transform/err
@@ -0,0 +1,6 @@
+Error: Cannot swap Variable value23 with Slot 0x20: too deep in the stack by 9 slots in [ RET value23 value22 value21 value20 value19 value18 value17 value16 value15 value14 value13 value12 value11 value10 value9 value8 value7 value6 value5 value4 value3 value2 value1 value0 pos 0x20 ]
+memoryguard was present.
+ --> stack_too_deep_from_code_transform/input.sol:1:1:
+  |
+1 | contract C {
+  | ^ (Relevant source part starts here and spans across multiple lines).
diff --git a/test/cmdlineTests/stack_too_deep_from_code_transform/exit b/test/cmdlineTests/stack_too_deep_from_code_transform/exit
@@ -0,0 +1 @@
+1
diff --git a/test/cmdlineTests/stack_too_deep_from_code_transform/input.sol b/test/cmdlineTests/stack_too_deep_from_code_transform/input.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() public {
+        uint b;
+        abi.encodePacked(
+            b, b, b, b, b, b, b, b,
+            b, b, b, b, b, b, b, b,
+            b, b, b, b, b, b, b, b
+        );
+    }
+}
diff --git a/test/cmdlineTests/standard_empty_file_name/output.json b/test/cmdlineTests/standard_empty_file_name/output.json
@@ -4,6 +4,10 @@
             "component": "general",
             "errorCode": "2904",
             "formattedMessage": "DeclarationError: Declaration \"A\" not found in \"\" (referenced as \".\").
+ --> :2:24:
+  |
+2 | pragma solidity >=0.0; import {A} from \".\";
+  |                        ^^^^^^^^^^^^^^^^^^^^
 
 ",
             "message": "Declaration \"A\" not found in \"\" (referenced as \".\").",
diff --git a/test/cmdlineTests/standard_stack_too_deep_from_code_transform/in.sol b/test/cmdlineTests/standard_stack_too_deep_from_code_transform/in.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() public {
+        uint b;
+        abi.encodePacked(
+            b, b, b, b, b, b, b, b,
+            b, b, b, b, b, b, b, b,
+            b, b, b, b, b, b, b, b
+        );
+    }
+}
diff --git a/test/cmdlineTests/standard_stack_too_deep_from_code_transform/input.json b/test/cmdlineTests/standard_stack_too_deep_from_code_transform/input.json
@@ -0,0 +1,12 @@
+{
+    "language": "Solidity",
+    "sources": {
+        "in.sol": {"urls": ["standard_stack_too_deep_from_code_transform/in.sol"]}
+    },
+    "settings": {
+        "viaIR": true,
+        "outputSelection": {
+            "*": {"*": ["evm.bytecode"]}
+        }
+    }
+}
diff --git a/test/cmdlineTests/standard_stack_too_deep_from_code_transform/output.json b/test/cmdlineTests/standard_stack_too_deep_from_code_transform/output.json
@@ -0,0 +1,29 @@
+{
+    "errors": [
+        {
+            "component": "general",
+            "formattedMessage": "YulException: Cannot swap Variable value23 with Slot 0x20: too deep in the stack by 9 slots in [ RET value23 value22 value21 value20 value19 value18 value17 value16 value15 value14 value13 value12 value11 value10 value9 value8 value7 value6 value5 value4 value3 value2 value1 value0 pos 0x20 ]
+memoryguard was present.
+ --> in.sol:1:1:
+  |
+1 | contract C {
+  | ^ (Relevant source part starts here and spans across multiple lines).
+
+",
+            "message": "Cannot swap Variable value23 with Slot 0x20: too deep in the stack by 9 slots in [ RET value23 value22 value21 value20 value19 value18 value17 value16 value15 value14 value13 value12 value11 value10 value9 value8 value7 value6 value5 value4 value3 value2 value1 value0 pos 0x20 ]
+memoryguard was present.",
+            "severity": "error",
+            "sourceLocation": {
+                "end": 206,
+                "file": "in.sol",
+                "start": 0
+            },
+            "type": "YulException"
+        }
+    ],
+    "sources": {
+        "in.sol": {
+            "id": 0
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -114,11 +114,11 @@ AnsiColorized SourceReferenceFormatter::diagColored() const`
`114`	`114`
`115`	`115`	`void SourceReferenceFormatter::printSourceLocation(SourceReference const& _ref)`
`116`	`116`	`{`
`117`		`- if (_ref.sourceName.empty())`
`118`		`- return; // Nothing we can print here`
`119`		`-`
`120`	`117`	`if (_ref.position.line < 0)`
`121`	`118`	`{`
	`119`	`+ if (_ref.sourceName.empty())`
	`120`	`+ return; // Nothing we can print here`
	`121`	`+`
`122`	`122`	`frameColored() << "-->";`
`123`	`123`	`m_stream << ' ' << _ref.sourceName << '\n';`
`124`	`124`	`return; // No line available, nothing else to print`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ Json formatErrorWithException(`
`131`	`131`	`);`
`132`	`132`
`133`	`133`	`if (std::string const* description = _exception.comment())`
`134`		`- message = ((_message.length() > 0) ? (_message + ":") : "") + *description;`
	`134`	`+ message = ((_message.length() > 0) ? (_message + ": ") : "") + *description;`
`135`	`135`	`else`
`136`	`136`	`message = _message;`
`137`	`137`
`@@ -1412,6 +1412,7 @@ Json StandardCompiler::compileSolidity(StandardCompiler::InputsAndSettings _inpu`
`1412`	`1412`	`));`
`1413`	`1413`	`}`
`1414`	`1414`	`}`
	`1415`	`+ // NOTE: This includes langutil::StackTooDeepError.`
`1415`	`1416`	`catch (CompilerError const& _exception)`
`1416`	`1417`	`{`
`1417`	`1418`	`errors.emplace_back(formatErrorWithException(`
`@@ -1422,39 +1423,43 @@ Json StandardCompiler::compileSolidity(StandardCompiler::InputsAndSettings _inpu`
`1422`	`1423`	`"Compiler error (" + _exception.lineInfo() + ")"`
`1423`	`1424`	`));`
`1424`	`1425`	`}`
`1425`		`- catch (InternalCompilerError const& _exception)`
	`1426`	`+ catch (yul::StackTooDeepError const& _exception)`
`1426`	`1427`	`{`
`1427`	`1428`	`errors.emplace_back(formatErrorWithException(`
`1428`	`1429`	`compilerStack,`
`1429`	`1430`	`_exception,`
	`1431`	`+ Error::Type::YulException,`
	`1432`	`+ "general",`
	`1433`	`+ "" // No prefix needed. These messages already say it's a "stack too deep" error.`
	`1434`	`+ ));`
	`1435`	`+ }`
	`1436`	`+ catch (InternalCompilerError const&)`
	`1437`	`+ {`
	`1438`	`+ errors.emplace_back(formatError(`
`1430`	`1439`	`Error::Type::InternalCompilerError,`
`1431`	`1440`	`"general",`
`1432`		`- "Internal compiler error (" + _exception.lineInfo() + ")"`
	`1441`	`+ "Internal compiler error:\n" + boost::current_exception_diagnostic_information()`
`1433`	`1442`	`));`
`1434`	`1443`	`}`
`1435`	`1444`	`catch (UnimplementedFeatureError const& _exception)`
`1436`	`1445`	`{`
`1437`	`1446`	`// let StandardCompiler::compile handle this`
`1438`	`1447`	`throw _exception;`
`1439`	`1448`	`}`
`1440`		`- catch (yul::YulException const& _exception)`
	`1449`	`+ catch (YulAssertion const&)`
`1441`	`1450`	`{`
`1442`		`- errors.emplace_back(formatErrorWithException(`
`1443`		`- compilerStack,`
`1444`		`- _exception,`
	`1451`	`+ errors.emplace_back(formatError(`
`1445`	`1452`	`Error::Type::YulException,`
`1446`	`1453`	`"general",`
`1447`		`- "Yul exception"`
	`1454`	`+ "Yul assertion failed:\n" + boost::current_exception_diagnostic_information()`
`1448`	`1455`	`));`
`1449`	`1456`	`}`
`1450`		`- catch (smtutil::SMTLogicError const& _exception)`
	`1457`	`+ catch (smtutil::SMTLogicError const&)`
`1451`	`1458`	`{`
`1452`		`- errors.emplace_back(formatErrorWithException(`
`1453`		`- compilerStack,`
`1454`		`- _exception,`
	`1459`	`+ errors.emplace_back(formatError(`
`1455`	`1460`	`Error::Type::SMTLogicException,`
`1456`	`1461`	`"general",`
`1457`		`- "SMT logic exception"`
	`1462`	`+ "SMT logic error:\n" + boost::current_exception_diagnostic_information()`
`1458`	`1463`	`));`
`1459`	`1464`	`}`
`1460`	`1465`	`catch (...)`
`@@ -1827,7 +1832,10 @@ Json StandardCompiler::compile(Json const& _input) noexcept`
`1827`	`1832`	`}`
`1828`	`1833`	`catch (...)`
`1829`	`1834`	`{`
`1830`		`- return formatFatalError(Error::Type::InternalCompilerError, "Internal exception in StandardCompiler::compile: " + boost::current_exception_diagnostic_information());`
	`1835`	`+ return formatFatalError(`
	`1836`	`+ Error::Type::InternalCompilerError,`
	`1837`	`+ "Uncaught exception:\n" + boost::current_exception_diagnostic_information()`
	`1838`	`+ );`
`1831`	`1839`	`}`
`1832`	`1840`	`}`
`1833`	`1841`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ namespace solidity::yul`
`36`	`36`	`struct YulException: virtual util::Exception {};`
`37`	`37`	`struct OptimizerException: virtual YulException {};`
`38`	`38`	`struct CodegenException: virtual YulException {};`
`39`		`-struct YulAssertion: virtual YulException {};`
	`39`	`+struct YulAssertion: virtual util::Exception {};`
`40`	`40`
`41`	`41`	`struct StackTooDeepError: virtual YulException`
`42`	`42`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1009,6 +1009,7 @@ void CommandLineInterface::compile()`
`1009`	`1009`	`if (!successful)`
`1010`	`1010`	`solThrow(CommandLineExecutionError, "");`
`1011`	`1011`	`}`
	`1012`	`+ // NOTE: This includes langutil::StackTooDeepError.`
`1012`	`1013`	`catch (CompilerError const& _exception)`
`1013`	`1014`	`{`
`1014`	`1015`	`m_hasOutput = true;`
`@@ -1018,6 +1019,15 @@ void CommandLineInterface::compile()`
`1018`	`1019`	`);`
`1019`	`1020`	`solThrow(CommandLineExecutionError, "");`
`1020`	`1021`	`}`
	`1022`	`+ catch (yul::StackTooDeepError const& _exception)`
	`1023`	`+ {`
	`1024`	`+ m_hasOutput = true;`
	`1025`	`+ formatter.printExceptionInformation(`
	`1026`	`+ _exception,`
	`1027`	`+ Error::errorSeverity(Error::Type::YulException)`
	`1028`	`+ );`
	`1029`	`+ solThrow(CommandLineExecutionError, "");`
	`1030`	`+ }`
`1021`	`1031`	`}`
`1022`	`1032`
`1023`	`1033`	`void CommandLineInterface::handleCombinedJSON()`
Original file line number	Diff line number	Diff line change
`@@ -51,6 +51,12 @@ int main(int argc, char** argv)`
`51`	`51`	`std::cerr << boost::diagnostic_information(_exception);`
`52`	`52`	`return 2;`
`53`	`53`	`}`
	`54`	`+ catch (yul::YulAssertion const& _exception)`
	`55`	`+ {`
	`56`	`+ std::cerr << "Yul assertion failed:" << std::endl;`
	`57`	`+ std::cerr << boost::diagnostic_information(_exception);`
	`58`	`+ return 2;`
	`59`	`+ }`
`54`	`60`	`catch (...)`
`55`	`61`	`{`
`56`	`62`	`std::cerr << "Uncaught exception:" << std::endl;`
Original file line number	Diff line number	Diff line change
`@@ -197,15 +197,15 @@ void CommonSyntaxTest::printErrorList(`
`197`	`197`	`for (auto const& error: _errorList)`
`198`	`198`	`{`
`199`	`199`	`{`
`200`		`- util::AnsiColorized scope(`
	`200`	`+ util::AnsiColorized formattedStream(`
`201`	`201`	`_stream,`
`202`	`202`	`_formatted,`
`203`	`203`	`{BOLD, SourceReferenceFormatter::errorTextColor(Error::errorSeverity(error.type))}`
`204`	`204`	`);`
`205`		`- _stream << _linePrefix << Error::formatErrorType(error.type);`
	`205`	`+ formattedStream << _linePrefix << Error::formatErrorType(error.type);`
`206`	`206`	`if (error.errorId.has_value())`
`207`		`- _stream << ' ' << error.errorId->error;`
`208`		`- _stream << ": ";`
	`207`	`+ formattedStream << ' ' << error.errorId->error;`
	`208`	`+ formattedStream << ": ";`
`209`	`209`	`}`
`210`	`210`	`if (!error.sourceName.empty() \|\| error.locationStart >= 0 \|\| error.locationEnd >= 0)`
`211`	`211`	`{`