Parse contract layout specification

Author: matheusaaguiar

Changelog.md

@@ -1,6 +1,7 @@
 ### 0.8.29 (unreleased)
 
 Language Features:
+ * Introduce syntax for specifying contract storage layout base.
 
 
 Compiler Features:

docs/grammar/SolidityLexer.g4

@@ -14,6 +14,7 @@ Address: 'address';
 Anonymous: 'anonymous';
 As: 'as';
 Assembly: 'assembly' -> pushMode(AssemblyBlockMode);
+At: 'at'; // not a real keyword
 Bool: 'bool';
 Break: 'break';
 Bytes: 'bytes';
@@ -54,6 +55,7 @@ Indexed: 'indexed';
 Interface: 'interface';
 Internal: 'internal';
 Is: 'is';
+Layout: 'layout'; // not a real keyword
 Library: 'library';
 Mapping: 'mapping';
 Memory: 'memory';

docs/grammar/SolidityParser.g4

@@ -52,9 +52,14 @@ symbolAliases: LBrace aliases+=importAliases (Comma aliases+=importAliases)* RBr
 /**
  * Top-level definition of a contract.
  */
-contractDefinition:
+contractDefinition
+locals [boolean layoutSet=false, boolean inheritanceSet=false]
+:
 	Abstract? Contract name=identifier
