X-Git-Url: http://nitlanguage.org diff --git a/src/frontend/serialization_phase.nit b/src/frontend/serialization_phase.nit index 25574e7..8d576ba 100644 --- a/src/frontend/serialization_phase.nit +++ b/src/frontend/serialization_phase.nit @@ -24,34 +24,128 @@ import modelize private import annotation redef class ToolContext + # Generate serialization and deserialization methods on `auto_serializable` annotated classes. var serialization_phase_pre_model: Phase = new SerializationPhasePreModel(self, null) + + # The second phase of the serialization var serialization_phase_post_model: Phase = new SerializationPhasePostModel(self, [modelize_class_phase, serialization_phase_pre_model]) private fun place_holder_type_name: String do return "PlaceHolderTypeWhichShouldNotExist" end +redef class ANode + # Is this node annotated to be made serializable? + private fun is_serialize: Bool do return false + + # Is this node annotated to not be made serializable? + private fun is_noserialize: Bool do return false + + private fun accept_precise_type_visitor(v: PreciseTypeVisitor) do visit_all(v) +end + +redef class ADefinition + + redef fun is_serialize do + return get_annotations("serialize").not_empty or + get_annotations("auto_serializable").not_empty + end + + redef fun is_noserialize do + return get_annotations("noserialize").not_empty + end +end + # TODO add annotations on attributes (volatile, sensitive or do_not_serialize?) private class SerializationPhasePreModel super Phase - redef fun process_annotated_node(nclassdef, nat) + redef fun process_annotated_node(node, nat) do # Skip if we are not interested - if nat.n_atid.n_id.text != "auto_serializable" then return - if not nclassdef isa AStdClassdef then - toolcontext.error(nclassdef.location, "Syntax error: only a concrete class can be automatically serialized.") + var text = nat.n_atid.n_id.text + var serialize = text == "auto_serializable" or text == "serialize" + var noserialize = text == "noserialize" + if not (serialize or noserialize) then return + + # Check legality of annotation + if node isa AModuledecl then + if noserialize then toolcontext.error(node.location, "Syntax Error: superfluous use of `{text}`, by default a module is `{text}`") + return + else if not (node isa AStdClassdef or node isa AAttrPropdef) then + toolcontext.error(node.location, + "Syntax Error: only a class, a module or an attribute can be annotated with `{text}`.") return + else if serialize and node.is_noserialize then + toolcontext.error(node.location, + "Syntax Error: an entity cannot be both `{text}` and `noserialize`.") + return + else if node.as(Prod).get_annotations(text).length > 1 then + toolcontext.warning(node.location, "useless-{text}", + "Warning: duplicated annotation `{text}`.") end - # Add `super Serializable` - var sc = toolcontext.parse_superclass("Serializable") - sc.location = nat.location - nclassdef.n_superclasses.add sc + # Check the `serialize` state of the parent + if not node isa AModuledecl then + var up_serialize = false + var up: nullable ANode = node + loop + up = up.parent + if up == null then + break + else if up.is_serialize then + up_serialize = true + break + else if up.is_noserialize then + break + end + end + + # Check for useless double declarations + if serialize and up_serialize then + toolcontext.warning(node.location, "useless-serialize", + "Warning: superfluous use of `{text}`.") + else if noserialize and not up_serialize then + toolcontext.warning(node.location, "useless-noserialize", + "Warning: superfluous use of `{text}`.") + end + end + end + + redef fun process_nclassdef(nclassdef) + do + if not nclassdef isa AStdClassdef then return - generate_serialization_method(nclassdef) + # Is there a declaration on the classdef or the module? + var serialize = nclassdef.is_serialize - generate_deserialization_init(nclassdef) + if not serialize and not nclassdef.is_noserialize then + # Is the module marked serialize? + serialize = nclassdef.parent.as(AModule).is_serialize + end + + var per_attribute = false + if not serialize then + # Is there an attribute marked serialize? + for npropdef in nclassdef.n_propdefs do + if npropdef.is_serialize then + serialize = true + per_attribute = true + break + end + end + end + + if serialize then + # Add `super Serializable` + var sc = toolcontext.parse_superclass("Serializable") + sc.location = nclassdef.location + nclassdef.n_propdefs.add sc + + # Add services + generate_serialization_method(nclassdef, per_attribute) + generate_deserialization_init(nclassdef, per_attribute) + end end redef fun process_nmodule(nmodule) @@ -62,8 +156,7 @@ private class SerializationPhasePreModel # collect all classes var auto_serializable_nclassdefs = new Array[AStdClassdef] for nclassdef in nmodule.n_classdefs do - if nclassdef isa AStdClassdef and - not nclassdef.get_annotations("auto_serializable").is_empty then + if nclassdef isa AStdClassdef and nclassdef.is_serialize then auto_serializable_nclassdefs.add nclassdef end end @@ -73,7 +166,7 @@ private class SerializationPhasePreModel end end - private fun generate_serialization_method(nclassdef: AClassdef) + fun generate_serialization_method(nclassdef: AClassdef, per_attribute: Bool) do var npropdefs = nclassdef.n_propdefs @@ -83,6 +176,11 @@ private class SerializationPhasePreModel code.add " super" for attribute in npropdefs do if attribute isa AAttrPropdef then + + # Is `attribute` to be skipped? + if (per_attribute and not attribute.is_serialize) or + attribute.is_noserialize then continue + var name = attribute.name code.add " v.serialize_attribute(\"{name}\", {name})" end @@ -94,16 +192,22 @@ private class SerializationPhasePreModel end # Add a constructor to the automated nclassdef - private fun generate_deserialization_init(nclassdef: AClassdef) + fun generate_deserialization_init(nclassdef: AClassdef, per_attribute: Bool) do var npropdefs = nclassdef.n_propdefs var code = new Array[String] - code.add "init from_deserializer(v: Deserializer)" + code.add "redef init from_deserializer(v: Deserializer)" code.add "do" + code.add " super" code.add " v.notify_of_creation self" for attribute in npropdefs do if attribute isa AAttrPropdef then + + # Is `attribute` to be skipped? + if (per_attribute and not attribute.is_serialize) or + attribute.is_noserialize then continue + var n_type = attribute.n_type var type_name if n_type == null then @@ -116,19 +220,19 @@ private class SerializationPhasePreModel code.add "" code.add "\tvar {name} = v.deserialize_attribute(\"{name}\")" - code.add "\tassert {name} isa {type_name} else print \"Unsupported type for attribute '{name}', got '\{{name}.class_name\}' (ex {type_name})\"" + code.add "\tassert {name} isa {type_name} else print \"Unsupported type for `\{class_name\}::{name}`, got '\{{name}.class_name\}'; expected {type_name}\"" code.add "\tself.{name} = {name}" end code.add "end" - var npropdef = toolcontext.parse_propdef(code.join("\n")).as(AConcreteInitPropdef) + var npropdef = toolcontext.parse_propdef(code.join("\n")).as(AMethPropdef) npropdefs.add npropdef nclassdef.parent.as(AModule).inits_to_retype.add npropdef end # Added to the abstract serialization service - private fun generate_deserialization_method(nmodule: AModule, nclassdefs: Array[AStdClassdef]) + fun generate_deserialization_method(nmodule: AModule, nclassdefs: Array[AStdClassdef]) do var code = new Array[String] @@ -147,13 +251,15 @@ private class SerializationPhasePreModel code.add " redef fun deserialize_class(name)" code.add " do" else - toolcontext.error(deserializer_npropdef.location, "Annotation error: you cannot define Deserializer::deserialize_class in a module where you use \"auto_serializable\".") + toolcontext.error(deserializer_npropdef.location, "Error: you cannot define `Deserializer::deserialize_class` in a module where you use `auto_serializable`.") return end for nclassdef in nclassdefs do var name = nclassdef.n_id.text - if nclassdef.n_formaldefs.is_empty then + if nclassdef.n_formaldefs.is_empty and + not nclassdef.n_classkind isa AAbstractClasskind then + code.add " if name == \"{name}\" then return new {name}.from_deserializer(self)" end end @@ -176,7 +282,9 @@ private class SerializationPhasePostModel redef fun process_nmodule(nmodule) do for npropdef in nmodule.inits_to_retype do - var v = new PreciseTypeVisitor(npropdef, npropdef.mpropdef.mclassdef, toolcontext) + var mpropdef = npropdef.mpropdef + if mpropdef == null then continue # skip error + var v = new PreciseTypeVisitor(npropdef, mpropdef.mclassdef, toolcontext) npropdef.accept_precise_type_visitor v end end @@ -186,24 +294,13 @@ end private class PreciseTypeVisitor super Visitor - var npropdef: AConcreteInitPropdef + var npropdef: AMethPropdef var mclassdef: MClassDef var toolcontext: ToolContext - init(npropdef: AConcreteInitPropdef, mclassdef: MClassDef, toolcontext: ToolContext) - do - self.npropdef = npropdef - self.mclassdef = mclassdef - self.toolcontext = toolcontext - end - redef fun visit(n) do n.accept_precise_type_visitor(self) end -redef class ANode - private fun accept_precise_type_visitor(v: PreciseTypeVisitor) do visit_all(v) -end - redef class AIsaExpr redef fun accept_precise_type_visitor(v) do @@ -223,8 +320,7 @@ end redef class AAttrPropdef private fun name: String do - if n_id == null then return n_id2.text - return n_id.text + return n_id2.text end end @@ -256,7 +352,9 @@ redef class AModule return null end - private var inits_to_retype = new Array[AConcreteInitPropdef] + private var inits_to_retype = new Array[AMethPropdef] + + redef fun is_serialize do return n_moduledecl != null and n_moduledecl.is_serialize end redef class AStdClassdef