Merge pull request #1501 from LefterisJP/abstract_contract_contructors

Abstract contract contructors

AST.cpp

@@ -54,6 +54,7 @@ void ContractDefinition::checkTypeRequirements()
 
 	checkIllegalOverrides();
 	checkAbstractFunctions();
+	checkAbstractConstructors();
 
 	FunctionDefinition const* constructor = getConstructor();
 	if (constructor && !constructor->getReturnParameters().empty())
@@ -152,6 +153,45 @@ void ContractDefinition::checkAbstractFunctions()
 		}
 }
 
+void ContractDefinition::checkAbstractConstructors()
+{
+	set<ContractDefinition const*> argumentsNeeded;
+	// check that we get arguments for all base constructors that need it.
+	// If not mark the contract as abstract (not fully implemented)
+
+	vector<ContractDefinition const*> const& bases = getLinearizedBaseContracts();
+	for (ContractDefinition const* contract: bases)
+		if (FunctionDefinition const* constructor = contract->getConstructor())
+			if (contract != this && !constructor->getParameters().empty())
+				argumentsNeeded.insert(contract);
+
+	for (ContractDefinition const* contract: bases)
+	{
+		if (FunctionDefinition const* constructor = contract->getConstructor())
+			for (auto const& modifier: constructor->getModifiers())
+			{
+				auto baseContract = dynamic_cast<ContractDefinition const*>(
+					modifier->getName()->getReferencedDeclaration()
+				);
+				if (baseContract)
+					argumentsNeeded.erase(baseContract);
+			}
+
+
+		for (ASTPointer<InheritanceSpecifier> const& base: contract->getBaseContracts())
+		{
+			auto baseContract = dynamic_cast<ContractDefinition const*>(
+				base->getName()->getReferencedDeclaration()
+			);
+			solAssert(baseContract, "");
+			if (!base->getArguments().empty())
+				argumentsNeeded.erase(baseContract);
+		}
+	}
+	if (!argumentsNeeded.empty())
+		setFullyImplemented(false);
+}
+
 void ContractDefinition::checkIllegalOverrides() const
 {
 	// TODO unify this at a later point. for this we need to put the constness and the access specifier
@@ -281,7 +321,7 @@ void InheritanceSpecifier::checkTypeRequirements()
 	ContractDefinition const* base = dynamic_cast<ContractDefinition const*>(m_baseName->getReferencedDeclaration());
 	solAssert(base, "Base contract not available.");
 	TypePointers parameterTypes = ContractType(*base).getConstructorType()->getParameterTypes();
-	if (parameterTypes.size() != m_arguments.size())
+	if (!m_arguments.empty() && parameterTypes.size() != m_arguments.size())
 		BOOST_THROW_EXCEPTION(createTypeError("Wrong argument count for constructor call."));
 	for (size_t i = 0; i < m_arguments.size(); ++i)
 		if (!m_arguments[i]->getType()->isImplicitlyConvertibleTo(*parameterTypes[i]))
@@ -348,8 +388,8 @@ void FunctionDefinition::checkTypeRequirements()
 	}
 	for (ASTPointer<ModifierInvocation> const& modifier: m_functionModifiers)
 		modifier->checkTypeRequirements(isConstructor() ?
-			dynamic_cast<ContractDefinition const&>(*getScope()).getBaseContracts() :
+			dynamic_cast<ContractDefinition const&>(*getScope()).getLinearizedBaseContracts() :
-			vector<ASTPointer<InheritanceSpecifier>>());
+			vector<ContractDefinition const*>());
 	if (m_body)
 		m_body->checkTypeRequirements();
 }
@@ -426,7 +466,7 @@ void ModifierDefinition::checkTypeRequirements()
 	m_body->checkTypeRequirements();
 }
 
