Merge pull request #15807 from ethereum/better-reporting-of-unreported-fatal-errors

cameel · web-flow · commit 1d26a839ebf1 · 2025-03-02T05:52:47.000+01:00
More info about unreported fatal errors
diff --git a/liblangutil/ErrorReporter.cpp b/liblangutil/ErrorReporter.cpp
@@ -23,6 +23,9 @@
 
 #include <liblangutil/ErrorReporter.h>
 #include <liblangutil/SourceLocation.h>
+
+#include <libsolutil/Exceptions.h>
+
 #include <range/v3/algorithm/find_if.hpp>
 #include <memory>
 
@@ -121,7 +124,7 @@ bool ErrorReporter::checkForExcessiveErrors(Error::Type _type)
 		if (m_errorCount > c_maxErrorsAllowed)
 		{
 			m_errorList.push_back(std::make_shared<Error>(4013_error, Error::Type::Warning, "There are more than 256 errors. Aborting."));
-			BOOST_THROW_EXCEPTION(FatalError());
+			solThrow(FatalError, "There are more than 256 errors. Aborting.");
 		}
 	}
 
@@ -131,13 +134,13 @@ bool ErrorReporter::checkForExcessiveErrors(Error::Type _type)
 void ErrorReporter::fatalError(ErrorId _error, Error::Type _type, SourceLocation const& _location, SecondarySourceLocation const& _secondaryLocation, std::string const& _description)
 {
 	error(_error, _type, _location, _secondaryLocation, _description);
-	BOOST_THROW_EXCEPTION(FatalError());
+	solThrow(FatalError, _description);
 }
 
 void ErrorReporter::fatalError(ErrorId _error, Error::Type _type, SourceLocation const& _location, std::string const& _description)
 {
 	error(_error, _type, _location, _description);
-	BOOST_THROW_EXCEPTION(FatalError());
+	solThrow(FatalError, _description);
 }
 
 ErrorList const& ErrorReporter::errors() const
diff --git a/libsolidity/analysis/NameAndTypeResolver.cpp b/libsolidity/analysis/NameAndTypeResolver.cpp
@@ -61,9 +61,14 @@ bool NameAndTypeResolver::registerDeclarations(SourceUnit& _sourceUnit, ASTNode
 	{
 		DeclarationRegistrationHelper registrar(m_scopes, _sourceUnit, m_errorReporter, m_globalContext, _currentScope);
 	}
-	catch (langutil::FatalError const& error)
+	catch (FatalError const&)
 	{
-		solAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());
+		if (!m_errorReporter.hasErrors())
+		{
+			std::cerr << "Unreported fatal error:" << std::endl;
+			std::cerr << boost::current_exception_diagnostic_information() << std::endl;
+			solAssert(false, "Unreported fatal error.");
+		}
 		return false;
 	}
 	return true;
@@ -135,9 +140,14 @@ bool NameAndTypeResolver::resolveNamesAndTypes(SourceUnit& _source)
 				return false;
 		}
 	}
-	catch (langutil::FatalError const& error)
+	catch (FatalError const&)
 	{
-		solAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());
+		if (!m_errorReporter.hasErrors())
+		{
+			std::cerr << "Unreported fatal error:" << std::endl;
+			std::cerr << boost::current_exception_diagnostic_information() << std::endl;
+			solAssert(false, "Unreported fatal error.");
+		}
 		return false;
 	}
 	return true;
@@ -150,9 +160,14 @@ bool NameAndTypeResolver::updateDeclaration(Declaration const& _declaration)
 		m_scopes[nullptr]->registerDeclaration(_declaration, false, true);
 		solAssert(_declaration.scope() == nullptr, "Updated declaration outside global scope.");
 	}
-	catch (langutil::FatalError const& error)
+	catch (FatalError const&)
 	{
-		solAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());
+		if (!m_errorReporter.hasErrors())
+		{
+			std::cerr << "Unreported fatal error:" << std::endl;
+			std::cerr << boost::current_exception_diagnostic_information() << std::endl;
+			solAssert(false, "Unreported fatal error.");
+		}
 		return false;
 	}
 	return true;
diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
@@ -1327,7 +1327,7 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 		solAssert(m_errorReporter.hasErrors(), "Should have errors!");
 		for (auto const& var: variables)
 			if (var && !var->annotation().type)
-				BOOST_THROW_EXCEPTION(FatalError());
+				solThrow(FatalError, "Type checker failed to determine types of all variables within the declaration.");
 	}
 
 	return false;