-	inheritanceSpecifierList?
+	(
+		{!$layoutSet}? Layout At expression {$layoutSet = true;}
+		| {!$inheritanceSet}? inheritanceSpecifierList {$inheritanceSet = true;}
+	)*
 	LBrace contractBodyElement* RBrace;
 /**
  * Top-level definition of an interface.
@@ -379,7 +384,7 @@ expression:
 	expression LBrack index=expression? RBrack # IndexAccess
 	| expression LBrack startIndex=expression? Colon endIndex=expression? RBrack # IndexRangeAccess
 	| expression Period (identifier | Address) # MemberAccess
-	| expression LBrace (namedArgument (Comma namedArgument)*)? RBrace # FunctionCallOptions
+	| expression LBrace (namedArgument (Comma namedArgument)*) RBrace # FunctionCallOptions
 	| expression callArgumentList # FunctionCall
 	| Payable callArgumentList # PayableConversion
 	| Type LParen typeName RParen # MetaType
@@ -420,7 +425,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 | Revert | Global | Transient;
+identifier: Identifier | From | Error | Revert | Global | Transient | Layout | At;
 
 literal: stringLiteral | numberLiteral | booleanLiteral | hexStringLiteral | unicodeStringLiteral;
 

liblangutil/ErrorReporter.cpp

@@ -190,6 +190,17 @@ void ErrorReporter::parserError(ErrorId _error, SourceLocation const& _location,
 	);
 }
 
+void ErrorReporter::parserError(ErrorId _error, SourceLocation const& _location, SecondarySourceLocation const& _secondaryLocation, std::string const& _description)
+{
+	error(
+		_error,
+		Error::Type::ParserError,
+		_location,
+		_secondaryLocation,
+		_description
+	);
+}
+
 void ErrorReporter::fatalParserError(ErrorId _error, SourceLocation const& _location, std::string const& _description)
 {
 	fatalError(

liblangutil/ErrorReporter.h

@@ -87,6 +87,7 @@ class ErrorReporter
 	void fatalDeclarationError(ErrorId _error, SourceLocation const& _location, std::string const& _description);
 
 	void parserError(ErrorId _error, SourceLocation const& _location, std::string const& _description);
+	void parserError(ErrorId _error, SourceLocation const& _location, SecondarySourceLocation const& _secondaryLocation, std::string const& _description);
 
 	void fatalParserError(ErrorId _error, SourceLocation const& _location, std::string const& _description);
 

libsolidity/analysis/NameAndTypeResolver.cpp

@@ -299,6 +299,10 @@ bool NameAndTypeResolver::resolveNamesAndTypesInternal(ASTNode& _node, bool _res
 			if (!resolveNamesAndTypesInternal(*baseContract, true))
 				success = false;
 
+		if (StorageLayoutSpecifier* storageLayoutSpecifier = contract->storageLayoutSpecifier())
+			if (!resolveNamesAndTypesInternal(*storageLayoutSpecifier, true))
+				success = false;
+
 		setScope(contract);
 
 		if (success)

libsolidity/analysis/TypeChecker.cpp

@@ -86,6 +86,9 @@ bool TypeChecker::visit(ContractDefinition const& _contract)
 
 	ASTNode::listAccept(_contract.baseContracts(), *this);
 
+	if (StorageLayoutSpecifier const* layoutSpecifier = _contract.storageLayoutSpecifier())
+		layoutSpecifier->accept(*this);
+
 	for (auto const& n: _contract.subNodes())
 		n->accept(*this);
 

libsolidity/ast/AST.cpp

@@ -371,6 +371,17 @@ std::multimap<std::string, FunctionDefinition const*> const& ContractDefinition:
 	});
 }
 
+StorageLayoutSpecifier::StorageLayoutSpecifier(
+	int64_t _id,
+	SourceLocation const& _location,
+	ASTPointer<Expression> _baseSlotExpression
+):
+	ASTNode(_id, _location),
+	m_baseSlotExpression(_baseSlotExpression)
+{
+	solAssert(m_baseSlotExpression);
+	solAssert(_location.contains(m_baseSlotExpression->location()));
+}
 
 TypeNameAnnotation& TypeName::annotation() const
 {

libsolidity/ast/AST.h

@@ -509,14 +509,16 @@ class ContractDefinition: public Declaration, public StructurallyDocumented, pub
 		std::vector<ASTPointer<InheritanceSpecifier>> _baseContracts,
 		std::vector<ASTPointer<ASTNode>> _subNodes,
 		ContractKind _contractKind = ContractKind::Contract,
-		bool _abstract = false
+		bool _abstract = false,
+		ASTPointer<StorageLayoutSpecifier> _storageLayoutSpecifier = nullptr
 	):
 		Declaration(_id, _location, _name, std::move(_nameLocation)),
 		StructurallyDocumented(_documentation),
 		m_baseContracts(std::move(_baseContracts)),
 		m_subNodes(std::move(_subNodes)),
 		m_contractKind(_contractKind),
-		m_abstract(_abstract)
+		m_abstract(_abstract),
+		m_storageLayoutSpecifier(_storageLayoutSpecifier)
 	{}
 
 	void accept(ASTVisitor& _visitor) override;
@@ -586,6 +588,9 @@ class ContractDefinition: public Declaration, public StructurallyDocumented, pub
 
 	bool abstract() const { return m_abstract; }
 
+	StorageLayoutSpecifier const* storageLayoutSpecifier() const { return m_storageLayoutSpecifier.get(); }
+	StorageLayoutSpecifier* storageLayoutSpecifier() { return m_storageLayoutSpecifier.get(); }
+
 	ContractDefinition const* superContract(ContractDefinition const& _mostDerivedContract) const;
 	/// @returns the next constructor in the inheritance hierarchy.
 	FunctionDefinition const* nextConstructor(ContractDefinition const& _mostDerivedContract) const;
@@ -597,12 +602,30 @@ class ContractDefinition: public Declaration, public StructurallyDocumented, pub
 	std::vector<ASTPointer<ASTNode>> m_subNodes;
 	ContractKind m_contractKind;
 	bool m_abstract{false};
+	ASTPointer<StorageLayoutSpecifier> m_storageLayoutSpecifier;
 
 	util::LazyInit<std::vector<std::pair<util::FixedHash<4>, FunctionTypePointer>>> m_interfaceFunctionList[2];
 	util::LazyInit<std::vector<EventDefinition const*>> m_interfaceEvents;
 	util::LazyInit<std::multimap<std::string, FunctionDefinition const*>> m_definedFunctionsByName;
 };
 
+
+class StorageLayoutSpecifier : public ASTNode
+{
+public:
+	StorageLayoutSpecifier(
+		int64_t _id,
+		SourceLocation const& _location,
+		ASTPointer<Expression> _baseSlotExpression
+	);
+	void accept(ASTVisitor& _visitor) override;
+	void accept(ASTConstVisitor& _visitor) const override;
+
+	Expression const& baseSlotExpression() const { solAssert(m_baseSlotExpression); return *m_baseSlotExpression; }
+private:
+	ASTPointer<Expression> m_baseSlotExpression;
+};
+
 /**
  * A sequence of identifiers separated by dots used outside the expression context. Inside the expression context, this is a sequence of Identifier and MemberAccess.
  */

