miner changes in the implementation of the externalTypes function of FunctionType.

better error messages for exeptions
style fixes after review

libsolidity/AST.cpp

@@ -339,12 +339,11 @@ void FunctionDefinition::checkTypeRequirements()
 			BOOST_THROW_EXCEPTION(var->createTypeError("Type is required to live outside storage."));
 		if (getVisibility() >= Visibility::Public && !(var->getType()->externalType()))
 		{
-			// todo delete when arrays as parameter type in internal functions will be implemented
+			// todo delete when will be implemented arrays as parameter type in internal functions
-			ArrayType const* type = dynamic_cast<ArrayType const*>(var->getType().get());
+			if (getVisibility() == Visibility::Public && var->getType()->getCategory() == Type::Category::Array)
-			if (getVisibility() == Visibility::Public && type)
 				BOOST_THROW_EXCEPTION(var->createTypeError("Array type is not allowed as parameter for internal functions."));
 			else
-				BOOST_THROW_EXCEPTION(var->createTypeError("Internal type is not allowed for function with external visibility."));
+				BOOST_THROW_EXCEPTION(var->createTypeError("Internal type is not allowed for public and external functions."));
 		}
 	}
 	for (ASTPointer<ModifierInvocation> const& modifier: m_functionModifiers)
@@ -389,12 +388,11 @@ void VariableDeclaration::checkTypeRequirements()
 
 		auto sharedToExternalTypes = FunctionType(*this).externalType(); // do not distroy the shared pointer.
 		auto externalFunctionTypes = dynamic_cast<FunctionType const*>(sharedToExternalTypes.get());
-		TypePointers retParamTypes = externalFunctionTypes->getReturnParameterTypes();
+		for (auto parameter: externalFunctionTypes->getParameterTypes() + externalFunctionTypes->getReturnParameterTypes())
-		TypePointers parameterTypes = externalFunctionTypes->getParameterTypes();
+			if (!parameter || !(parameter->externalType()))
-		for (auto parameter: parameterTypes + retParamTypes)
+				BOOST_THROW_EXCEPTION(createTypeError("Internal type is not allowed for public state variables."));
-		if (!parameter && !(parameter->externalType()))
+	}
-			BOOST_THROW_EXCEPTION(createTypeError("Internal type is not allowed for state variables."));
+	else
-	} else
 	{
 		// no type declared and no previous assignment, infer the type
 		m_value->checkTypeRequirements();

libsolidity/Types.cpp

@@ -1103,15 +1103,17 @@ TypePointer FunctionType::externalType() const
 	TypePointers paramTypes;
 	TypePointers retParamTypes;
 
-	for(auto type: m_parameterTypes)
+	for (auto type: m_parameterTypes)
 	{
-		solAssert(!!type->externalType(), "To be included in external type of the function, the argument should have external type.");
+		if(!type->externalType())
+			return TypePointer();
 		paramTypes.push_back(type->externalType());
 	}
-	for(auto param: m_returnParameterTypes)
+	for (auto type: m_returnParameterTypes)
 	{
-		solAssert(!!param->externalType(), "To be included in external type of the function, the argument should have external type.");
+		if(!type->externalType())
-		retParamTypes.push_back(param->externalType());
+			return TypePointer();
+		retParamTypes.push_back(type->externalType());
 	}
 	return make_shared<FunctionType>(paramTypes, retParamTypes, m_location, m_arbitraryParameters);
 }

libsolidity/Types.h

@@ -512,6 +512,8 @@ public:
 
 	virtual Category getCategory() const override { return Category::Function; }
 
+	/// @returns TypePointer of a new FunctionType object. All input/return parameters are an appropriate external types of input/return parameters of current function.
+	/// Returns an empty shared pointer if one of input/return parameters does not have an externaltype.
 	virtual TypePointer externalType() const override;
 
 	explicit FunctionType(FunctionDefinition const& _function, bool _isInternal = true);