Revert statement.

docs/grammar/Solidity.g4

@@ -381,7 +381,7 @@ inlineArrayExpression: LBrack (expression ( Comma expression)* ) RBrack;
 /**
  * Besides regular non-keyword Identifiers, some keywords like 'from' and 'error' can also be used as identifiers.
  */
-identifier: Identifier | From | Error;
+identifier: Identifier | From | Error | Revert;
 
 literal: stringLiteral | numberLiteral | booleanLiteral | hexStringLiteral | unicodeStringLiteral;
 booleanLiteral: True | False;
@@ -422,6 +422,7 @@ statement:
 	| tryStatement
 	| returnStatement
 	| emitStatement
+	| revertStatement
 	| assemblyStatement
 ;
 
@@ -459,6 +460,10 @@ returnStatement: Return expression? Semicolon;
  * An emit statement. The contained expression needs to refer to an event.
  */
 emitStatement: Emit expression callArgumentList Semicolon;
+/**
+ * A revert statement. The contained expression needs to refer to an error.
+ */
+revertStatement: Revert expression callArgumentList Semicolon;
 /**
  * An inline assembly block.
  * The contents of an inline assembly block use a separate scanner/lexer, i.e. the set of keywords and

docs/grammar/SolidityLexer.g4

@@ -30,6 +30,7 @@ Else: 'else';
 Emit: 'emit';
 Enum: 'enum';
 Error: 'error'; // not a real keyword
+Revert: 'revert'; // not a real keyword
 Event: 'event';
 External: 'external';
 Fallback: 'fallback';

libsolidity/CMakeLists.txt

@@ -30,6 +30,8 @@ set(sources
 	analysis/OverrideChecker.h
 	analysis/PostTypeChecker.cpp
 	analysis/PostTypeChecker.h
+	analysis/PostTypeContractLevelChecker.cpp
+	analysis/PostTypeContractLevelChecker.h
 	analysis/ReferencesResolver.cpp
 	analysis/ReferencesResolver.h
 	analysis/Scoper.cpp

libsolidity/analysis/ContractLevelChecker.cpp

@@ -433,24 +433,6 @@ void ContractLevelChecker::checkHashCollisions(ContractDefinition const& _contra
 			);
 		hashes.insert(hash);
 	}
-
-	map<uint32_t, SourceLocation> errorHashes;
-	for (ErrorDefinition const* error: _contract.interfaceErrors())
-	{
-		if (!error->functionType(true)->interfaceFunctionType())
-			// This will result in an error later on, so we can ignore it here.
-			continue;
-		uint32_t hash = selectorFromSignature32(error->functionType(true)->externalSignature());
-		if (errorHashes.count(hash))
-			m_errorReporter.typeError(
-				4883_error,
-				_contract.location(),
-				SecondarySourceLocation{}.append("This error has the same selector: "s, errorHashes[hash]),
-				"Error signature hash collision for " + error->functionType(true)->externalSignature()
-			);
-		else
-			errorHashes[hash] = error->location();
-	}
 }
 
 void ContractLevelChecker::checkLibraryRequirements(ContractDefinition const& _contract)

libsolidity/analysis/ControlFlowBuilder.cpp

@@ -236,6 +236,16 @@ bool ControlFlowBuilder::visit(Throw const& _throw)
 	return false;
 }
 
+bool ControlFlowBuilder::visit(RevertStatement const& _revert)
+{
+	solAssert(!!m_currentNode, "");
+	solAssert(!!m_revertNode, "");
+	visitNode(_revert);
+	connect(m_currentNode, m_revertNode);
+	m_currentNode = newLabel();
+	return false;
+}
+
 bool ControlFlowBuilder::visit(PlaceholderStatement const&)
 {
 	solAssert(!!m_currentNode, "");

libsolidity/analysis/ControlFlowBuilder.h

@@ -56,6 +56,7 @@ class ControlFlowBuilder: private ASTConstVisitor, private yul::ASTWalker
 	bool visit(Break const&) override;
 	bool visit(Continue const&) override;
 	bool visit(Throw const&) override;
+	bool visit(RevertStatement const&) override;
 	bool visit(PlaceholderStatement const&) override;
 	bool visit(FunctionCall const& _functionCall) override;
 	bool visit(ModifierInvocation const& _modifierInvocation) override;

libsolidity/analysis/FunctionCallGraph.cpp

@@ -125,6 +125,8 @@ bool FunctionCallGraphBuilder::visit(FunctionCall const& _functionCall)
 		// change at runtime). All we can do is to add an edge to the dispatch which in turn has
 		// edges to all functions could possibly be called.
 		add(m_currentNode, CallGraph::SpecialNode::InternalDispatch);
+	else if (functionType->kind() == FunctionType::Kind::Error)
+		m_graph.usedErrors.insert(&dynamic_cast<ErrorDefinition const&>(functionType->declaration()));
 
 	return true;
 }

libsolidity/analysis/FunctionCallGraph.h

@@ -65,8 +65,8 @@ class FunctionCallGraphBuilder: private ASTConstVisitor
 
 private:
 	FunctionCallGraphBuilder(ContractDefinition const& _contract):
-		m_contract(_contract),
-		m_graph{{}, {}, {}} {}
+		m_contract(_contract)
+	{}
 
 	bool visit(FunctionCall const& _functionCall) override;
 	bool visit(EmitStatement const& _emitStatement) override;

libsolidity/analysis/PostTypeChecker.cpp

@@ -86,6 +86,16 @@ void PostTypeChecker::endVisit(EmitStatement const& _emit)
 	callEndVisit(_emit);
 }
 
+bool PostTypeChecker::visit(RevertStatement const& _revert)
+{
+	return callVisit(_revert);
+}
+
+void PostTypeChecker::endVisit(RevertStatement const& _revert)
+{
+	callEndVisit(_revert);
+}
+
 bool PostTypeChecker::visit(FunctionCall const& _functionCall)
 {
 	return callVisit(_functionCall);
@@ -281,42 +291,59 @@ struct ModifierContextChecker: public PostTypeChecker::Checker
 	bool m_insideModifierInvocation = false;
 };
 
-struct EventOutsideEmitChecker: public PostTypeChecker::Checker
+struct EventOutsideEmitErrorOutsideRevertChecker: public PostTypeChecker::Checker
 {
-	EventOutsideEmitChecker(ErrorReporter& _errorReporter):
+	EventOutsideEmitErrorOutsideRevertChecker(ErrorReporter& _errorReporter):
 		Checker(_errorReporter) {}
 
-	bool visit(EmitStatement const&) override
+	bool visit(EmitStatement const& _emitStatement) override
 	{
-		m_insideEmitStatement = true;
+		m_currentStatement = &_emitStatement;
 		return true;
 	}
 
 	void endVisit(EmitStatement const&) override
 	{
-		m_insideEmitStatement = true;
+		m_currentStatement = nullptr;
 	}
 
-	bool visit(FunctionCall const& _functionCall) override
+	bool visit(RevertStatement const& _revertStatement) override
 	{
-		if (*_functionCall.annotation().kind != FunctionCallKind::FunctionCall)
-			return true;
+		m_currentStatement = &_revertStatement;
+		return true;
+	}
 
-		if (FunctionTypePointer const functionType = dynamic_cast<FunctionTypePointer const>(_functionCall.expression().annotation().type))
-			// Check for event outside of emit statement
-			if (!m_insideEmitStatement && functionType->kind() == FunctionType::Kind::Event)
-				m_errorReporter.typeError(
-					3132_error,
-					_functionCall.location(),
-					"Event invocations have to be prefixed by \"emit\"."
-				);
+	void endVisit(RevertStatement const&) override
+	{
+		m_currentStatement = nullptr;
+	}
+
+	bool visit(FunctionCall const& _functionCall) override
+	{
+		if (*_functionCall.annotation().kind == FunctionCallKind::FunctionCall)
+			if (auto const* functionType = dynamic_cast<FunctionType const*>(_functionCall.expression().annotation().type))
+			{
+				// Check for event outside of emit statement
+				if (!dynamic_cast<EmitStatement const*>(m_currentStatement) && functionType->kind() == FunctionType::Kind::Event)
+					m_errorReporter.typeError(
+						3132_error,
+						_functionCall.location(),
+						"Event invocations have to be prefixed by \"emit\"."
+					);
+				else if (!dynamic_cast<RevertStatement const*>(m_currentStatement) && functionType->kind() == FunctionType::Kind::Error)
+					m_errorReporter.typeError(
+						7757_error,
+						_functionCall.location(),
+						"Errors can only be used with revert statements: \"revert MyError();\"."
+					);
+			}
+		m_currentStatement = nullptr;
 
 		return true;
 	}
 
 private:
-	/// Flag indicating whether we are currently inside an EmitStatement.
-	bool m_insideEmitStatement = false;
+	Statement const* m_currentStatement = nullptr;
 };
 
 struct NoVariablesInInterfaceChecker: public PostTypeChecker::Checker
@@ -395,14 +422,16 @@ struct ReservedErrorSelector: public PostTypeChecker::Checker
 		}
 	}
 };
+
 }
 
+
 PostTypeChecker::PostTypeChecker(langutil::ErrorReporter& _errorReporter): m_errorReporter(_errorReporter)
 {
 	m_checkers.push_back(make_shared<ConstStateVarCircularReferenceChecker>(_errorReporter));
 	m_checkers.push_back(make_shared<OverrideSpecifierChecker>(_errorReporter));
 	m_checkers.push_back(make_shared<ModifierContextChecker>(_errorReporter));
-	m_checkers.push_back(make_shared<EventOutsideEmitChecker>(_errorReporter));
+	m_checkers.push_back(make_shared<EventOutsideEmitErrorOutsideRevertChecker>(_errorReporter));
 	m_checkers.push_back(make_shared<NoVariablesInInterfaceChecker>(_errorReporter));
 	m_checkers.push_back(make_shared<ReservedErrorSelector>(_errorReporter));
 }

libsolidity/analysis/PostTypeChecker.h

@@ -83,6 +83,9 @@ class PostTypeChecker: private ASTConstVisitor
 	bool visit(EmitStatement const& _emit) override;
 	void endVisit(EmitStatement const& _emit) override;
 
+	bool visit(RevertStatement const& _revert) override;
+	void endVisit(RevertStatement const& _revert) override;
+
 	bool visit(FunctionCall const& _functionCall) override;
 
 	bool visit(Identifier const& _identifier) override;

libsolidity/analysis/PostTypeContractLevelChecker.cpp

@@ -0,0 +1,72 @@
+/*
+	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
+/**
+ * Component that verifies overloads, abstract contracts, function clashes and others
+ * checks at contract or function level.
+ */
+
+#include <libsolidity/analysis/PostTypeContractLevelChecker.h>
+
+#include <libsolidity/ast/AST.h>
+#include <libsolutil/FunctionSelector.h>
+#include <liblangutil/ErrorReporter.h>
+
+using namespace std;
+using namespace solidity;
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+
+bool PostTypeContractLevelChecker::check(SourceUnit const& _sourceUnit)
+{
+	bool noErrors = true;
+	for (auto* contract: ASTNode::filteredNodes<ContractDefinition>(_sourceUnit.nodes()))
+		if (!check(*contract))
+			noErrors = false;
+	return noErrors;
+}
+
+bool PostTypeContractLevelChecker::check(ContractDefinition const& _contract)
+{
+	solAssert(
+		_contract.annotation().creationCallGraph.set() &&
+		_contract.annotation().deployedCallGraph.set(),
+		""
+	);
+
+	map<uint32_t, map<string, SourceLocation>> errorHashes;
+	for (ErrorDefinition const* error: _contract.interfaceErrors())
+	{
+		string signature = error->functionType(true)->externalSignature();
+		uint32_t hash = selectorFromSignature32(signature);
+		// Fail if there is a different signature for the same hash.
+		if (!errorHashes[hash].empty() && !errorHashes[hash].count(signature))
+		{
+			SourceLocation& otherLocation = errorHashes[hash].begin()->second;
+			m_errorReporter.typeError(
+				4883_error,
+				error->nameLocation(),
+				SecondarySourceLocation{}.append("This error has a different signature but the same hash: ", otherLocation),
+				"Error signature hash collision for " + error->functionType(true)->externalSignature()
+			);
+		}
+		else
+			errorHashes[hash][signature] = error->location();
+	}
+
+	return Error::containsOnlyWarnings(m_errorReporter.errors());
+}

