src/serialization: detect more errors on serialize/noserialize annotations

[nit.git] / src / frontend / serialization_phase.nit

diff --git a/src/frontend/serialization_phase.nit b/src/frontend/serialization_phase.nit
index 90924f2..3e144ef 100644 (file)
--- a/src/frontend/serialization_phase.nit
+++ b/src/frontend/serialization_phase.nit
@@ -34,17 +34,55 @@ redef class ToolContext
        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`
@@ -65,8 +103,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
@@ -201,10 +238,6 @@ private class PreciseTypeVisitor
        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