Refactoring of errors and fixes for various ICEs.

libsolidity/analysis/TypeChecker.cpp

@@ -518,19 +518,14 @@ bool TypeChecker::visit(VariableDeclaration const& _variable)
 			m_errorReporter.typeError(_variable.location(), "Internal or recursive type is not allowed for public state variables.");
 	}
 
-	switch (varType->category())
+	if (auto referenceType = dynamic_cast<ReferenceType const*>(varType))
 	{
-	case Type::Category::Array:
+		auto result = referenceType->validForLocation(referenceType->location());
-		if (auto arrayType = dynamic_cast<ArrayType const*>(varType))
+		if (!result)
-			if (
+		{
-				((arrayType->location() == DataLocation::Memory) ||
+			solAssert(!result.message().empty(), "Expected detailed error message");
-				(arrayType->location() == DataLocation::CallData)) &&
+			m_errorReporter.typeError(_variable.location(), result.message());
-				!arrayType->validForCalldata()
+		}
-			)
-				m_errorReporter.typeError(_variable.location(), "Array is too large to be encoded.");
-		break;
-	default:
-		break;
 	}
 
 	return false;

libsolidity/ast/AST.cpp

@@ -617,12 +617,20 @@ set<VariableDeclaration::Location> VariableDeclaration::allowedDataLocations() c
 	else if (isLocalVariable())
 	{
 		solAssert(typeName(), "");
-		solAssert(typeName()->annotation().type, "Can only be called after reference resolution");
+		auto getDataLocations = [](TypePointer _type, auto&& _recursion) -> set<Location> {
-		if (typeName()->annotation().type->category() == Type::Category::Mapping)
+			solAssert(_type, "Can only be called after reference resolution");
-			return set<Location>{ Location::Storage };
+			switch (_type->category())
-		else
+			{
-			//  TODO: add Location::Calldata once implemented for local variables.
+				case Type::Category::Array:
-			return set<Location>{ Location::Memory, Location::Storage };
+					return _recursion(dynamic_cast<ArrayType const*>(_type)->baseType(), _recursion);
+				case Type::Category::Mapping:
+					return set<Location>{ Location::Storage };
+				default:
+					//  TODO: add Location::Calldata once implemented for local variables.
+					return set<Location>{ Location::Memory, Location::Storage };
+			}
+		};
+		return getDataLocations(typeName()->annotation().type, getDataLocations);
 	}
 	else
 		// Struct members etc.

libsolidity/ast/Types.cpp

@@ -1649,12 +1649,35 @@ bool ArrayType::operator==(Type const& _other) const
 	return isDynamicallySized() || length() == other.length();
 }
 
-bool ArrayType::validForCalldata() const
+BoolResult ArrayType::validForLocation(DataLocation _loc) const
 {
 	if (auto arrayBaseType = dynamic_cast<ArrayType const*>(baseType()))
-		if (!arrayBaseType->validForCalldata())
+	{
-			return false;
+		BoolResult result = arrayBaseType->validForLocation(_loc);
-	return isDynamicallySized() || unlimitedStaticCalldataSize(true) <= numeric_limits<unsigned>::max();
+		if (!result)
+			return result;
+	}
+	if (isDynamicallySized())
+		return true;
+	switch (_loc)
+	{
+		case DataLocation::Memory:
+		{
+			bigint size = bigint(length()) * m_baseType->memoryHeadSize();
+			if (size >= numeric_limits<unsigned>::max())
+				return BoolResult::err("Type too large for memory.");
+			break;
+		}
+		case DataLocation::CallData:
+		{
+			if (unlimitedStaticCalldataSize(true) >= numeric_limits<unsigned>::max())
+				return BoolResult::err("Type too large for calldata.");
+			break;
+		}
+		case DataLocation::Storage:
+			break;
+	}
+	return true;
 }
 
 bigint ArrayType::unlimitedStaticCalldataSize(bool _padded) const
