[Checker] check and reject composite types with non-storable fields

runtime/runtime.go

@@ -453,6 +453,7 @@ func validateArgumentParams(
 	return argumentValues, nil
 }
 
+// ParseAndCheckProgram parses the given script and runs type check.
 func (r *interpreterRuntime) ParseAndCheckProgram(script []byte, runtimeInterface Interface, location Location) error {
 	runtimeStorage := newInterpreterRuntimeStorage(runtimeInterface)
 	functions := r.standardLibraryFunctions(runtimeInterface, runtimeStorage)

runtime/sema/check_composite_declaration.go

@@ -496,6 +496,19 @@ func (checker *Checker) declareCompositeMembersAndValue(
 			checker.declareInterfaceMembers(nestedInterfaceDeclaration)
 		}
 
+		// If this composite declaration has nested composite declaration, 
+		// then recursively declare the members and values of them.
+		//
+		// For instance, a structure `S`, defined within a contract `MyContract`,
+		// as shown in the example code below, is a nested composite declaration
+		// which has its own members:
+		// ```
+		// contract MyContract {
+		//   struct S {
+		//     var v: Int
+		//   }
+		// }
+		// ```
 		for _, nestedCompositeDeclaration := range declaration.CompositeDeclarations {
 			checker.declareCompositeMembersAndValue(nestedCompositeDeclaration, kind)
 
@@ -562,6 +575,23 @@ func (checker *Checker) declareCompositeMembersAndValue(
 			)
 		}
 
+		// Check if all members' types are allowed. 
+		// A member's type is allowed if it is storable
+
+		for _, member := range members {
+			// If a member has a non-storable type, then report an error
+
+			if !member.IsStorable() {
+				checker.report(
+					&FieldTypeNotStorableError{
+						Name: member.Identifier.Identifier,
+						Type: member.TypeAnnotation.Type,
+						Pos:  member.Identifier.Pos,
+					},
+				)
+			}
+		}
+
 		compositeType.Members = members
 		checker.memberOrigins[compositeType] = origins
 	})()
@@ -1272,6 +1302,7 @@ func (checker *Checker) checkNoInitializerNoFields(
 	)
 }
 
+// checkSpecialFunction checks special functions, like initializers and destructors
 func (checker *Checker) checkSpecialFunction(
 	specialFunction *ast.SpecialFunctionDeclaration,
 	containerType Type,

runtime/sema/errors.go

@@ -707,6 +707,33 @@ func (e *FieldUninitializedError) EndPosition() ast.Position {
 	return e.Pos.Shifted(length - 1)
 }
 
+// FieldTypeNotStorableError is an error that is reported for 
+// field of composite types that are not storable.
+//
+// Field types have to be storable because the storage
+// layer needs to know how to store the field, which is not 
+// possible for all types.
+//
+// For example, the type `Int` is a storable type, 
+// whereas a function type is not.
+
+type FieldTypeNotStorableError struct {
+	// Field's name
+	Name string
+	// Field's type
+	Type Type
+	// StartPosition of the error
+	Pos ast.Position
+}
+
+func (e *FieldTypeNotStorableError) Error() string {
+	return fmt.Sprintf(
+		"field %s has non-storable type: %s",
+		e.Name,
+		e.Type,
+	)
+}
+
 // FunctionExpressionInConditionError
 
 type FunctionExpressionInConditionError struct {