Syntax for custom errors.

Author: chriseth

docs/grammar/Solidity.g4

@@ -19,6 +19,7 @@ sourceUnit: (
 	| constantVariableDeclaration
 	| structDefinition
 	| enumDefinition
+	| errorDefinition
 )* EOF;
 
 //@doc: inline
@@ -90,6 +91,7 @@ contractBodyElement:
 	| enumDefinition
 	| stateVariableDeclaration
 	| eventDefinition
+	| errorDefinition
 	| usingDirective;
 //@doc:inline
 namedArgument: name=identifier Colon value=expression;
@@ -289,6 +291,18 @@ eventDefinition:
 	Anonymous?
 	Semicolon;
 
+/**
+ * Parameter of an error.
+ */
+errorParameter: type=typeName name=identifier?;
+/**
+ * Definition of an error.
+ */
+errorDefinition:
+	Error name=identifier
+	LParen (parameters+=errorParameter (Comma parameters+=errorParameter)*)? RParen
+	Semicolon;
+
 /**
  * Using directive to bind library functions to types.
  * Can occur within contracts and libraries.
@@ -367,7 +381,7 @@ inlineArrayExpression: LBrack (expression ( Comma expression)* ) RBrack;
 /**
  * Besides regular non-keyword Identifiers, the 'from' keyword can also occur as identifier outside of import statements.
  */
-identifier: Identifier | From;
+identifier: Identifier | From | Error;
 
 literal: stringLiteral | numberLiteral | booleanLiteral | hexStringLiteral | unicodeStringLiteral;
 booleanLiteral: True | False;

docs/grammar/SolidityLexer.g4

@@ -29,12 +29,13 @@ Do: 'do';
 Else: 'else';
 Emit: 'emit';
 Enum: 'enum';
+Error: 'error'; // not a real keyword
 Event: 'event';
 External: 'external';
 Fallback: 'fallback';
 False: 'false';
 Fixed: 'fixed' | ('fixed' [1-9][0-9]* 'x' [1-9][0-9]*);
-From: 'from';
+From: 'from'; // not a real keyword
 /**
  * Bytes types of fixed length.
  */

libsolidity/analysis/ContractLevelChecker.cpp

@@ -25,10 +25,10 @@
 #include <libsolidity/ast/AST.h>
 #include <libsolidity/ast/TypeProvider.h>
 #include <libsolidity/analysis/TypeChecker.h>
+#include <libsolutil/FunctionSelector.h>
 #include <liblangutil/ErrorReporter.h>
 #include <boost/range/adaptor/reversed.hpp>
 
-
 using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
@@ -433,6 +433,24 @@ 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())
+			// Will create an error later on.
+			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: ", errorHashes[hash]),
+				string("Error signature hash collision for ") + error->functionType(true)->externalSignature()
+			);
+		else
+			errorHashes[hash] = error->location();
+	}
 }
 
 void ContractLevelChecker::checkLibraryRequirements(ContractDefinition const& _contract)

libsolidity/analysis/DeclarationContainer.cpp

@@ -124,7 +124,7 @@ bool DeclarationContainer::registerDeclaration(
 		// Do not warn about shadowing for structs and enums because their members are
 		// not accessible without prefixes. Also do not warn about event parameters
 		// because they do not participate in any proper scope.
-		bool special = _declaration.scope() && (_declaration.isStructMember() || _declaration.isEnumValue() || _declaration.isEventParameter());
+		bool special = _declaration.scope() && (_declaration.isStructMember() || _declaration.isEnumValue() || _declaration.isEventOrErrorParameter());
 		if (m_enclosingContainer && !special)
 			m_homonymCandidates.emplace_back(*_name, _location ? _location : &_declaration.location());
 	}

libsolidity/analysis/DeclarationTypeChecker.cpp

@@ -368,7 +368,7 @@ void DeclarationTypeChecker::endVisit(VariableDeclaration const& _variable)
 	}
 
 	// Find correct data location.
-	if (_variable.isEventParameter())
+	if (_variable.isEventOrErrorParameter())
 	{
 		solAssert(varLoc == Location::Unspecified, "");
 		typeLoc = DataLocation::Memory;

libsolidity/analysis/DocStringAnalyser.cpp

@@ -158,6 +158,13 @@ bool DocStringAnalyser::visit(EventDefinition const& _event)
 	return true;
 }
 