@@ -2272,6 +2295,18 @@ TypeResult StructType::interfaceType(bool _inLibrary) const
 	return *m_interfaceType_library;
 }
 
+BoolResult StructType::validForLocation(DataLocation _loc) const
+{
+	for (auto const& member: m_struct.members())
+		if (auto referenceType = dynamic_cast<ReferenceType const*>(member->annotation().type))
+		{
+			BoolResult result = referenceType->validForLocation(_loc);
+			if (!result)
+				return result;
+		}
+	return true;
+}
+
 bool StructType::recursive() const
 {
 	solAssert(m_struct.annotation().recursive.has_value(), "Called StructType::recursive() before DeclarationTypeChecker.");

libsolidity/ast/Types.h

@@ -706,6 +706,9 @@ public:
 	/// never change the contents of the original value.
 	bool isPointer() const;
 
+	/// @returns true if this is valid to be stored in data location _loc
+	virtual BoolResult validForLocation(DataLocation _loc) const = 0;
+
 	bool operator==(ReferenceType const& _other) const
 	{
 		return location() == _other.location() && isPointer() == _other.isPointer();
@@ -772,8 +775,7 @@ public:
 	TypePointer decodingType() const override;
 	TypeResult interfaceType(bool _inLibrary) const override;
 
-	/// @returns true if this is valid to be stored in calldata
+	BoolResult validForLocation(DataLocation _loc) const override;
-	bool validForCalldata() const;
 
 	/// @returns true if this is a byte array or a string
 	bool isByteArray() const { return m_arrayKind != ArrayKind::Ordinary; }
@@ -827,8 +829,7 @@ public:
 	bool canLiveOutsideStorage() const override { return m_arrayType.canLiveOutsideStorage(); }
 	std::string toString(bool _short) const override;
 
-	/// @returns true if this is valid to be stored in calldata
+	BoolResult validForLocation(DataLocation _loc) const override { return m_arrayType.validForLocation(_loc); }
-	bool validForCalldata() const { return m_arrayType.validForCalldata(); }
 
 	ArrayType const& arrayType() const { return m_arrayType; }
 	u256 memoryDataSize() const override { solAssert(false, ""); }
@@ -934,6 +935,8 @@ public:
 	Type const* encodingType() const override;
 	TypeResult interfaceType(bool _inLibrary) const override;
 
+	BoolResult validForLocation(DataLocation _loc) const override;
+
 	bool recursive() const;
 
 	std::unique_ptr<ReferenceType> copyForLocation(DataLocation _location, bool _isPointer) const override;

test/libsolidity/syntaxTests/array/length/not_too_large.sol

@@ -7,3 +7,4 @@ contract C {
     }
 }
 // ----
+// TypeError: (226-234): Type too large for memory.

test/libsolidity/syntaxTests/array/length/parameter_too_large.sol

@@ -2,4 +2,4 @@ contract C {
   function f(bytes32[1263941234127518272] memory) public pure {}
 }
 // ----
-// TypeError: (26-61): Array is too large to be encoded.
+// TypeError: (26-61): Type too large for memory.

test/libsolidity/syntaxTests/array/length/parameter_too_large_multidim.sol

@@ -2,10 +2,8 @@ contract C {
   function f(bytes32[1263941234127518272][500] memory) public pure {}
   function f(uint[2**30][] memory) public pure {}
   function f(uint[2**30][2**30][] memory) public pure {}
-  function f(uint[2**16][2**16][] memory) public pure {}
 }
 // ----
-// TypeError: (26-66): Array is too large to be encoded.
+// TypeError: (26-66): Type too large for memory.
-// TypeError: (96-116): Array is too large to be encoded.
+// TypeError: (96-116): Type too large for memory.
-// TypeError: (146-173): Array is too large to be encoded.
+// TypeError: (146-173): Type too large for memory.
-// TypeError: (203-230): Array is too large to be encoded.

test/libsolidity/syntaxTests/array/length/parameter_too_large_multidim_ABIv2.sol

@@ -5,5 +5,5 @@ contract C {
   function f(uint[2**30][2**30][][] memory) public pure {}
 }
 // ----
-// TypeError: (61-101): Array is too large to be encoded.
+// TypeError: (61-101): Type too large for memory.
-// TypeError: (131-160): Array is too large to be encoded.
+// TypeError: (131-160): Type too large for memory.

test/libsolidity/syntaxTests/iceRegressionTests/large_array_in_memory_struct.sol

@@ -0,0 +1,17 @@
+contract C {
+        struct X { bytes31 [ 3 ] x1 ;
+                uint x2 ;
+        }
+        struct S { uint256 [ ] [ 0.425781 ether ] s1 ;
+                uint [ 2 ** 0xFF ] [ 2 ** 0x42 ] s2 ;
+                X s3 ;
+                mapping ( uint => address payable ) c ;
+                uint [ 9 hours ** 16 ] d ;
+                string s ;
+        }
+        function f ( ) public { function ( function ( bytes9 , uint ) external pure returns ( uint ) , uint ) external pure returns ( uint ) [ 3 ] memory s2 ;
+                S memory s ;
+        }
+}
+// ----
+// TypeError: (530-540): Type too large for memory.

test/libsolidity/syntaxTests/iceRegressionTests/large_array_in_memory_struct_2.sol

@@ -0,0 +1,12 @@
+contract C {
+    struct R { uint[10][10] y; }
+    struct S { uint a; uint b; R d; uint[20][20][2999999999999999999999999990] c; }
+    function f() public pure {
+        C.S memory y;
+        C.S[10] memory z;
+        y.a < 2;
+        z; y;
+    }
+}
+// ----
+// TypeError: (169-181): Type too large for memory.

test/libsolidity/syntaxTests/iceRegressionTests/memory_mapping_array.sol

@@ -0,0 +1,7 @@
+ contract C {
+        function h ( bool flag ) public returns ( bool c ) {
+                mapping ( string => uint24 ) [ 1 ] memory val ;
+        }
+}
+// ----
+// TypeError: (91-136): Data location must be "storage" for variable, but "memory" was given.

test/libsolidity/syntaxTests/iceRegressionTests/recursive_struct_memory.sol

@@ -0,0 +1,13 @@
+contract Test {
+        struct RecursiveStruct {
+                address payable d ;
+                mapping ( uint => address payable ) c ;
+                mapping ( uint => address payable [ ] ) d ;
+        }
+        function func ( ) private pure {
+                RecursiveStruct [ 1 ] memory val ;
+                val ;
+        }
+}
+// ----
+// DeclarationError: (157-198): Identifier already declared.

test/libsolidity/syntaxTests/nameAndTypeResolution/207_no_mappings_in_memory_array.sol

@@ -4,4 +4,4 @@ contract C {
     }
 }
 // ----
-// TypeError: (47-77): Type mapping(uint256 => uint256)[] memory is only valid in storage.
+// TypeError: (47-77): Data location must be "storage" for variable, but "memory" was given.

test/libsolidity/syntaxTests/nameAndTypeResolution/476_too_large_arrays_for_calldata_external.sol

@@ -3,4 +3,4 @@ contract C {
     }
 }
 // ----
-// TypeError: (28-56): Array is too large to be encoded.
+// TypeError: (28-56): Type too large for calldata.

test/libsolidity/syntaxTests/nameAndTypeResolution/477_too_large_arrays_for_calldata_internal.sol

@@ -3,4 +3,4 @@ contract C {
     }
 }
 // ----
-// TypeError: (28-54): Array is too large to be encoded.
+// TypeError: (28-54): Type too large for memory.

test/libsolidity/syntaxTests/nameAndTypeResolution/478_too_large_arrays_for_calldata_public.sol

@@ -3,4 +3,4 @@ contract C {
     }
 }
 // ----
-// TypeError: (28-54): Array is too large to be encoded.
+// TypeError: (28-54): Type too large for memory.