@@ -1380,7 +1380,7 @@ bool TypeChecker::visit(Conditional const& _conditional)
 		commonType = falseType;
 
 	if (!trueType && !falseType)
-		BOOST_THROW_EXCEPTION(FatalError());
+		solThrow(FatalError, "Both sides of the ternary expression have invalid types.");
 	else if (trueType && falseType)
 	{
 		commonType = Type::commonType(trueType, falseType);
diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
@@ -507,9 +507,14 @@ bool CompilerStack::analyze()
 		else if (!analyzeLegacy(noErrors))
 			noErrors = false;
 	}
-	catch (FatalError const& error)
+	catch (FatalError const&)
 	{
-		solAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());
+		if (!m_errorReporter.hasErrors())
+		{
+			std::cerr << "Unreported fatal error:" << std::endl;
+			std::cerr << boost::current_exception_diagnostic_information() << std::endl;
+			solAssert(false, "Unreported fatal error.");
+		}
 		noErrors = false;
 	}
 	catch (UnimplementedFeatureError const& _error)
@@ -1317,9 +1322,14 @@ StringMap CompilerStack::loadMissingSources(SourceUnit const& _ast)
 				}
 			}
 	}
-	catch (FatalError const& error)
+	catch (FatalError const&)
 	{
-		solAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());
+		if (!m_errorReporter.hasErrors())
+		{
+			std::cerr << "Unreported fatal error:" << std::endl;
+			std::cerr << boost::current_exception_diagnostic_information() << std::endl;
+			solAssert(false, "Unreported fatal error.");
+		}
 	}
 	return newSources;
 }
diff --git a/libsolidity/parsing/Parser.cpp b/libsolidity/parsing/Parser.cpp
@@ -176,9 +176,14 @@ ASTPointer<SourceUnit> Parser::parse(CharStream& _charStream)
 		solAssert(m_recursionDepth == 0, "");
 		return nodeFactory.createNode<SourceUnit>(findLicenseString(nodes), nodes, m_experimentalSolidityEnabledInCurrentSourceUnit);
 	}
-	catch (FatalError const& error)
+	catch (FatalError const&)
 	{
-		solAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());
+		if (!m_errorReporter.hasErrors())
+		{
+			std::cerr << "Unreported fatal error:" << std::endl;
+			std::cerr << boost::current_exception_diagnostic_information() << std::endl;
+			solAssert(false, "Unreported fatal error.");
+		}
 		return nullptr;
 	}
 }
@@ -1539,7 +1544,7 @@ ASTPointer<InlineAssembly> Parser::parseInlineAssembly(ASTPointer<ASTString> con
 	yul::Parser asmParser(m_errorReporter, dialect);
 	std::shared_ptr<yul::AST> ast = asmParser.parseInline(m_scanner);
 	if (ast == nullptr)
-		BOOST_THROW_EXCEPTION(FatalError());
+		solThrow(FatalError, "Failed to parse inline assembly.");
 
 	location.end = nativeLocationOf(ast->root()).end;
 	return std::make_shared<InlineAssembly>(nextID(), location, _docString, dialect, std::move(flags), ast);
diff --git a/libyul/AsmAnalysis.cpp b/libyul/AsmAnalysis.cpp
@@ -75,13 +75,18 @@ bool AsmAnalyzer::analyze(Block const& _block)
 
 		(*this)(_block);
 	}
-	catch (FatalError const& error)
+	catch (FatalError const&)
 	{
 		// NOTE: There's a cap on the number of reported errors, but watcher.ok() will work fine even if
 		// we exceed it because the reporter keeps counting (it just stops adding errors to the list).
 		// Note also that fact of exceeding the cap triggers a FatalError so one can get thrown even
 		// if we don't make any of our errors fatal.
-		yulAssert(!watcher.ok(), "Unreported fatal error: "s + error.what());
+		if (watcher.ok())
+		{
+			std::cerr << "Unreported fatal error:" << std::endl;
+			std::cerr << boost::current_exception_diagnostic_information() << std::endl;
+			yulAssert(false, "Unreported fatal error.");
+		}
 	}
 	return watcher.ok();
 }
diff --git a/libyul/AsmParser.cpp b/libyul/AsmParser.cpp
@@ -127,9 +127,14 @@ std::unique_ptr<AST> Parser::parseInline(std::shared_ptr<Scanner> const& _scanne
 			fetchDebugDataFromComment();
 		return std::make_unique<AST>(m_dialect, parseBlock());
 	}