libsolidity/ast/ASTForward.h

@@ -98,6 +98,7 @@ class Identifier;
 class ElementaryTypeNameExpression;
 class Literal;
 class StructuredDocumentation;
+class StorageLayoutSpecifier;
 
 /// Experimental Solidity nodes
 /// @{

libsolidity/ast/ASTJsonExporter.cpp

@@ -210,6 +210,13 @@ Json ASTJsonExporter::toJson(ASTNode const& _node)
 	return util::removeNullMembers(std::move(m_currentValue));
 }
 
+Json ASTJsonExporter::toJson(ASTNode const* _node)
+{
+	if (!_node)
+		return Json();
+	return toJson(*_node);
+}
+
 bool ASTJsonExporter::visit(SourceUnit const& _node)
 {
 	std::vector<std::pair<std::string, Json>> attributes = {
@@ -279,6 +286,14 @@ bool ASTJsonExporter::visit(ImportDirective const& _node)
 	return false;
 }
 
+bool ASTJsonExporter::visit(StorageLayoutSpecifier const& _node)
+{
+	setJsonNode(_node, "StorageLayoutSpecifier", {
+		{"baseSlotExpression", toJson(_node.baseSlotExpression())}
+	});
+	return false;
+}
+
 bool ASTJsonExporter::visit(ContractDefinition const& _node)
 {
 	std::vector<std::pair<std::string, Json>> attributes = {
@@ -293,7 +308,8 @@ bool ASTJsonExporter::visit(ContractDefinition const& _node)
 		std::make_pair("usedEvents", getContainerIds(_node.interfaceEvents(false))),
 		std::make_pair("usedErrors", getContainerIds(_node.interfaceErrors(false))),
 		std::make_pair("nodes", toJson(_node.subNodes())),
-		std::make_pair("scope", idOrNull(_node.scope()))
+		std::make_pair("scope", idOrNull(_node.scope())),
+		std::make_pair("storageLayout", toJson(_node.storageLayoutSpecifier()))
 	};
 	addIfSet(attributes, "canonicalName", _node.annotation().canonicalName);
 

libsolidity/ast/ASTJsonExporter.h

@@ -60,6 +60,7 @@ class ASTJsonExporter: public ASTConstVisitor
 	/// Output the json representation of the AST to _stream.
 	void print(std::ostream& _stream, ASTNode const& _node, util::JsonFormat const& _format);
 	Json toJson(ASTNode const& _node);
+	Json toJson(ASTNode const* _node);
 	template <class T>
 	Json toJson(std::vector<ASTPointer<T>> const& _nodes)
 	{
@@ -126,6 +127,7 @@ class ASTJsonExporter: public ASTConstVisitor
 	bool visit(ElementaryTypeNameExpression const& _node) override;
 	bool visit(Literal const& _node) override;
 	bool visit(StructuredDocumentation const& _node) override;
+	bool visit(StorageLayoutSpecifier const& _node) override;
 
 	void endVisit(EventDefinition const&) override;
 

libsolidity/ast/ASTJsonImporter.cpp

@@ -37,6 +37,8 @@
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string.hpp>
 
+#include <range/v3/algorithm/find_if.hpp>
+
 namespace solidity::frontend
 {
 
@@ -255,6 +257,8 @@ ASTPointer<ASTNode> ASTJsonImporter::convertJsonToASTNode(Json const& _json)
 		return createLiteral(_json);
 	if (nodeType == "StructuredDocumentation")
 		return createDocumentation(_json);
+	if (nodeType == "StorageLayoutSpecifier")
+		return createStorageLayoutSpecifier(_json);
 	else
 		astAssert(false, "Unknown type of ASTNode: " + nodeType);
 
@@ -348,7 +352,17 @@ ASTPointer<ContractDefinition> ASTJsonImporter::createContractDefinition(Json co
 		baseContracts,
 		subNodes,
 		contractKind(_node),
-		memberAsBool(_node, "abstract")
+		memberAsBool(_node, "abstract"),
+		nullOrCast<StorageLayoutSpecifier>(member(_node, "storageLayout"))
+	);
+}
+
+ASTPointer<StorageLayoutSpecifier> ASTJsonImporter::createStorageLayoutSpecifier(Json const& _node)
+{
+	astAssert(_node.contains("baseSlotExpression"), "Expected field \"baseSlotExpression\" is missing.");
+	return createASTNode<StorageLayoutSpecifier>(
+		_node,
+		convertJsonToASTNode<Expression>(_node["baseSlotExpression"])
 	);
 }
 

libsolidity/ast/ASTJsonImporter.h

@@ -131,10 +131,11 @@ class ASTJsonImporter
 	ASTPointer<ElementaryTypeNameExpression> createElementaryTypeNameExpression(Json const& _node);
 	ASTPointer<ASTNode> createLiteral(Json const& _node);
 	ASTPointer<StructuredDocumentation> createDocumentation(Json const& _node);
+	ASTPointer<StorageLayoutSpecifier> createStorageLayoutSpecifier(Json const& _node);
 	///@}
 
 	// =============== general helper functions ===================
-	/// @returns the member of a given JSON object, throws if member does not exist
+	/// @returns the member of a given JSON object or null if member does not exist
 	Json member(Json const& _node, std::string const& _name);
 	/// @returns the appropriate TokenObject used in parsed Strings (pragma directive or operator)
 	Token scanSingleToken(Json const& _node);

libsolidity/ast/ASTVisitor.h

@@ -109,6 +109,7 @@ class ASTVisitor
 	virtual bool visit(ElementaryTypeNameExpression& _node) { return visitNode(_node); }
 	virtual bool visit(Literal& _node) { return visitNode(_node); }
 	virtual bool visit(StructuredDocumentation& _node) { return visitNode(_node); }
+	virtual bool visit(StorageLayoutSpecifier& _node) { return visitNode(_node); }
 	/// Experimental Solidity nodes
 	/// @{
 	virtual bool visit(TypeClassDefinition& _node) { return visitNode(_node); }
@@ -174,6 +175,7 @@ class ASTVisitor
 	virtual void endVisit(ElementaryTypeNameExpression& _node) { endVisitNode(_node); }
 	virtual void endVisit(Literal& _node) { endVisitNode(_node); }
 	virtual void endVisit(StructuredDocumentation& _node) { endVisitNode(_node); }
+	virtual void endVisit(StorageLayoutSpecifier& _node) { endVisitNode(_node); }
 	/// Experimental Solidity nodes
 	/// @{
 	virtual void endVisit(TypeClassDefinition& _node) { endVisitNode(_node); }
@@ -261,6 +263,7 @@ class ASTConstVisitor
 	virtual bool visit(ElementaryTypeNameExpression const& _node) { return visitNode(_node); }
 	virtual bool visit(Literal const& _node) { return visitNode(_node); }
 	virtual bool visit(StructuredDocumentation const& _node) { return visitNode(_node); }
+	virtual bool visit(StorageLayoutSpecifier const& _node) { return visitNode(_node); }
 	/// Experimental Solidity nodes
 	/// @{
 	virtual bool visit(TypeClassDefinition const& _node) { return visitNode(_node); }
@@ -326,6 +329,7 @@ class ASTConstVisitor
 	virtual void endVisit(ElementaryTypeNameExpression const& _node) { endVisitNode(_node); }
 	virtual void endVisit(Literal const& _node) { endVisitNode(_node); }
 	virtual void endVisit(StructuredDocumentation const& _node) { endVisitNode(_node); }
+	virtual void endVisit(StorageLayoutSpecifier const& _node) { endVisitNode(_node); }
 	/// Experimental Solidity nodes
 	/// @{
 	virtual void endVisit(TypeClassDefinition const& _node) { endVisitNode(_node); }

libsolidity/ast/AST_accept.h

@@ -93,6 +93,8 @@ void ContractDefinition::accept(ASTVisitor& _visitor)
 		if (m_documentation)
 			m_documentation->accept(_visitor);
 		listAccept(m_baseContracts, _visitor);
+		if (m_storageLayoutSpecifier)
+			m_storageLayoutSpecifier->accept(_visitor);
 		listAccept(m_subNodes, _visitor);
 	}
 	_visitor.endVisit(*this);
@@ -105,6 +107,8 @@ void ContractDefinition::accept(ASTConstVisitor& _visitor) const
 		if (m_documentation)
 			m_documentation->accept(_visitor);
 		listAccept(m_baseContracts, _visitor);
+		if (m_storageLayoutSpecifier)
+			m_storageLayoutSpecifier->accept(_visitor);
 		listAccept(m_subNodes, _visitor);
 	}
 	_visitor.endVisit(*this);
@@ -1160,6 +1164,22 @@ void ForAllQuantifier::accept(ASTConstVisitor& _visitor) const
 	}
 	_visitor.endVisit(*this);
 }
