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

better error messages for exeptions
style fixes after review

3 files changed, 17 insertions, 15 deletions

diff --git a/AST.cpp b/AST.cpp
index a111a6f8..d489a448 100644
--- a/AST.cpp
+++ b/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
-			ArrayType const* type = dynamic_cast<ArrayType const*>(var->getType().get());
-			if (getVisibility() == Visibility::Public && type)
+			// todo delete when will be implemented arrays as parameter type in internal functions
+			if (getVisibility() == Visibility::Public && var->getType()->getCategory() == Type::Category::Array)
 				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();
-		TypePointers parameterTypes = externalFunctionTypes->getParameterTypes();
-		for (auto parameter: parameterTypes + retParamTypes)
-		if (!parameter && !(parameter->externalType()))
-			BOOST_THROW_EXCEPTION(createTypeError("Internal type is not allowed for state variables."));
-	} else
+		for (auto parameter: externalFunctionTypes->getParameterTypes() + externalFunctionTypes->getReturnParameterTypes())
+			if (!parameter || !(parameter->externalType()))
+				BOOST_THROW_EXCEPTION(createTypeError("Internal type is not allowed for public state variables."));
+	}
+	else
 	{
 		// no type declared and no previous assignment, infer the type
 		m_value->checkTypeRequirements();
diff --git a/Types.cpp b/Types.cpp
index e784c6b8..86b74026 100644
--- a/Types.cpp
+++ b/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.");
-		retParamTypes.push_back(param->externalType());
+		if(!type->externalType())
+			return TypePointer();
+		retParamTypes.push_back(type->externalType());
 	}
 	return make_shared<FunctionType>(paramTypes, retParamTypes, m_location, m_arbitraryParameters);
 }
diff --git a/Types.h b/Types.h
index 99fd878f..cea71199 100644
--- a/Types.h
+++ b/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);