-	catch (FatalError const& error)
+	catch (FatalError const&)
 	{
-		yulAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());
+		if (!m_errorReporter.hasErrors())
+		{
+			std::cerr << "Unreported fatal error:" << std::endl;
+			std::cerr << boost::current_exception_diagnostic_information() << std::endl;
+			yulAssert(false, "Unreported fatal error.");
+		}
 	}
 
 	return nullptr;
diff --git a/libyul/ObjectParser.cpp b/libyul/ObjectParser.cpp
@@ -63,9 +63,14 @@ std::shared_ptr<Object> ObjectParser::parse(std::shared_ptr<Scanner> const& _sca
 			expectToken(Token::EOS);
 		return object;
 	}
-	catch (FatalError const& error)
+	catch (FatalError const&)
 	{
-		yulAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());
+		if (!m_errorReporter.hasErrors())
+		{
+			std::cerr << "Unreported fatal error:" << std::endl;
+			std::cerr << boost::current_exception_diagnostic_information() << std::endl;
+			yulAssert(false, "Unreported fatal error.");
+		}
 	}
 	return nullptr;
 }

Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,9 @@`
`23`	`23`
`24`	`24`	`#include <liblangutil/ErrorReporter.h>`
`25`	`25`	`#include <liblangutil/SourceLocation.h>`
	`26`	`+`
	`27`	`+#include <libsolutil/Exceptions.h>`
	`28`	`+`
`26`	`29`	`#include <range/v3/algorithm/find_if.hpp>`
`27`	`30`	`#include <memory>`
`28`	`31`
`@@ -121,7 +124,7 @@ bool ErrorReporter::checkForExcessiveErrors(Error::Type _type)`
`121`	`124`	`if (m_errorCount > c_maxErrorsAllowed)`
`122`	`125`	`{`
`123`	`126`	`m_errorList.push_back(std::make_shared<Error>(4013_error, Error::Type::Warning, "There are more than 256 errors. Aborting."));`
`124`		`- BOOST_THROW_EXCEPTION(FatalError());`
	`127`	`+ solThrow(FatalError, "There are more than 256 errors. Aborting.");`
`125`	`128`	`}`
`126`	`129`	`}`
`127`	`130`
`@@ -131,13 +134,13 @@ bool ErrorReporter::checkForExcessiveErrors(Error::Type _type)`
`131`	`134`	`void ErrorReporter::fatalError(ErrorId _error, Error::Type _type, SourceLocation const& _location, SecondarySourceLocation const& _secondaryLocation, std::string const& _description)`
`132`	`135`	`{`
`133`	`136`	`error(_error, _type, _location, _secondaryLocation, _description);`
`134`		`- BOOST_THROW_EXCEPTION(FatalError());`
	`137`	`+ solThrow(FatalError, _description);`
`135`	`138`	`}`
`136`	`139`
`137`	`140`	`void ErrorReporter::fatalError(ErrorId _error, Error::Type _type, SourceLocation const& _location, std::string const& _description)`
`138`	`141`	`{`
`139`	`142`	`error(_error, _type, _location, _description);`
`140`		`- BOOST_THROW_EXCEPTION(FatalError());`
	`143`	`+ solThrow(FatalError, _description);`
`141`	`144`	`}`
`142`	`145`
`143`	`146`	`ErrorList const& ErrorReporter::errors() const`
Original file line number	Diff line number	Diff line change
`@@ -61,9 +61,14 @@ bool NameAndTypeResolver::registerDeclarations(SourceUnit& _sourceUnit, ASTNode`
`61`	`61`	`{`
`62`	`62`	`DeclarationRegistrationHelper registrar(m_scopes, _sourceUnit, m_errorReporter, m_globalContext, _currentScope);`
`63`	`63`	`}`
`64`		`- catch (langutil::FatalError const& error)`
	`64`	`+ catch (FatalError const&)`
`65`	`65`	`{`
`66`		`- solAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());`
	`66`	`+ if (!m_errorReporter.hasErrors())`
	`67`	`+ {`
	`68`	`+ std::cerr << "Unreported fatal error:" << std::endl;`
	`69`	`+ std::cerr << boost::current_exception_diagnostic_information() << std::endl;`
	`70`	`+ solAssert(false, "Unreported fatal error.");`
	`71`	`+ }`