+
+void StorageLayoutSpecifier::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+		m_baseSlotExpression->accept(_visitor);
+
+	_visitor.endVisit(*this);
+}
+
+void StorageLayoutSpecifier::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+		m_baseSlotExpression->accept(_visitor);
+
+	_visitor.endVisit(*this);
+}
 /// @}
 
 }

libsolidity/interface/CompilerStack.cpp

@@ -1104,6 +1104,7 @@ Json const& CompilerStack::storageLayout(Contract const& _contract) const
 	solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
 	solAssert(_contract.contract);
 	solUnimplementedAssert(!isExperimentalSolidity());
+	solUnimplementedAssert(!_contract.contract->storageLayoutSpecifier(), "Storage layout not supported for contract with specified layout base.");
 
 	return _contract.storageLayout.init([&]{ return StorageLayout().generate(*_contract.contract, DataLocation::Storage); });
 }
@@ -1523,6 +1524,7 @@ void CompilerStack::compileContract(
 	solAssert(!m_viaIR, "");
 	solUnimplementedAssert(!m_eofVersion.has_value(), "Experimental EOF support is only available for via-IR compilation.");
 	solAssert(m_stackState >= AnalysisSuccessful, "");
+	solUnimplementedAssert(!_contract.storageLayoutSpecifier(), "Code generation is not supported for contracts with specified storage layout base.");
 
 	if (_otherCompilers.count(&_contract))
 		return;
@@ -1558,7 +1560,7 @@ void CompilerStack::compileContract(
 void CompilerStack::generateIR(ContractDefinition const& _contract, bool _unoptimizedOnly)
 {
 	solAssert(m_stackState >= AnalysisSuccessful, "");
-
+	solUnimplementedAssert(!_contract.storageLayoutSpecifier(), "Code generation is not supported for contracts with specified storage layout base.");
 	Contract& compiledContract = m_contracts.at(_contract.fullyQualifiedName());
 	if (compiledContract.yulIR)
 	{