changed the test so constructor will have input parameters

libsolidity/AST.cpp

@@ -817,7 +817,10 @@ void NewExpression::checkTypeRequirements(TypePointers const*)
 		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},
+	m_type = make_shared<FunctionType>(
+		parameterTypes,
+		TypePointers{contractType},
+		strings(),
 		FunctionType::Location::Creation);
 }
 

libsolidity/ExpressionCompiler.cpp

@@ -521,8 +521,19 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 			arguments.front()->accept(*this);
 			appendTypeConversion(*arguments.front()->getType(),
 								 *function.getParameterTypes().front(), true);
-			appendExternalFunctionCall(FunctionType(TypePointers{}, TypePointers{},
+			appendExternalFunctionCall(
-													Location::External, false, true, true), {}, true);
+				FunctionType(
+					TypePointers{},
+					TypePointers{},
+					strings(),
+					Location::External,
+					false,
+					true,
+					true
+				),
+				{},
+				true
+			);
 			break;
 		case Location::Suicide:
 			arguments.front()->accept(*this);

libsolidity/Types.cpp

@@ -1143,7 +1143,7 @@ FunctionTypePointer FunctionType::externalFunctionType() const
 			return FunctionTypePointer();
 		retParamTypes.push_back(type->externalType());
 	}
-	return make_shared<FunctionType>(paramTypes, retParamTypes, m_location, m_arbitraryParameters);
+	return make_shared<FunctionType>(paramTypes, retParamTypes, m_parameterNames, m_location, m_arbitraryParameters);
 }
 
 MemberList const& FunctionType::getMembers() const
@@ -1159,14 +1159,34 @@ MemberList const& FunctionType::getMembers() const
 		if (!m_members)
 		{
 			MemberList::MemberMap members{
-				{"value", make_shared<FunctionType>(parseElementaryTypeVector({"uint"}),
+				{
+					"value",
+					make_shared<FunctionType>(
+						parseElementaryTypeVector({"uint"}),
 						TypePointers{copyAndSetGasOrValue(false, true)},
-													Location::SetValue, false, m_gasSet, m_valueSet)}};
+						strings(),
+						Location::SetValue,
+						false,
+						m_gasSet,
+						m_valueSet
+					)
+				}
+			};
 			if (m_location != Location::Creation)
-				members.push_back(MemberList::Member("gas", make_shared<FunctionType>(
+				members.push_back(
+					MemberList::Member(
+						"gas",
+						make_shared<FunctionType>(
 							parseElementaryTypeVector({"uint"}),
 							TypePointers{copyAndSetGasOrValue(true, false)},
-												Location::SetGas, false, m_gasSet, m_valueSet)));
+							strings(),
+							Location::SetGas,
+							false,
+							m_gasSet,
+							m_valueSet
+						)
+					)
+				);
 			m_members.reset(new MemberList(members));
 		}
 		return *m_members;
@@ -1244,9 +1264,15 @@ TypePointers FunctionType::parseElementaryTypeVector(strings const& _types)
 
 TypePointer FunctionType::copyAndSetGasOrValue(bool _setGas, bool _setValue) const
 {
-	return make_shared<FunctionType>(m_parameterTypes, m_returnParameterTypes, m_location,
+	return make_shared<FunctionType>(
+		m_parameterTypes,
+		m_returnParameterTypes,
+		strings(),
+		m_location,
 		m_arbitraryParameters,
-									 m_gasSet || _setGas, m_valueSet || _setValue);
+		m_gasSet || _setGas,
+		m_valueSet || _setValue
+	);
 }
 
 vector<string> const FunctionType::getParameterTypeNames() const

libsolidity/Types.h

@@ -564,13 +564,24 @@ public:
 	explicit FunctionType(FunctionDefinition const& _function, bool _isInternal = true);
 	explicit FunctionType(VariableDeclaration const& _varDecl);
 	explicit FunctionType(EventDefinition const& _event);
-	FunctionType(strings const& _parameterTypes, strings const& _returnParameterTypes,
+	FunctionType(
-				 Location _location = Location::Internal, bool _arbitraryParameters = false):
+		strings const& _parameterTypes,
-		FunctionType(parseElementaryTypeVector(_parameterTypes), parseElementaryTypeVector(_returnParameterTypes),
+		strings const& _returnParameterTypes,
-					 _location, _arbitraryParameters) {}
+		Location _location = Location::Internal,
+		bool _arbitraryParameters = false
+	): FunctionType(
+		parseElementaryTypeVector(_parameterTypes),
+		parseElementaryTypeVector(_returnParameterTypes),
+		strings(),
+		_location,
+		_arbitraryParameters
+	)
+	{
+	}
 	FunctionType(
 		TypePointers const& _parameterTypes,
 		TypePointers const& _returnParameterTypes,
+		strings _parameterNames = strings(),
 		Location _location = Location::Internal,
 		bool _arbitraryParameters = false,
 		bool _gasSet = false,
@@ -578,6 +589,7 @@ public:
 	):
 		m_parameterTypes (_parameterTypes),
 		m_returnParameterTypes (_returnParameterTypes),
+		m_parameterNames (_parameterNames),
 		m_location (_location),
 		m_arbitraryParameters (_arbitraryParameters),
 		m_gasSet (_gasSet),

test/libsolidity/SolidityABIJSON.cpp

@@ -499,14 +499,27 @@ BOOST_AUTO_TEST_CASE(constructor_abi)
 {
 	char const* sourceCode = R"(
 		contract test {
-			function test() {
+			function test(uint param1, test param2, bool param3) {}
 		}
-	})";
+	)";
 
 	char const* interface = R"([
 	{
-	   "inputs" : [],
+		"inputs": [
-	   "type" : "constructor"
+			{
+				"name": "param1",
+				"type": "uint256"
+			},
+			{
+				"name": "param2",
+				"type": "address"
+			},
+			{
+				"name": "param3",
+				"type": "bool"
+			}
+		],
+		"type": "constructor"
 	}
 	])";
 	checkInterface(sourceCode, interface);