libsolidity/analysis/PostTypeContractLevelChecker.h

@@ -0,0 +1,56 @@
+/*
+	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
+/**
+ * Component that verifies properties at contract level, after the type checker has run.
+ */
+
+#pragma once
+
+#include <libsolidity/ast/ASTForward.h>
+
+namespace solidity::langutil
+{
+class ErrorReporter;
+}
+
+namespace solidity::frontend
+{
+
+/**
+ * Component that verifies properties at contract level, after the type checker has run.
+ */
+class PostTypeContractLevelChecker
+{
+public:
+	explicit PostTypeContractLevelChecker(langutil::ErrorReporter& _errorReporter):
+		m_errorReporter(_errorReporter)
+	{}
+
+	/// Performs checks on the given source ast.
+	/// @returns true iff all checks passed. Note even if all checks passed, errors() can still contain warnings
+	bool check(SourceUnit const& _sourceUnit);
+
+private:
+	/// Performs checks on the given contract.
+	/// @returns true iff all checks passed. Note even if all checks passed, errors() can still contain warnings
+	bool check(ContractDefinition const& _contract);
+
+	langutil::ErrorReporter& m_errorReporter;
+};
+
+}

libsolidity/analysis/TypeChecker.cpp

@@ -1167,6 +1167,18 @@ void TypeChecker::endVisit(EmitStatement const& _emit)
 		m_errorReporter.typeError(9292_error, _emit.eventCall().expression().location(), "Expression has to be an event invocation.");
 }
 
+void TypeChecker::endVisit(RevertStatement const& _revert)
+{
+	FunctionCall const& errorCall = _revert.errorCall();
+	if (
+		*errorCall.annotation().kind != FunctionCallKind::FunctionCall ||
+		type(errorCall.expression())->category() != Type::Category::Function ||
+		dynamic_cast<FunctionType const&>(*type(errorCall.expression())).kind() != FunctionType::Kind::Error
+	)
+		m_errorReporter.typeError(1885_error, errorCall.expression().location(), "Expression has to be an error.");
+}
+
+
 bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 {
 	if (!_statement.initialValue())

libsolidity/analysis/TypeChecker.h

@@ -134,6 +134,7 @@ class TypeChecker: private ASTConstVisitor
 	bool visit(ForStatement const& _forStatement) override;
 	void endVisit(Return const& _return) override;
 	void endVisit(EmitStatement const& _emit) override;
+	void endVisit(RevertStatement const& _revert) override;
 	bool visit(VariableDeclarationStatement const& _variable) override;
 	void endVisit(ExpressionStatement const& _statement) override;
 	bool visit(Conditional const& _conditional) override;