Adapt nyan to new specification

nyan/value/boolean.cpp

@@ -96,16 +96,25 @@ bool Boolean::equals(const Value &other) const {
 
 
 const std::unordered_set<nyan_op> &Boolean::allowed_operations(const Type &with_type) const {
+
+	const static std::unordered_set<nyan_op> none_ops{
+		nyan_op::ASSIGN,
+	};
+
 	const static std::unordered_set<nyan_op> ops{
 		nyan_op::ASSIGN,
 		nyan_op::UNION_ASSIGN,
 		nyan_op::INTERSECT_ASSIGN,
 	};
 
-	if (with_type.get_primitive_type() == primitive_t::BOOLEAN) {
+	switch (with_type.get_primitive_type()) {
+	case primitive_t::BOOLEAN:
 		return ops;
-	}
-	else {
+
+	case primitive_t::NONE:
+		return none_ops;
+
+	default:
 		return no_nyan_ops;
 	}
 }

nyan/value/dict.cpp

@@ -229,9 +229,9 @@ void Dict::apply_value(const Value &value, nyan_op operation) {
 
 const std::unordered_set<nyan_op> &Dict::allowed_operations(const Type &with_type) const {
 
-	if (not with_type.is_container()) {
-		return no_nyan_ops;
-	}
+	const static std::unordered_set<nyan_op> none_ops{
+		nyan_op::ASSIGN,
+	};
 
 	const static std::unordered_set<nyan_op> set_ops{
 		nyan_op::SUBTRACT_ASSIGN,
@@ -245,6 +245,14 @@ const std::unordered_set<nyan_op> &Dict::allowed_operations(const Type &with_typ
 		nyan_op::INTERSECT_ASSIGN,
 	};
 
+	if (with_type.get_primitive_type() == primitive_t::NONE) {
+		return none_ops;
+	}
+
+	if (not with_type.is_container()) {
+		return no_nyan_ops;
+	}
+
 	switch (with_type.get_composite_type()) {
 	case composite_t::SET:
 	case composite_t::ORDEREDSET:

nyan/value/file.cpp

@@ -84,10 +84,12 @@ const std::unordered_set<nyan_op> &Filename::allowed_operations(const Type &with
 		nyan_op::ASSIGN,
 	};
 
-	if (with_type.get_primitive_type() == primitive_t::FILENAME) {
+	switch (with_type.get_primitive_type()) {
+	case primitive_t::FILENAME:
+	case primitive_t::NONE:
 		return ops;
-	}
-	else {
+
+	default:
 		return no_nyan_ops;
 	}
 }

nyan/value/number.cpp

@@ -390,6 +390,10 @@ template <typename T>
 const std::unordered_set<nyan_op> &
 Number<T>::allowed_operations(const Type &with_type) const {
 
+	const static std::unordered_set<nyan_op> none_ops{
+		nyan_op::ASSIGN,
+	};
+
 	const static std::unordered_set<nyan_op> ops{
 		nyan_op::ASSIGN,
 		nyan_op::ADD_ASSIGN,
@@ -403,6 +407,10 @@ Number<T>::allowed_operations(const Type &with_type) const {
 	case primitive_t::FLOAT:
 	case primitive_t::INT:
 		return ops;
+
+	case primitive_t::NONE:
+		return none_ops;
+
 	default:
 		return no_nyan_ops;
 	}

nyan/value/object.cpp

@@ -64,10 +64,12 @@ const std::unordered_set<nyan_op> &ObjectValue::allowed_operations(const Type &w
 		nyan_op::ASSIGN,
 	};
 
-	if (with_type.get_primitive_type() == primitive_t::OBJECT) {
+	switch (with_type.get_primitive_type()) {
+	case primitive_t::OBJECT:
+	case primitive_t::NONE:
 		return ops;
-	}
-	else {
+
+	default:
 		return no_nyan_ops;
 	}
 }

nyan/value/orderedset.cpp

@@ -69,9 +69,9 @@ std::string OrderedSet::repr() const {
 
 const std::unordered_set<nyan_op> &OrderedSet::allowed_operations(const Type &with_type) const {
 
-	if (not with_type.is_container()) {
-		return no_nyan_ops;
-	}
+	const static std::unordered_set<nyan_op> none_ops{
+		nyan_op::ASSIGN,
+	};
 
 	const static std::unordered_set<nyan_op> orderedset_ops{
 		nyan_op::ASSIGN,
@@ -88,6 +88,13 @@ const std::unordered_set<nyan_op> &OrderedSet::allowed_operations(const Type &wi
 		nyan_op::INTERSECT_ASSIGN,
 	};
 
+	if (with_type.get_primitive_type() == primitive_t::NONE) {
+		return none_ops;
+	}
+
+	if (not with_type.is_container()) {
+		return no_nyan_ops;
+	}
 
 	switch (with_type.get_composite_type()) {
 	case composite_t::ORDEREDSET:

nyan/value/set.cpp

@@ -73,9 +73,9 @@ std::string Set::repr() const {
 
 const std::unordered_set<nyan_op> &Set::allowed_operations(const Type &with_type) const {
 
-	if (not with_type.is_container()) {
-		return no_nyan_ops;
-	}
+	const static std::unordered_set<nyan_op> none_ops{
+		nyan_op::ASSIGN,
+	};
 
 	const static std::unordered_set<nyan_op> set_ops{
 		nyan_op::ASSIGN,
@@ -90,6 +90,14 @@ const std::unordered_set<nyan_op> &Set::allowed_operations(const Type &with_type
 		nyan_op::INTERSECT_ASSIGN,
 	};
 
+	if (with_type.get_primitive_type() == primitive_t::NONE) {
+		return none_ops;
+	}
+
+	if (not with_type.is_container()) {
+		return no_nyan_ops;
+	}
+
 	switch (with_type.get_composite_type()) {
 	case composite_t::SET:
 		return set_ops;

nyan/value/text.cpp

@@ -79,10 +79,18 @@ const std::unordered_set<nyan_op> &Text::allowed_operations(const Type &with_typ
 		nyan_op::ADD_ASSIGN,
 	};
 
-	if (with_type.get_primitive_type() == primitive_t::TEXT) {
+	const static std::unordered_set<nyan_op> none_ops{
+		nyan_op::ASSIGN,
+	};
+
+	switch (with_type.get_primitive_type()) {
+	case primitive_t::TEXT:
 		return ops;
-	}
-	else {
+
+	case primitive_t::NONE:
+		return none_ops;
+
+	default:
 		return no_nyan_ops;
 	}
 }

nyan/value/value.cpp

@@ -124,6 +124,18 @@ static void handle_modifiers(const std::vector<Type> &modifiers,
                              const ValueHolder &value_holder,
 							 std::vector<std::pair<fqon_t, Location>> *objs_in_values) {
 	bool contains_optional = false;
+	for (auto &mod: modifiers) {
+		auto modifier_type = mod.get_composite_type();
+
+		if (modifier_type == composite_t::OPTIONAL) {
+			contains_optional = true;
+		}
+	}
+
+	if (typeid(*value_holder.get_value()) == typeid(None&) and not contains_optional) {
+		throw InternalError{"NoneValue is content, but no optional modifier was found"};
+	}
+
 	for (auto &mod: modifiers) {
 		auto modifier_type = mod.get_composite_type();
 
@@ -133,7 +145,9 @@ static void handle_modifiers(const std::vector<Type> &modifiers,
 
 		if (modifier_type == composite_t::CHILDREN) {
 			if (unlikely(typeid(*value_holder.get_value()) != typeid(ObjectValue&))) {
-				throw InternalError{"children type requires ObjectValue as content"};
+				if (not contains_optional) {
+					throw InternalError{"children type requires ObjectValue as content"};
+				}
 			}
 
 			// Check if object fqon is a child (i.e. not the same fqon as  the member type)
@@ -147,19 +161,16 @@ static void handle_modifiers(const std::vector<Type> &modifiers,
 
 		if (modifier_type == composite_t::ABSTRACT) {
 			if (unlikely(typeid(*value_holder.get_value()) != typeid(ObjectValue&))) {
-				throw InternalError{"abstract type requires ObjectValue as content"};
+				if (not contains_optional) {
+					throw InternalError{"abstract type requires ObjectValue as content"};
+				}
 			}
 
 			// Remove last element here, so the object is not checked
 			// for non-abstractness later
 			objs_in_values->pop_back();
 		}
 	}
-
-	if (typeid(*value_holder.get_value()) == typeid(None&) and not contains_optional) {
-		throw InternalError{"NoneValue is content, but no optional modifier was found"};
-	}
-
 }
 ValueHolder Value::from_ast(const Type &target_type,
                             const ASTMemberValue &astmembervalue,
@@ -205,7 +216,7 @@ ValueHolder Value::from_ast(const Type &target_type,
 		return value;
 	}
 
-	composite_t composite_type = astmembervalue.get_composite_type();
+	composite_t composite_type = current_type.get_composite_type();
 
 	// For sets/orderedsets (with primitive values)
 	std::vector<ValueHolder> values;
@@ -218,17 +229,30 @@ ValueHolder Value::from_ast(const Type &target_type,
 		values.reserve(astmembervalue.get_values().size());
 
 		// convert all tokens to values
-		const std::vector<Type> *element_type = target_type.get_element_type();
+		const std::vector<Type> *element_type = current_type.get_element_type();
 		if (unlikely(element_type == nullptr)) {
 			throw InternalError{"container element type is nonexisting"};
 		}
 
+		Type cur_elem_type = element_type->at(0);
+		std::vector<Type> elem_modifiers;
+		while (cur_elem_type.is_modifier()) {
+			elem_modifiers.insert(elem_modifiers.begin(), cur_elem_type);
+			cur_elem_type = cur_elem_type.get_element_type()->at(0);
+		}
+
+		std::vector<Type> target_types{cur_elem_type};
 		for (auto &value_token : astmembervalue.get_values()) {
-			values.push_back(
-				value_from_value_token(*element_type,
-									   value_token,
-									   get_fqon)[0]
-			);
+			ValueHolder value = value_from_value_token(
+				target_types,
+				value_token,
+				get_fqon
+			)[0];
+
+			handle_modifiers(elem_modifiers, value, objs_in_values);
+
+			values.push_back(value);
+
 		}
 
 		switch (composite_type) {
@@ -252,13 +276,32 @@ ValueHolder Value::from_ast(const Type &target_type,
 			throw InternalError{"container element type is nonexisting"};
 		}
 
+		Type cur_elem_type_key = element_type->at(0);
+		std::vector<Type> elem_modifiers_key;
+		while (cur_elem_type_key.is_modifier()) {
+			elem_modifiers_key.insert(elem_modifiers_key.begin(), cur_elem_type_key);
+			cur_elem_type_key = cur_elem_type_key.get_element_type()->at(0);
+		}
+
+		Type cur_elem_type_value = element_type->at(1);
+		std::vector<Type> elem_modifiers_value;
+		while (cur_elem_type_value.is_modifier()) {
+			elem_modifiers_value.insert(elem_modifiers_value.begin(), cur_elem_type_value);
+			cur_elem_type_value = cur_elem_type_value.get_element_type()->at(0);
+		}
+
+		std::vector<Type> target_types{cur_elem_type_key, cur_elem_type_value};
+
 		for (auto &value_token : astmembervalue.get_values()) {
 			std::vector<ValueHolder> keyval = value_from_value_token(
-				*element_type,
+				target_types,
 				value_token,
 				get_fqon
 			);
 
+			handle_modifiers(elem_modifiers_key, keyval[0], objs_in_values);
+			handle_modifiers(elem_modifiers_value, keyval[1], objs_in_values);
+
 			items.insert(std::make_pair(keyval[0], keyval[1]));
 		}
 

test/test.nyan

@@ -10,7 +10,7 @@ First():
     wat : abstract(First) = Second
     wat2 : abstract(children(First)) = Second
     wat3 : optional(First) = Second
-    # wat4 : set(children(First)) = None
+    wat4 : set(children(First)) = {Second}
     member : int = 15
     test : text = "rofl lol"
     bla : file = "wtf.h4x"