`67`	`72`	`return false;`
`68`	`73`	`}`
`69`	`74`	`return true;`
`@@ -135,9 +140,14 @@ bool NameAndTypeResolver::resolveNamesAndTypes(SourceUnit& _source)`
`135`	`140`	`return false;`
`136`	`141`	`}`
`137`	`142`	`}`
`138`		`- catch (langutil::FatalError const& error)`
	`143`	`+ catch (FatalError const&)`
`139`	`144`	`{`
`140`		`- solAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());`
	`145`	`+ if (!m_errorReporter.hasErrors())`
	`146`	`+ {`
	`147`	`+ std::cerr << "Unreported fatal error:" << std::endl;`
	`148`	`+ std::cerr << boost::current_exception_diagnostic_information() << std::endl;`
	`149`	`+ solAssert(false, "Unreported fatal error.");`
	`150`	`+ }`
`141`	`151`	`return false;`
`142`	`152`	`}`
`143`	`153`	`return true;`
`@@ -150,9 +160,14 @@ bool NameAndTypeResolver::updateDeclaration(Declaration const& _declaration)`
`150`	`160`	`m_scopes[nullptr]->registerDeclaration(_declaration, false, true);`
`151`	`161`	`solAssert(_declaration.scope() == nullptr, "Updated declaration outside global scope.");`
`152`	`162`	`}`
`153`		`- catch (langutil::FatalError const& error)`
	`163`	`+ catch (FatalError const&)`
`154`	`164`	`{`
`155`		`- solAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());`
	`165`	`+ if (!m_errorReporter.hasErrors())`
	`166`	`+ {`
	`167`	`+ std::cerr << "Unreported fatal error:" << std::endl;`
	`168`	`+ std::cerr << boost::current_exception_diagnostic_information() << std::endl;`
	`169`	`+ solAssert(false, "Unreported fatal error.");`
	`170`	`+ }`
