src/frontend/serialization_phase.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2013 Jean-Philippe Caissy <jpcaissy@piji.ca>
   4 # Copyright 2013 Guillaume Auger <jeho@resist.ca>
   5 # Copyright 2014 Alexis Laferrière <alexis.laf@xymus.net>
   6 #
   7 # Licensed under the Apache License, Version 2.0 (the "License");
   8 # you may not use this file except in compliance with the License.
   9 # You may obtain a copy of the License at
  10 #
  11 #     http://www.apache.org/licenses/LICENSE-2.0
  12 #
  13 # Unless required by applicable law or agreed to in writing, software
  14 # distributed under the License is distributed on an "AS IS" BASIS,
  15 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 # See the License for the specific language governing permissions and
  17 # limitations under the License.
  18
  19 # Phase generating methods to serialize Nit objects to different formats
  20 module serialization_phase
  21
  22 private import parser_util
  23 import modelize
  24 private import annotation
  25
  26 redef class ToolContext
  27         # Generate serialization and deserialization methods on `auto_serializable` annotated classes.
  28         var serialization_phase_pre_model: Phase = new SerializationPhasePreModel(self, null)
  29
  30         # The second phase of the serialization
  31         var serialization_phase_post_model: Phase = new SerializationPhasePostModel(self,
  32                 [modelize_class_phase, serialization_phase_pre_model])
  33
  34         private fun place_holder_type_name: String do return "PlaceHolderTypeWhichShouldNotExist"
  35 end
  36
  37 # TODO add annotations on attributes (volatile, sensitive or do_not_serialize?)
  38 private class SerializationPhasePreModel
  39         super Phase
  40
  41         redef fun process_annotated_node(nclassdef, nat)
  42         do
  43                 # Skip if we are not interested
  44                 if nat.n_atid.n_id.text != "auto_serializable" then return
  45                 if not nclassdef isa AStdClassdef then
  46                         toolcontext.error(nclassdef.location, "Syntax error: only a concrete class can be automatically serialized.")
  47                         return
  48                 end
  49
  50                 # Add `super Serializable`
  51                 var sc = toolcontext.parse_superclass("Serializable")
  52                 sc.location = nat.location
  53                 nclassdef.n_propdefs.add sc
  54
  55                 generate_serialization_method(nclassdef)
  56
  57                 generate_deserialization_init(nclassdef)
  58         end
  59
  60         redef fun process_nmodule(nmodule)
  61         do
  62                 # Clear the cache of constructors to review before adding to it
  63                 nmodule.inits_to_retype.clear
  64
  65                 # collect all classes
  66                 var auto_serializable_nclassdefs = new Array[AStdClassdef]
  67                 for nclassdef in nmodule.n_classdefs do
  68                         if nclassdef isa AStdClassdef and
  69                            not nclassdef.get_annotations("auto_serializable").is_empty then
  70                                 auto_serializable_nclassdefs.add nclassdef
  71                         end
  72                 end
  73
  74                 if not auto_serializable_nclassdefs.is_empty then
  75                         generate_deserialization_method(nmodule, auto_serializable_nclassdefs)
  76                 end
  77         end
  78
  79         fun generate_serialization_method(nclassdef: AClassdef)
  80         do
  81                 var npropdefs = nclassdef.n_propdefs
  82
  83                 var code = new Array[String]
  84                 code.add "redef fun core_serialize_to(v)"
  85                 code.add "do"
  86                 code.add "      super"
  87
  88                 for attribute in npropdefs do if attribute isa AAttrPropdef then
  89                         var name = attribute.name
  90                         code.add "      v.serialize_attribute(\"{name}\", {name})"
  91                 end
  92
  93                 code.add "end"
  94
  95                 # Create method Node and add it to the AST
  96                 npropdefs.push(toolcontext.parse_propdef(code.join("\n")))
  97         end
  98
  99         # Add a constructor to the automated nclassdef
 100         fun generate_deserialization_init(nclassdef: AStdClassdef)
 101         do
 102                 # Do not generate constructors for abstract classes
 103                 if nclassdef.n_classkind isa AAbstractClasskind then return
 104
 105                 var npropdefs = nclassdef.n_propdefs
 106
 107                 var code = new Array[String]
 108                 code.add "init from_deserializer(v: Deserializer)"
 109                 code.add "do"
 110                 code.add "      v.notify_of_creation self"
 111
 112                 for attribute in npropdefs do if attribute isa AAttrPropdef then
 113                         var n_type = attribute.n_type
 114                         var type_name
 115                         if n_type == null then
 116                                 # Use a place holder, we will replace it with the infered type after the model phases
 117                                 type_name = toolcontext.place_holder_type_name
 118                         else
 119                                 type_name = n_type.type_name
 120                         end
 121                         var name = attribute.name
 122
 123                         code.add ""
 124                         code.add "\tvar {name} = v.deserialize_attribute(\"{name}\")"
 125                         code.add "\tassert {name} isa {type_name} else print \"Unsupported type for attribute '{name}', got '\{{name}.class_name\}' (ex {type_name})\""
 126                         code.add "\tself.{name} = {name}"
 127                 end
 128
 129                 code.add "end"
 130
 131                 var npropdef = toolcontext.parse_propdef(code.join("\n")).as(AMethPropdef)
 132                 npropdefs.add npropdef
 133                 nclassdef.parent.as(AModule).inits_to_retype.add npropdef
 134         end
 135
 136         # Added to the abstract serialization service
 137         fun generate_deserialization_method(nmodule: AModule, nclassdefs: Array[AStdClassdef])
 138         do
 139                 var code = new Array[String]
 140
 141                 var deserializer_nclassdef = nmodule.deserializer_nclassdef
 142                 var deserializer_npropdef
 143                 if deserializer_nclassdef == null then
 144                         # create the class
 145                         code.add "redef class Deserializer"
 146                         deserializer_npropdef = null
 147                 else
 148                         deserializer_npropdef = deserializer_nclassdef.deserializer_npropdef
 149                 end
 150
 151                 if deserializer_npropdef == null then
 152                         # create the property
 153                         code.add "      redef fun deserialize_class(name)"
 154                         code.add "      do"
 155                 else
 156                         toolcontext.error(deserializer_npropdef.location, "Annotation error: you cannot define Deserializer::deserialize_class in a module where you use \"auto_serializable\".")
 157                         return
 158                 end
 159
 160                 for nclassdef in nclassdefs do
 161                         var name = nclassdef.n_id.text
 162                         if nclassdef.n_formaldefs.is_empty and
 163                                 not nclassdef.n_classkind isa AAbstractClasskind then
 164
 165                                 code.add "              if name == \"{name}\" then return new {name}.from_deserializer(self)"
 166                         end
 167                 end
 168
 169                 code.add "              return super"
 170                 code.add "      end"
 171
 172                 if deserializer_nclassdef == null then
 173                         code.add "end"
 174                         nmodule.n_classdefs.add toolcontext.parse_classdef(code.join("\n"))
 175                 else
 176                         deserializer_nclassdef.n_propdefs.add(toolcontext.parse_propdef(code.join("\n")))
 177                 end
 178         end
 179 end
 180
 181 private class SerializationPhasePostModel
 182         super Phase
 183
 184         redef fun process_nmodule(nmodule)
 185         do
 186                 for npropdef in nmodule.inits_to_retype do
 187                         var mpropdef = npropdef.mpropdef
 188                         if mpropdef == null then continue # skip error
 189                         var v = new PreciseTypeVisitor(npropdef, mpropdef.mclassdef, toolcontext)
 190                         npropdef.accept_precise_type_visitor v
 191                 end
 192         end
 193 end
 194
 195 # Visitor on generated constructors to replace the expected type of deserialized attributes
 196 private class PreciseTypeVisitor
 197         super Visitor
 198
 199         var npropdef: AMethPropdef
 200         var mclassdef: MClassDef
 201         var toolcontext: ToolContext
 202
 203         redef fun visit(n) do n.accept_precise_type_visitor(self)
 204 end
 205
 206 redef class ANode
 207         private fun accept_precise_type_visitor(v: PreciseTypeVisitor) do visit_all(v)
 208 end
 209
 210 redef class AIsaExpr
 211         redef fun accept_precise_type_visitor(v)
 212         do
 213                 if n_type.collect_text != v.toolcontext.place_holder_type_name then return
 214
 215                 var attr_name = "_" + n_expr.collect_text
 216                 for mattrdef in v.mclassdef.mpropdefs do
 217                         if mattrdef isa MAttributeDef and mattrdef.name == attr_name then
 218                                 var new_ntype = v.toolcontext.parse_something(mattrdef.static_mtype.to_s)
 219                                 n_type.replace_with new_ntype
 220                                 break
 221                         end
 222                 end
 223         end
 224 end
 225
 226 redef class AAttrPropdef
 227         private fun name: String
 228         do
 229                 return n_id2.text
 230         end
 231 end
 232
 233 redef class AType
 234         private fun type_name: String
 235         do
 236                 var name = n_id.text
 237
 238                 if n_kwnullable != null then name = "nullable {name}"
 239
 240                 var types = n_types
 241                 if not types.is_empty then
 242                         var params = new Array[String]
 243                         for t in types do params.add(t.type_name)
 244                         return "{name}[{params.join(", ")}]"
 245                 else return name
 246         end
 247 end
 248
 249 redef class AModule
 250         private fun deserializer_nclassdef: nullable AStdClassdef
 251         do
 252                 for nclassdef in n_classdefs do
 253                         if nclassdef isa AStdClassdef and nclassdef.n_id.text == "Deserialization" then
 254                                 return nclassdef
 255                         end
 256                 end
 257
 258                 return null
 259         end
 260
 261         private var inits_to_retype = new Array[AMethPropdef]
 262 end
 263
 264 redef class AStdClassdef
 265         private fun deserializer_npropdef: nullable AMethPropdef
 266         do
 267                 for npropdef in n_propdefs do if npropdef isa AMethPropdef then
 268                         var id = npropdef.n_methid
 269                         if id isa AIdMethid and id.n_id.text == "deserialize_class" then
 270                                 return npropdef
 271                         end
 272                 end
 273
 274                 return null
 275         end
 276 end