model: remove `new_msignature` and special call as the new signature is the method...

[nit.git] / src / modelize / modelize_property.nit

diff --git a/src/modelize/modelize_property.nit b/src/modelize/modelize_property.nit
index 03d9951..abce092 100644 (file)
--- a/src/modelize/modelize_property.nit
+++ b/src/modelize/modelize_property.nit
@@ -55,10 +55,9 @@ redef class ModelBuilder
                        toolcontext.run_phases_on_npropdef(res)
                        return res
                end
-               if mpropdef isa MMethodDef and mpropdef.mproperty.is_root_init then
-                       res = mclassdef2nclassdef.get_or_null(mpropdef.mclassdef)
-                       if res != null then return res
-               end
+               # Fall back to the class node if any.
+               res = mclassdef2nclassdef.get_or_null(mpropdef.mclassdef)
+               if res != null then return res
                return null
        end
 
@@ -151,11 +150,9 @@ redef class ModelBuilder
                        var mparameters = new Array[MParameter]
                        var msignature = new MSignature(mparameters, null)
                        mpropdef.msignature = msignature
-                       mpropdef.new_msignature = msignature
                        mprop.is_init = true
                        self.toolcontext.info("{mclassdef} gets a free empty constructor {mpropdef}{msignature}", 3)
                        the_root_init_mmethod = mprop
-                       return
                end
 
                # Is there already a constructor defined?
@@ -166,12 +163,16 @@ redef class ModelBuilder
                        if mpropdef.mproperty.is_root_init then
                                assert defined_init == null
                                defined_init = mpropdef
-                       else if mpropdef.mproperty.name == "init" then
+                       else if mpropdef.mproperty.name == "autoinit" then
                                # An explicit old-style init named "init", so return
                                return
                        end
                end
 
+               if mclassdef.auto_init != null then
+                       return
+               end
+
                if not nclassdef isa AStdClassdef then return
 
                # Collect undefined attributes
@@ -226,10 +227,12 @@ redef class ModelBuilder
                if the_root_init_mmethod == null then return
 
                # Look for most-specific new-stype init definitions
-               var spropdefs = the_root_init_mmethod.lookup_super_definitions(mclassdef.mmodule, mclassdef.bound_mtype)
-               if spropdefs.is_empty then
-                       toolcontext.error(nclassdef.location, "Error: `{mclassdef}` does not specialize `{the_root_init_mmethod.intro_mclassdef}`. Possible duplication of the root class `Object`?")
-                       return
+               var spropdefs = new ArraySet[MMethodDef]
+               for x in mclassdef.in_hierarchy.direct_greaters do
+                       var y = x.mclass.intro.auto_init
+                       if y == null then continue
+                       if y.is_broken or y.msignature == null then return
+                       spropdefs.add y
                end
 
                # Look at the autoinit class-annotation
@@ -331,32 +334,25 @@ redef class ModelBuilder
 
                                # Combine the inherited list to what is collected
                                if longest.initializers.length > 0 then
-                                       mparameters.prepend longest.new_msignature.mparameters
+                                       mparameters.prepend longest.msignature.mparameters
                                        initializers.prepend longest.initializers
                                end
                        end
                end
 
-               # If we already have a basic init definition, then setup its initializers
-               if defined_init != null then
-                       defined_init.initializers.add_all(initializers)
+               # Create a specific new autoinit constructor
+               do
+                       var mprop = new MMethod(mclassdef, "autoinit", public_visibility)
+                       mprop.is_init = true
+                       var mpropdef = new MMethodDef(mclassdef, mprop, nclassdef.location)
+                       mpropdef.initializers.add_all(initializers)
                        var msignature = new MSignature(mparameters, null)
-                       defined_init.new_msignature = msignature
-                       self.toolcontext.info("{mclassdef} extends its basic constructor signature to {defined_init}{msignature}", 3)
-                       mclassdef.mclass.root_init = defined_init
-                       return
+                       mpropdef.msignature = msignature
+                       mclassdef.auto_init = mpropdef
+                       self.toolcontext.info("{mclassdef} gets a free auto constructor `{mpropdef}{msignature}`. {spropdefs}", 3)
+                       #mclassdef.mclass.root_init = mpropdef
+                       mclassdef.mclass.the_root_init_mmethod = the_root_init_mmethod
                end
-
-               # Else create the local implicit basic init definition
-               var mprop = the_root_init_mmethod
-               var mpropdef = new MMethodDef(mclassdef, mprop, nclassdef.location)
-               mpropdef.has_supercall = true
-               mpropdef.initializers.add_all(initializers)
-               var msignature = new MSignature(mparameters, null)
-               mpropdef.new_msignature = msignature
-               mpropdef.msignature = new MSignature(new Array[MParameter], null) # always an empty real signature
-               self.toolcontext.info("{mclassdef} gets a free constructor for attributes {mpropdef}{msignature}", 3)
-               mclassdef.mclass.root_init = mpropdef
        end
 
        # Check the visibility of `mtype` as an element of the signature of `mpropdef`.
@@ -490,11 +486,15 @@ end
 
 redef class MClass
        # The base init of the class.
-       # Used to get the common new_msignature and initializers
        #
        # TODO: Where to put this information is not clear because unlike other
        # informations, the initialisers are stable in a same class.
        var root_init: nullable MMethodDef = null
+
+       # The base init of the class.
+       #
+       # TODO: merge with `root_init` and `ModelBuilder::the_root_init_mmethod` if possible
+       var the_root_init_mmethod: nullable MMethod = null
 end
 
 redef class MClassDef
@@ -778,6 +778,9 @@ redef class AMethPropdef
                        else if n_kwinit != null then
                                name = "init"
                                name_node = n_kwinit
+                               if self.n_signature.n_params.not_empty or get_single_annotation("old_style_init", modelbuilder) != null then
+                                       name = "autoinit"
+                               end
                        else if n_kwnew != null then
                                name = "new"
                                name_node = n_kwnew
@@ -881,7 +884,6 @@ redef class AMethPropdef
                        var root_init = mclassdef.mclass.root_init
                        if root_init != null then
                                # Inherit the initializers by refinement
-                               mpropdef.new_msignature = root_init.new_msignature
                                assert mpropdef.initializers.is_empty
                                mpropdef.initializers.add_all root_init.initializers
                        end