-void ModifierInvocation::checkTypeRequirements(vector<ASTPointer<InheritanceSpecifier>> const& _bases)
+void ModifierInvocation::checkTypeRequirements(vector<ContractDefinition const*> const& _bases)
 {
 	m_modifierName->checkTypeRequirements();
 	for (ASTPointer<Expression> const& argument: m_arguments)
@@ -439,10 +479,10 @@ void ModifierInvocation::checkTypeRequirements(vector<ASTPointer<InheritanceSpec
 		parameters = &modifier->getParameters();
 	else
 		// check parameters for Base constructors
-		for (auto const& base: _bases)
+		for (auto const* base: _bases)
-			if (declaration == base->getName()->getReferencedDeclaration())
+			if (declaration == base)
 			{
-				if (auto referencedConstructor = dynamic_cast<ContractDefinition const&>(*declaration).getConstructor())
+				if (auto referencedConstructor = base->getConstructor())
 					parameters = &referencedConstructor->getParameters();
 				else
 					parameters = &emptyParameterList;
@@ -686,7 +726,7 @@ void NewExpression::checkTypeRequirements()
 	if (!m_contract)
 		BOOST_THROW_EXCEPTION(createTypeError("Identifier is not a contract."));
 	if (!m_contract->isFullyImplemented())
-		BOOST_THROW_EXCEPTION(m_contract->createTypeError("Trying to create an instance of an abstract contract."));
+		BOOST_THROW_EXCEPTION(createTypeError("Trying to create an instance of an abstract contract."));
 	shared_ptr<ContractType const> contractType = make_shared<ContractType>(*m_contract);
 	TypePointers const& parameterTypes = contractType->getConstructorType()->getParameterTypes();
 	m_type = make_shared<FunctionType>(parameterTypes, TypePointers{contractType},

AST.h

@@ -284,6 +284,7 @@ public:
 private:
 	void checkIllegalOverrides() const;
 	void checkAbstractFunctions();
+	void checkAbstractConstructors();
 
 	std::vector<std::pair<FixedHash<4>, FunctionTypePointer>> const& getInterfaceFunctionList() const;
 
@@ -376,7 +377,7 @@ class EnumValue: public Declaration
 
 	virtual void accept(ASTVisitor& _visitor) override;
 	virtual void accept(ASTConstVisitor& _visitor) const override;
-	TypePointer getType(ContractDefinition const* = nullptr) const;
+	virtual TypePointer getType(ContractDefinition const* = nullptr) const override;
 };
 
 /**
@@ -566,7 +567,7 @@ public:
 	std::vector<ASTPointer<Expression>> const& getArguments() const { return m_arguments; }
 
 	/// @param _bases is the list of base contracts for base constructor calls. For modifiers an empty vector should be passed.
-	void checkTypeRequirements(std::vector<ASTPointer<InheritanceSpecifier>> const& _bases);
+	void checkTypeRequirements(std::vector<ContractDefinition const*> const& _bases);
 
 private:
 	ASTPointer<Identifier> m_modifierName;

Compiler.cpp

@@ -136,6 +136,7 @@ void Compiler::appendBaseConstructor(FunctionDefinition const& _constructor)
 	FunctionType constructorType(_constructor);
 	if (!constructorType.getParameterTypes().empty())
 	{
+		solAssert(m_baseArguments.count(&_constructor), "");
 		std::vector<ASTPointer<Expression>> const* arguments = m_baseArguments[&_constructor];
 		solAssert(arguments, "");
 		for (unsigned i = 0; i < arguments->size(); ++i)

CompilerStack.cpp

@@ -157,14 +157,16 @@ bytes const& CompilerStack::compile(string const& _sourceCode, bool _optimize)
 	return getBytecode();
 }
 
-eth::AssemblyItems const& CompilerStack::getAssemblyItems(string const& _contractName) const
+eth::AssemblyItems const* CompilerStack::getAssemblyItems(string const& _contractName) const
 {
-	return getContract(_contractName).compiler->getAssemblyItems();
+	Contract const& contract = getContract(_contractName);
+	return contract.compiler ? &getContract(_contractName).compiler->getAssemblyItems() : nullptr;
 }
 
-eth::AssemblyItems const& CompilerStack::getRuntimeAssemblyItems(string const& _contractName) const
+eth::AssemblyItems const* CompilerStack::getRuntimeAssemblyItems(string const& _contractName) const
 {
-	return getContract(_contractName).compiler->getRuntimeAssemblyItems();
+	Contract const& contract = getContract(_contractName);
+	return contract.compiler ? &getContract(_contractName).compiler->getRuntimeAssemblyItems() : nullptr;
 }
 
 bytes const& CompilerStack::getBytecode(string const& _contractName) const
@@ -184,7 +186,11 @@ dev::h256 CompilerStack::getContractCodeHash(string const& _contractName) const
 
 void CompilerStack::streamAssembly(ostream& _outStream, string const& _contractName, StringMap _sourceCodes) const
 {
+	Contract const& contract = getContract(_contractName);
+	if (contract.compiler)
 		getContract(_contractName).compiler->streamAssembly(_outStream, _sourceCodes);
+	else
+		_outStream << "Contract not fully implemented" << endl;
 }
 
 string const& CompilerStack::getInterface(string const& _contractName) const

CompilerStack.h

@@ -94,9 +94,9 @@ public:
 	/// @returns the runtime bytecode for the contract, i.e. the code that is returned by the constructor.
 	bytes const& getRuntimeBytecode(std::string const& _contractName = "") const;
 	/// @returns normal contract assembly items
-	eth::AssemblyItems const& getAssemblyItems(std::string const& _contractName = "") const;
+	eth::AssemblyItems const* getAssemblyItems(std::string const& _contractName = "") const;
 	/// @returns runtime contract assembly items
-	eth::AssemblyItems const& getRuntimeAssemblyItems(std::string const& _contractName = "") const;
+	eth::AssemblyItems const* getRuntimeAssemblyItems(std::string const& _contractName = "") const;
 	/// @returns hash of the runtime bytecode for the contract, i.e. the code that is returned by the constructor.
 	dev::h256 getContractCodeHash(std::string const& _contractName = "") const;