+bool DocStringAnalyser::visit(ErrorDefinition const& _error)
+{
+	handleCallable(_error, _error, _error.annotation());
+
+	return true;
+}
+
 void DocStringAnalyser::handleCallable(
 	CallableDeclaration const& _callable,
 	StructurallyDocumented const& _node,

libsolidity/analysis/DocStringAnalyser.h

@@ -43,6 +43,7 @@ class DocStringAnalyser: private ASTConstVisitor
 	bool visit(VariableDeclaration const& _variable) override;
 	bool visit(ModifierDefinition const& _modifier) override;
 	bool visit(EventDefinition const& _event) override;
+	bool visit(ErrorDefinition const& _error) override;
 
 	CallableDeclaration const* resolveInheritDoc(
 		std::set<CallableDeclaration const*> const& _baseFunctions,

libsolidity/analysis/DocStringTagParser.cpp

@@ -92,6 +92,13 @@ bool DocStringTagParser::visit(EventDefinition const& _event)
 	return true;
 }
 
+bool DocStringTagParser::visit(ErrorDefinition const& _error)
+{
+	handleCallable(_error, _error, _error.annotation());
+
+	return true;
+}
+
 void DocStringTagParser::checkParameters(
 	CallableDeclaration const& _callable,
 	StructurallyDocumented const& _node,
@@ -134,11 +141,14 @@ void DocStringTagParser::handleCallable(
 )
 {
 	static set<string> const validEventTags = set<string>{"dev", "notice", "return", "param"};
+	static set<string> const validErrorTags = set<string>{"dev", "notice", "param"};
 	static set<string> const validModifierTags = set<string>{"dev", "notice", "param", "inheritdoc"};
 	static set<string> const validTags = set<string>{"dev", "notice", "return", "param", "inheritdoc"};
 
 	if (dynamic_cast<EventDefinition const*>(&_callable))
 		parseDocStrings(_node, _annotation, validEventTags, "events");
+	else if (dynamic_cast<ErrorDefinition const*>(&_callable))
+		parseDocStrings(_node, _annotation, validErrorTags, "errors");
 	else if (dynamic_cast<ModifierDefinition const*>(&_callable))
 		parseDocStrings(_node, _annotation, validModifierTags, "modifiers");
 	else

libsolidity/analysis/DocStringTagParser.h

@@ -44,6 +44,7 @@ class DocStringTagParser: private ASTConstVisitor
 	bool visit(VariableDeclaration const& _variable) override;
 	bool visit(ModifierDefinition const& _modifier) override;
 	bool visit(EventDefinition const& _event) override;
+	bool visit(ErrorDefinition const& _error) override;
 
 	void checkParameters(
 		CallableDeclaration const& _callable,

libsolidity/analysis/PostTypeChecker.cpp

@@ -23,6 +23,7 @@
 #include <liblangutil/ErrorReporter.h>
 #include <liblangutil/SemVerHandler.h>
 #include <libsolutil/Algorithms.h>
+#include <libsolutil/FunctionSelector.h>
 
 #include <boost/range/adaptor/map.hpp>
 #include <memory>
@@ -70,6 +71,11 @@ void PostTypeChecker::endVisit(VariableDeclaration const& _variable)
 	callEndVisit(_variable);
 }
 
+void PostTypeChecker::endVisit(ErrorDefinition const& _error)
+{
+	callEndVisit(_error);
+}
+
 bool PostTypeChecker::visit(EmitStatement const& _emit)
 {
 	return callVisit(_emit);
@@ -362,6 +368,33 @@ struct NoVariablesInInterfaceChecker: public PostTypeChecker::Checker
 	/// Flag indicating whether we are currently inside a StructDefinition.
 	int m_insideStruct = 0;
 };
+
+struct ReservedErrorSelector: public PostTypeChecker::Checker
+{
+	ReservedErrorSelector(ErrorReporter& _errorReporter):
+		Checker(_errorReporter)
+	{}
+
+	void endVisit(ErrorDefinition const& _error) override
+	{
+		if (_error.name() == "Error" || _error.name() == "Panic")
+			m_errorReporter.syntaxError(
+				1855_error,
+				_error.location(),
+				"The built-in errors \"Error\" and \"Panic\" cannot be re-defined."
+			);
+		else
+		{
+			uint32_t selector = selectorFromSignature32(_error.functionType(true)->externalSignature());
+			if (selector == 0 || ~selector == 0)
+				m_errorReporter.syntaxError(
+					2855_error,
+					_error.location(),
+					"The selector 0x" + toHex(toCompactBigEndian(selector, 4)) + " is reserved. Please rename the error to avoid the collision."
+				);
+		}
+	}
+};
 }
 
 PostTypeChecker::PostTypeChecker(langutil::ErrorReporter& _errorReporter): m_errorReporter(_errorReporter)
@@ -371,4 +404,5 @@ PostTypeChecker::PostTypeChecker(langutil::ErrorReporter& _errorReporter): m_err
 	m_checkers.push_back(make_shared<ModifierContextChecker>(_errorReporter));
 	m_checkers.push_back(make_shared<EventOutsideEmitChecker>(_errorReporter));
 	m_checkers.push_back(make_shared<NoVariablesInInterfaceChecker>(_errorReporter));
+	m_checkers.push_back(make_shared<ReservedErrorSelector>(_errorReporter));
 }