`156`	`171`	`return false;`
`157`	`172`	`}`
`158`	`173`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -507,9 +507,14 @@ bool CompilerStack::analyze()`
`507`	`507`	`else if (!analyzeLegacy(noErrors))`
`508`	`508`	`noErrors = false;`
`509`	`509`	`}`
`510`		`- catch (FatalError const& error)`
	`510`	`+ catch (FatalError const&)`
`511`	`511`	`{`
`512`		`- solAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());`
	`512`	`+ if (!m_errorReporter.hasErrors())`
	`513`	`+ {`
	`514`	`+ std::cerr << "Unreported fatal error:" << std::endl;`
	`515`	`+ std::cerr << boost::current_exception_diagnostic_information() << std::endl;`
	`516`	`+ solAssert(false, "Unreported fatal error.");`
	`517`	`+ }`
`513`	`518`	`noErrors = false;`
`514`	`519`	`}`
`515`	`520`	`catch (UnimplementedFeatureError const& _error)`
`@@ -1317,9 +1322,14 @@ StringMap CompilerStack::loadMissingSources(SourceUnit const& _ast)`
`1317`	`1322`	`}`
`1318`	`1323`	`}`
`1319`	`1324`	`}`
`1320`		`- catch (FatalError const& error)`
	`1325`	`+ catch (FatalError const&)`
`1321`	`1326`	`{`
`1322`		`- solAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());`
	`1327`	`+ if (!m_errorReporter.hasErrors())`
	`1328`	`+ {`
	`1329`	`+ std::cerr << "Unreported fatal error:" << std::endl;`
	`1330`	`+ std::cerr << boost::current_exception_diagnostic_information() << std::endl;`
	`1331`	`+ solAssert(false, "Unreported fatal error.");`
	`1332`	`+ }`
`1323`	`1333`	`}`
`1324`	`1334`	`return newSources;`
`1325`	`1335`	`}`
Original file line number	Diff line number	Diff line change
`@@ -176,9 +176,14 @@ ASTPointer<SourceUnit> Parser::parse(CharStream& _charStream)`
`176`	`176`	`solAssert(m_recursionDepth == 0, "");`
`177`	`177`	`return nodeFactory.createNode<SourceUnit>(findLicenseString(nodes), nodes, m_experimentalSolidityEnabledInCurrentSourceUnit);`
`178`	`178`	`}`
`179`		`- catch (FatalError const& error)`
	`179`	`+ catch (FatalError const&)`
`180`	`180`	`{`
`181`		`- solAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());`
	`181`	`+ if (!m_errorReporter.hasErrors())`
	`182`	`+ {`
	`183`	`+ std::cerr << "Unreported fatal error:" << std::endl;`
	`184`	`+ std::cerr << boost::current_exception_diagnostic_information() << std::endl;`
	`185`	`+ solAssert(false, "Unreported fatal error.");`
	`186`	`+ }`
`182`	`187`	`return nullptr;`
`183`	`188`	`}`
`184`	`189`	`}`
`@@ -1539,7 +1544,7 @@ ASTPointer<InlineAssembly> Parser::parseInlineAssembly(ASTPointer<ASTString> con`
`1539`	`1544`	`yul::Parser asmParser(m_errorReporter, dialect);`
`1540`	`1545`	`std::shared_ptr<yul::AST> ast = asmParser.parseInline(m_scanner);`
`1541`	`1546`	`if (ast == nullptr)`
`1542`		`- BOOST_THROW_EXCEPTION(FatalError());`
	`1547`	`+ solThrow(FatalError, "Failed to parse inline assembly.");`
`1543`	`1548`
`1544`	`1549`	`location.end = nativeLocationOf(ast->root()).end;`
`1545`	`1550`	`return std::make_shared<InlineAssembly>(nextID(), location, _docString, dialect, std::move(flags), ast);`
Original file line number	Diff line number	Diff line change
`@@ -75,13 +75,18 @@ bool AsmAnalyzer::analyze(Block const& _block)`
`75`	`75`
`76`	`76`	`(*this)(_block);`
`77`	`77`	`}`
`78`		`- catch (FatalError const& error)`
	`78`	`+ catch (FatalError const&)`
`79`	`79`	`{`
`80`	`80`	`// NOTE: There's a cap on the number of reported errors, but watcher.ok() will work fine even if`
`81`	`81`	`// we exceed it because the reporter keeps counting (it just stops adding errors to the list).`
`82`	`82`	`// Note also that fact of exceeding the cap triggers a FatalError so one can get thrown even`
`83`	`83`	`// if we don't make any of our errors fatal.`
`84`		`- yulAssert(!watcher.ok(), "Unreported fatal error: "s + error.what());`
	`84`	`+ if (watcher.ok())`
	`85`	`+ {`
	`86`	`+ std::cerr << "Unreported fatal error:" << std::endl;`
	`87`	`+ std::cerr << boost::current_exception_diagnostic_information() << std::endl;`
	`88`	`+ yulAssert(false, "Unreported fatal error.");`
	`89`	`+ }`
`85`	`90`	`}`
`86`	`91`	`return watcher.ok();`
`87`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -127,9 +127,14 @@ std::unique_ptr<AST> Parser::parseInline(std::shared_ptr<Scanner> const& _scanne`
`127`	`127`	`fetchDebugDataFromComment();`
`128`	`128`	`return std::make_unique<AST>(m_dialect, parseBlock());`
`129`	`129`	`}`
`130`		`- catch (FatalError const& error)`
	`130`	`+ catch (FatalError const&)`
`131`	`131`	`{`
`132`		`- yulAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());`
	`132`	`+ if (!m_errorReporter.hasErrors())`
	`133`	`+ {`
	`134`	`+ std::cerr << "Unreported fatal error:" << std::endl;`
	`135`	`+ std::cerr << boost::current_exception_diagnostic_information() << std::endl;`
	`136`	`+ yulAssert(false, "Unreported fatal error.");`
	`137`	`+ }`
`133`	`138`	`}`
`134`	`139`
`135`	`140`	`return nullptr;`
Original file line number	Diff line number	Diff line change
`@@ -63,9 +63,14 @@ std::shared_ptr<Object> ObjectParser::parse(std::shared_ptr<Scanner> const& _sca`
`63`	`63`	`expectToken(Token::EOS);`
`64`	`64`	`return object;`
`65`	`65`	`}`
`66`		`- catch (FatalError const& error)`
	`66`	`+ catch (FatalError const&)`
`67`	`67`	`{`
`68`		`- yulAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());`
	`68`	`+ if (!m_errorReporter.hasErrors())`
	`69`	`+ {`
	`70`	`+ std::cerr << "Unreported fatal error:" << std::endl;`
	`71`	`+ std::cerr << boost::current_exception_diagnostic_information() << std::endl;`
	`72`	`+ yulAssert(false, "Unreported fatal error.");`
	`73`	`+ }`
`69`	`74`	`}`
`70`	`75`	`return nullptr;`
`71`	`76`	`}`