Do not set to ref for explicit conversion and add assertion for array

type conversion. Also, add some test cases for #4901 and #4948.

libsolidity/analysis/TypeChecker.cpp

@@ -1733,8 +1733,23 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 			DataLocation dataLoc = DataLocation::Memory;
 			if (auto argRefType = dynamic_cast<ReferenceType const*>(argType.get()))
 				dataLoc = argRefType->location();
-			resultType = ReferenceType::copyForLocationIfReference(dataLoc, resultType);
+			if (auto type = dynamic_cast<ReferenceType const*>(resultType.get()))
-			if (!argType->isExplicitlyConvertibleTo(*resultType))
+				resultType = type->copyForLocation(dataLoc, type->isPointer());
+			if (argType->isExplicitlyConvertibleTo(*resultType))
+			{
+				if (auto argArrayType = dynamic_cast<ArrayType const*>(argType.get()))
+				{
+					auto resultArrayType = dynamic_cast<ArrayType const*>(resultType.get());
+					solAssert(!!resultArrayType, "");
+					solAssert(
+						argArrayType->location() != DataLocation::Storage ||
+						((resultArrayType->isPointer() || (argArrayType->isByteArray() && resultArrayType->isByteArray())) &&
+						 resultArrayType->location() == DataLocation::Storage),
+						"Invalid explicit conversion to storage type."
+					);
+				}
+			}
+			else
 			{
 				if (resultType->category() == Type::Category::Contract && argType->category() == Type::Category::Address)
 				{

test/libsolidity/syntaxTests/conversion/allowed_conversion_to_bytes_array.sol

@@ -0,0 +1,9 @@
+contract C {
+	bytes a;
+	bytes b;
+	function f() public view {
+		bytes storage c = a;
+		bytes memory d = b;
+		d = bytes(c);
+	}
+}

test/libsolidity/syntaxTests/conversion/allowed_conversion_to_string.sol

@@ -0,0 +1,9 @@
+contract C {
+	string a;
+	string b;
+	function f() public view {
+		string storage c = a;
+		string memory d = b;
+		d = string(c);
+	}
+}

test/libsolidity/syntaxTests/conversion/explicit_conversion_from_storage_array_ref.sol

@@ -0,0 +1,10 @@
+contract C {
+	int[10] x;
+	function f() public view {
+		int[](x);
+		int(x);
+	}
+}
+// ----
+// TypeError: (55-63): Explicit type conversion not allowed from "int256[10] storage ref" to "int256[] storage pointer".
+// TypeError: (67-73): Explicit type conversion not allowed from "int256[10] storage ref" to "int256".

test/libsolidity/syntaxTests/conversion/implicit_conversion_from_storage_array_ref.sol

@@ -0,0 +1,7 @@
+contract C {
+	int[10] x;
+	int[] y;
+	function f() public {
+		y = x;
+	}
+}

test/libsolidity/syntaxTests/conversion/not_allowed_conversion_to_int_array_pointer1.sol

@@ -0,0 +1,10 @@
+contract C {
+	uint[] a;
+	uint[] b;
+	function f() public view {
+		uint[] storage c = a;
+		uint[] storage d = b;
+		d = uint[](c);
+	}
+}
+// ----

test/libsolidity/syntaxTests/conversion/not_allowed_conversion_to_int_array_pointer2.sol

@@ -0,0 +1,10 @@
+contract C {
+	uint[] a;
+	uint[] b;
+	function f() public view {
+		uint[] storage c = a;
+		uint[] memory d = b;
+		d = uint[](c);
+	}
+}
+// ----

test/libsolidity/syntaxTests/dataLocations/memory_storage_data_location.sol

@@ -0,0 +1,12 @@
+contract C {
+	int[] x;
+	function f() public {
+		int[] storage a = x;
+		int[] memory b;
+		a = b;
+		a = int[](b);
+	}
+}
+// ----
+// TypeError: (93-94): Type int256[] memory is not implicitly convertible to expected type int256[] storage pointer.
+// TypeError: (102-110): Type int256[] memory is not implicitly convertible to expected type int256[] storage pointer.