X-Git-Url: http://nitlanguage.org diff --git a/src/semantize/auto_super_init.nit b/src/semantize/auto_super_init.nit index e6feb5c..0be7107 100644 --- a/src/semantize/auto_super_init.nit +++ b/src/semantize/auto_super_init.nit @@ -14,7 +14,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -# Computing of super-constructors that must be implicitely called at the begin of constructors. +# Computing of super-constructors that must be implicitly called at the begin of constructors. # The current rules are a bit crazy but whatever. module auto_super_init @@ -22,6 +22,7 @@ import typing private import annotation redef class ToolContext + # Phase that inject `super` in constructors that need it. var auto_super_init_phase: Phase = new AutoSuperInitPhase(self, [typing_phase]) end @@ -32,10 +33,6 @@ end private class AutoSuperInitVisitor super Visitor - init - do - end - redef fun visit(n) do n.accept_auto_super_init(self) @@ -43,6 +40,9 @@ private class AutoSuperInitVisitor end var has_explicit_super_init: nullable ANode = null + + # The method is broken, so avoid to display additional errors + var is_broken = false end @@ -56,8 +56,10 @@ redef class AMethPropdef # Collect initializers and build the auto-init fun do_auto_super_init(modelbuilder: ModelBuilder) do - var mclassdef = self.parent.as(AClassdef).mclassdef.as(not null) - var mpropdef = self.mpropdef.as(not null) + var mclassdef = self.parent.as(AClassdef).mclassdef + if mclassdef == null or mclassdef.is_broken then return # skip error + var mpropdef = self.mpropdef + if mpropdef == null or mpropdef.is_broken then return # skip error var mmodule = mpropdef.mclassdef.mmodule var anchor = mclassdef.bound_mtype var recvtype = mclassdef.mclass.mclass_type @@ -66,21 +68,11 @@ redef class AMethPropdef var nosuper = get_single_annotation("nosuper", modelbuilder) # Collect only for constructors - if not mpropdef.mproperty.is_init then - if nosuper != null then modelbuilder.error(nosuper, "Error: nosuper only in `init`") + if not mpropdef.mproperty.is_init or mpropdef.mproperty.is_new then + if nosuper != null then modelbuilder.error(nosuper, "Error: `nosuper` only allowed in `init`.") return end - # FIXME: THIS IS STUPID (be here to keep the old code working) - if not mpropdef.mclassdef.is_intro then return - - # Do we inherit for a constructor? - var skip = true - for cd in mclassdef.in_hierarchy.direct_greaters do - if cd.mclass.kind.need_init then skip = false - end - if skip then return - # Now we search for the absence of any explicit super-init invocation # * via a "super" # * via a call of an other init @@ -90,9 +82,10 @@ redef class AMethPropdef v.enter_visit(nblock) var anode = v.has_explicit_super_init if anode != null then - if nosuper != null then modelbuilder.error(anode, "Error: method is annotated nosuper but a constructor call is present") + if nosuper != null then modelbuilder.error(anode, "Error: method is annotated `nosuper` but a super-constructor call is present.") return end + if v.is_broken then return # skip end if nosuper != null then return @@ -101,104 +94,93 @@ redef class AMethPropdef if not mpropdef.is_intro then auto_super_call = true mpropdef.has_supercall = true + modelbuilder.toolcontext.info("Auto-super call for {mpropdef}", 4) return end # Still here? So it means that we must determine what super inits need to be automatically invoked # The code that follow is required to deal with complex cases with old-style and new-style inits - # Look for old-style super constructors var auto_super_inits = new Array[CallSite] - for msupertype in mclassdef.supertypes do - # FIXME: the order is quite arbitrary - if not msupertype.mclass.kind.need_init then continue - msupertype = msupertype.anchor_to(mmodule, mclassdef.bound_mtype) - var candidate = modelbuilder.try_get_mproperty_by_name2(self, mmodule, msupertype, mpropdef.mproperty.name) - if candidate == null then - candidate = modelbuilder.try_get_mproperty_by_name2(self, mmodule, msupertype, "init") - end - if candidate == null then - modelbuilder.error(self, "Error: Cannot do an implicit constructor call in {mpropdef}; there is no constructor named {mpropdef.mproperty.name} in {msupertype}.") - return - end - assert candidate isa MMethod - # Skip new-style init - if candidate.is_root_init then continue + # The look for new-style super constructors (called from a old style constructor) + var candidatedefs = get_super_candidatedefs(modelbuilder) + + if not candidatedefs.is_empty and auto_super_inits.is_empty then - var candidatedefs = candidate.lookup_definitions(mmodule, anchor) var candidatedef = candidatedefs.first - # TODO, we drop the others propdefs in the callsite, that is not great :( + if candidatedefs.length > 1 then + var cd2 = candidatedefs[1] + modelbuilder.error(self, "Error: cannot do an implicit constructor call to conflicting inherited inits `{cd2}({cd2.initializers.join(", ")}`) and `{candidatedef}({candidatedef.initializers.join(", ")}`). NOTE: Do not mix old-style and new-style init!") + is_broken = true + return + end - var msignature = candidatedef.new_msignature or else candidatedef.msignature + var msignature = candidatedef.msignature msignature = msignature.resolve_for(recvtype, anchor, mmodule, true) - var callsite = new CallSite(self, recvtype, mmodule, anchor, true, candidate, candidatedef, msignature, false) - auto_super_inits.add(callsite) - end - - # No old style? The look for new-style super constructors (called from a old style constructor) - var the_root_init_mmethod = modelbuilder.the_root_init_mmethod - if the_root_init_mmethod != null and auto_super_inits.is_empty then - var candidatedefs = the_root_init_mmethod.lookup_definitions(mmodule, anchor) + if msignature.arity > mpropdef.msignature.arity then + modelbuilder.error(self, "Error: cannot do an implicit constructor call to `{candidatedef}{msignature}`. Expected at least `{msignature.arity}` arguments.") + is_broken = true + return + end - # Search the longest-one and checks for conflict - var candidatedef = candidatedefs.first - if candidatedefs.length > 1 then - # Check for conflict in the order of initializers - # Each initializer list must me a prefix of the longest list - # part 1. find the longest list - for spd in candidatedefs do - if spd.initializers.length > candidatedef.initializers.length then candidatedef = spd - end - # compare - for spd in candidatedefs do - var i = 0 - for p in spd.initializers do - if p != candidatedef.initializers[i] then - modelbuilder.error(self, "Error: Cannot do an implicit constructor call to comflicting for inherited inits {spd}({spd.initializers.join(", ")}) and {candidatedef}({candidatedef.initializers.join(", ")}). NOTE: Do not mix old-style and new-style init!") - return - end - i += 1 + if candidatedef.mproperty != mpropdef.mproperty then + var i = 0 + for candidat_mparameter in msignature.mparameters do + var actual_mparameter = mpropdef.msignature.mparameters[i] + if not candidat_mparameter.mtype.is_subtype(mmodule, anchor, actual_mparameter.mtype) then + modelbuilder.error(self, "Type Error: expected argument #{i} of type `{candidat_mparameter.mtype}`, got implicit argument `{candidat_mparameter.name}` of type `{actual_mparameter.mtype}`. Signature is {msignature}") + return end + i += 1 end end - var msignature = candidatedef.new_msignature or else candidatedef.msignature - msignature = msignature.resolve_for(recvtype, anchor, mmodule, true) - - var callsite = new CallSite(self, recvtype, mmodule, anchor, true, the_root_init_mmethod, candidatedef, msignature, false) + var callsite = new CallSite(hot_location, recvtype, mmodule, anchor, true, candidatedef.mproperty, candidatedef, msignature, false) auto_super_inits.add(callsite) + modelbuilder.toolcontext.info("Auto-super init for {mpropdef} to {candidatedef.full_name}", 4) + else if candidatedefs.is_empty then + # skip broken + is_broken = true + return end if auto_super_inits.is_empty then - modelbuilder.error(self, "Error: No constructors to call implicitely in {mpropdef}. Call one explicitely.") + modelbuilder.error(self, "Error: no constructors to call implicitly in `{mpropdef}`. Call one explicitly.") return end - # Can the super-constructors be called? - for auto_super_init in auto_super_inits do - var auto_super_init_def = auto_super_init.mpropdef - var msig = mpropdef.msignature.as(not null) - var supermsig = auto_super_init.msignature - if supermsig.arity > msig.arity then - modelbuilder.error(self, "Error: Cannot do an implicit constructor call to {auto_super_init_def}{supermsig}. Expected at least {supermsig.arity} arguments, got {msig.arity}.") - continue - end - var i = 0 - for sp in supermsig.mparameters do - var p = msig.mparameters[i] - var sub = p.mtype - var sup = sp.mtype - if not sub.is_subtype(mmodule, anchor, sup) then - modelbuilder.error(self, "Error: Cannot do an implicit constructor call to {auto_super_init_def}{supermsig}. Expected argument #{i} of type {sp.mtype}, got implicit argument {p.name} of type {p.mtype}.") - break - end - i += 1 - end - end self.auto_super_inits = auto_super_inits end + # This method returns the list of possible candidates for the current definition. + # + # Warning this method supports super call from old_style_init to default_inits without signature verification!!! + private fun get_super_candidatedefs(modelbuilder: ModelBuilder): Array[MMethodDef] + do + var candidatedefs = new Array[MMethodDef] + + var mclassdef = self.parent.as(AClassdef).mclassdef + if mclassdef == null or mclassdef.is_broken then return candidatedefs # skip error + var mpropdef = self.mpropdef + if mpropdef == null or mpropdef.is_broken then return candidatedefs # skip error + var mmodule = mpropdef.mclassdef.mmodule + var anchor = mclassdef.bound_mtype + var mproperty = mpropdef.mproperty + + # The look for new-style super constructors (called from a old style constructor) + var the_root_init_mmethod = modelbuilder.the_root_init_mmethod + + if mpropdef.is_old_style_init then + var superprop: nullable MMethodDef = null + for mclass in mclassdef.mclass.in_hierarchy(mmodule).direct_greaters do + candidatedefs.add(mclass.intro.default_init.as(not null)) + end + else + candidatedefs = the_root_init_mmethod.lookup_definitions(mmodule, anchor) + end + return candidatedefs + end end redef class ANode @@ -209,8 +191,12 @@ end redef class ASendExpr redef fun accept_auto_super_init(v) do - var mproperty = self.callsite.mproperty - if mproperty.is_init then + var callsite = self.callsite + if callsite == null then + v.is_broken = true + return + end + if callsite.mproperty.is_init then v.has_explicit_super_init = self end end