X-Git-Url: http://nitlanguage.org diff --git a/src/modelize_property.nit b/src/modelize_property.nit index 0215897..57e847b 100644 --- a/src/modelize_property.nit +++ b/src/modelize_property.nit @@ -18,6 +18,7 @@ module modelize_property import modelize_class +private import annotation redef class ToolContext var modelize_property_phase: Phase = new ModelizePropertyPhase(self, [modelize_class_phase]) @@ -28,6 +29,7 @@ private class ModelizePropertyPhase redef fun process_nmodule(nmodule) do for nclassdef in nmodule.n_classdefs do + if nclassdef.all_defs == null then continue # skip non principal classdef toolcontext.modelbuilder.build_properties(nclassdef) end end @@ -35,10 +37,10 @@ end redef class ModelBuilder # Register the npropdef associated to each mpropdef - # FIXME: why not refine the MPropDef class with a nullable attribute? + # FIXME: why not refine the `MPropDef` class with a nullable attribute? var mpropdef2npropdef: HashMap[MPropDef, APropdef] = new HashMap[MPropDef, APropdef] - # Build the properties of `nclassdef'. + # Build the properties of `nclassdef`. # REQUIRE: all superclasses are built. private fun build_properties(nclassdef: AClassdef) do @@ -48,23 +50,31 @@ redef class ModelBuilder var mclassdef = nclassdef.mclassdef.as(not null) if mclassdef.in_hierarchy == null then return # Skip error for superclassdef in mclassdef.in_hierarchy.direct_greaters do + if not mclassdef2nclassdef.has_key(superclassdef) then continue build_properties(mclassdef2nclassdef[superclassdef]) end - for npropdef in nclassdef.n_propdefs do - npropdef.build_property(self, nclassdef) - end - for npropdef in nclassdef.n_propdefs do - npropdef.build_signature(self, nclassdef) - end - for npropdef in nclassdef.n_propdefs do - npropdef.check_signature(self, nclassdef) + for nclassdef2 in nclassdef.all_defs do + for npropdef in nclassdef2.n_propdefs do + npropdef.build_property(self, mclassdef) + end + for npropdef in nclassdef2.n_propdefs do + npropdef.build_signature(self) + end + for npropdef in nclassdef2.n_propdefs do + npropdef.check_signature(self) + end end process_default_constructors(nclassdef) end + # the root init of the Object class + # Is usually implicitly defined + # Then explicit or implicit definitions of root-init are attached to it + var the_root_init_mmethod: nullable MMethod + # Introduce or inherit default constructor - # This is the last part of `build_properties'. + # This is the last part of `build_properties`. private fun process_default_constructors(nclassdef: AClassdef) do var mclassdef = nclassdef.mclassdef.as(not null) @@ -72,29 +82,60 @@ redef class ModelBuilder # Are we a refinement if not mclassdef.is_intro then return + var mmodule = nclassdef.mclassdef.mmodule + + # Look for the init in Object, or create it + if mclassdef.mclass.name == "Object" and the_root_init_mmethod == null then + # Create the implicit root-init method + var mprop = new MMethod(mclassdef, "init", mclassdef.mclass.visibility) + mprop.is_root_init = true + var mpropdef = new MMethodDef(mclassdef, mprop, nclassdef.location) + var mparameters = new Array[MParameter] + var msignature = new MSignature(mparameters, null) + mpropdef.msignature = msignature + mpropdef.new_msignature = msignature + mprop.is_init = true + nclassdef.mfree_init = mpropdef + self.toolcontext.info("{mclassdef} gets a free empty constructor {mpropdef}{msignature}", 3) + the_root_init_mmethod = mprop + return + end + # Is the class forbid constructors? if not mclassdef.mclass.kind.need_init then return # Is there already a constructor defined? + var defined_init: nullable MMethodDef = null for mpropdef in mclassdef.mpropdefs do if not mpropdef isa MMethodDef then continue - if mpropdef.mproperty.is_init then return + if not mpropdef.mproperty.is_init then continue + if mpropdef.mproperty.is_root_init then + assert defined_init == null + defined_init = mpropdef + else + # An explicit old-style init, so return + return + end end if not nclassdef isa AStdClassdef then return - var mmodule = nclassdef.mclassdef.mmodule - # Do we inherit for a constructor? - var combine = new Array[MMethod] - var inhc: nullable MClass = null - for st in mclassdef.supertypes do + # Do we inherit a old-style constructor? + var combine = new Array[MMethod] # old-style constructors without arguments + var inhc: nullable MClass = null # single super-class with a constructor with arguments + if defined_init == null then for st in mclassdef.supertypes do var c = st.mclass if not c.kind.need_init then continue - st = st.anchor_to(mmodule, nclassdef.mclassdef.bound_mtype) + st = st.anchor_to(mmodule, mclassdef.bound_mtype) var candidate = self.try_get_mproperty_by_name2(nclassdef, mmodule, st, "init").as(nullable MMethod) - if candidate != null and candidate.intro.msignature.arity == 0 then - combine.add(candidate) - continue + if candidate != null then + if candidate.is_root_init then continue + if candidate.intro.msignature != null then + if candidate.intro.msignature.arity == 0 then + combine.add(candidate) + continue + end + end end var inhc2 = c.inherit_init_from if inhc2 == null then inhc2 = c @@ -105,22 +146,68 @@ redef class ModelBuilder inhc = inhc2 end end + + # Collect undefined attributes + var mparameters = new Array[MParameter] + var initializers = new Array[MProperty] + var anode: nullable ANode = null + for npropdef in nclassdef.n_propdefs do + if npropdef isa AAttrPropdef then + if npropdef.mpropdef == null then return # Skip broken attribute + var at = npropdef.get_single_annotation("noinit", self) + if at != null then + npropdef.noinit = true + if npropdef.n_expr != null then + self.error(at, "Error: `noinit` attributes cannot have an initial value") + end + continue # Skip noinit attributes + end + if npropdef.n_expr != null then continue + var paramname = npropdef.mpropdef.mproperty.name.substring_from(1) + var ret_type = npropdef.mpropdef.static_mtype + if ret_type == null then return + var mparameter = new MParameter(paramname, ret_type, false) + mparameters.add(mparameter) + var msetter = npropdef.mwritepropdef + if msetter == null then + # No setter, it is a old-style attribute, so just add it + initializers.add(npropdef.mpropdef.mproperty) + else + # Add the setter to the list + initializers.add(msetter.mproperty) + end + if anode == null then anode = npropdef + end + end + if anode == null then anode = nclassdef + if combine.is_empty and inhc != null then + if not mparameters.is_empty then + self.error(anode,"Error: {mclassdef} cannot inherit constructors from {inhc} because there is attributes without initial values: {mparameters.join(", ")}") + return + end + # TODO: actively inherit the consturctor self.toolcontext.info("{mclassdef} inherits all constructors from {inhc}", 3) - mclassdef.mclass.inherit_init_from = inhc - return + #mclassdef.mclass.inherit_init_from = inhc + #return end + if not combine.is_empty and inhc != null then self.error(nclassdef, "Error: Cannot provide a defaut constructor: conflict for {combine.join(", ")} and {inhc}") return end - if not combine.is_empty then + if mparameters.is_empty and combine.length == 1 then + # No need to create a local init, the inherited one is enough + inhc = combine.first.intro_mclassdef.mclass + mclassdef.mclass.inherit_init_from = inhc + self.toolcontext.info("{mclassdef} inherits all constructors from {inhc}", 3) + return + end nclassdef.super_inits = combine var mprop = new MMethod(mclassdef, "init", mclassdef.mclass.visibility) var mpropdef = new MMethodDef(mclassdef, mprop, nclassdef.location) - var mparameters = new Array[MParameter] var msignature = new MSignature(mparameters, null) mpropdef.msignature = msignature mprop.is_init = true @@ -129,27 +216,116 @@ redef class ModelBuilder return end - # Collect undefined attributes - var mparameters = new Array[MParameter] - for npropdef in nclassdef.n_propdefs do - if npropdef isa AAttrPropdef and npropdef.n_expr == null then - if npropdef.mpropdef == null then return # Skip broken attribute - var paramname = npropdef.mpropdef.mproperty.name.substring_from(1) - var ret_type = npropdef.mpropdef.static_mtype - if ret_type == null then return - var mparameter = new MParameter(paramname, ret_type, false) - mparameters.add(mparameter) + if the_root_init_mmethod == null then return + + # Look for nost-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.fatal_error(nclassdef.location, "Fatal error: {mclassdef} does not specialize {the_root_init_mmethod.intro_mclassdef}. Possible duplication of the root class `Object`?") + end + + # Search the longest-one and checks for conflict + var longest = spropdefs.first + if spropdefs.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 spropdefs do + if spd.initializers.length > longest.initializers.length then longest = spd + end + # part 2. compare + for spd in spropdefs do + var i = 0 + for p in spd.initializers do + if p != longest.initializers[i] then + self.error(nclassdef, "Error: conflict for inherited inits {spd}({spd.initializers.join(", ")}) and {longest}({longest.initializers.join(", ")})") + return + end + i += 1 + end end end - var mprop = new MMethod(mclassdef, "init", mclassdef.mclass.visibility) + # Can we just inherit? + if spropdefs.length == 1 and mparameters.is_empty and defined_init == null then + self.toolcontext.info("{mclassdef} inherits the basic constructor {longest}", 3) + return + end + + # Combine the inherited list to what is collected + if longest.initializers.length > 0 then + mparameters.prepend longest.new_msignature.mparameters + initializers.prepend longest.initializers + end + + # If we already have a basic init definition, then setup its initializers + if defined_init != null then + defined_init.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) + return + end + + # Else create the local implicit basic init definition + var mprop = the_root_init_mmethod.as(not null) var mpropdef = new MMethodDef(mclassdef, mprop, nclassdef.location) + mpropdef.has_supercall = true + mpropdef.initializers.add_all(initializers) var msignature = new MSignature(mparameters, null) - mpropdef.msignature = msignature - mprop.is_init = true + mpropdef.new_msignature = msignature + mpropdef.msignature = new MSignature(new Array[MParameter], null) # always an empty real signature nclassdef.mfree_init = mpropdef self.toolcontext.info("{mclassdef} gets a free constructor for attributes {mpropdef}{msignature}", 3) end + + # Check the visibility of `mtype` as an element of the signature of `mpropdef`. + fun check_visibility(node: ANode, mtype: MType, mpropdef: MPropDef) + do + var mmodule = mpropdef.mclassdef.mmodule + var mproperty = mpropdef.mproperty + + # Extract visibility information of the main part of `mtype` + # It is a case-by case + var vis_type: nullable MVisibility = null # The own visibility of the type + var mmodule_type: nullable MModule = null # The origial module of the type + mtype = mtype.as_notnullable + if mtype isa MClassType then + vis_type = mtype.mclass.visibility + mmodule_type = mtype.mclass.intro.mmodule + else if mtype isa MVirtualType then + vis_type = mtype.mproperty.visibility + mmodule_type = mtype.mproperty.intro_mclassdef.mmodule + else if mtype isa MParameterType then + # nothing, always visible + else + node.debug "Unexpected type {mtype}" + abort + end + + if vis_type != null then + assert mmodule_type != null + var vis_module_type = mmodule.visibility_for(mmodule_type) # the visibility of the original module + if mproperty.visibility > vis_type then + error(node, "Error: The {mproperty.visibility} property `{mproperty}` cannot contain the {vis_type} type `{mtype}`") + return + else if mproperty.visibility > vis_module_type then + error(node, "Error: The {mproperty.visibility} property `{mproperty}` cannot contain the type `{mtype}` from the {vis_module_type} module `{mmodule_type}`") + return + end + end + + # No error, try to go deeper in generic types + if node isa AType then + for a in node.n_types do + var t = a.mtype + if t == null then continue # Error, thus skipped + check_visibility(a, t, mpropdef) + end + else if mtype isa MGenericType then + for t in mtype.arguments do check_visibility(node, t, mpropdef) + end + end end redef class MClass @@ -158,6 +334,12 @@ redef class MClass var inherit_init_from: nullable MClass = null end +redef class MPropDef + # Does the MPropDef contains a call to super or a call of a super-constructor? + # Subsequent phases of the frontend (esp. typing) set it if required + var has_supercall: Bool writable = false +end + redef class AClassdef var build_properties_is_done: Bool = false # The list of super-constructor to call at the start of the free constructor @@ -166,8 +348,10 @@ redef class AClassdef # The free init (implicitely constructed by the class if required) var mfree_init: nullable MMethodDef = null +end - # What is the APropdef associated to a MProperty? +redef class MClassDef + # What is the `APropdef` associated to a `MProperty`? # Used to check multiple definition of a property. var mprop2npropdef: Map[MProperty, APropdef] = new HashMap[MProperty, APropdef] end @@ -198,17 +382,23 @@ redef class APropdef # The associated main model entity type MPROPDEF: MPropDef - # The associated propdef once build by a `ModelBuilder' + # The associated propdef once build by a `ModelBuilder` var mpropdef: nullable MPROPDEF writable - private fun build_property(modelbuilder: ModelBuilder, nclassdef: AClassdef) is abstract - private fun build_signature(modelbuilder: ModelBuilder, nclassdef: AClassdef) is abstract - private fun check_signature(modelbuilder: ModelBuilder, nclassdef: AClassdef) is abstract - private fun new_property_visibility(modelbuilder: ModelBuilder, nclassdef: AClassdef, nvisibility: nullable AVisibility): MVisibility + private fun build_property(modelbuilder: ModelBuilder, mclassdef: MClassDef) is abstract + private fun build_signature(modelbuilder: ModelBuilder) is abstract + private fun check_signature(modelbuilder: ModelBuilder) is abstract + private fun new_property_visibility(modelbuilder: ModelBuilder, mclassdef: MClassDef, nvisibility: nullable AVisibility): MVisibility do var mvisibility = public_visibility - if nvisibility != null then mvisibility = nvisibility.mvisibility - if nclassdef.mclassdef.mclass.visibility == private_visibility then + if nvisibility != null then + mvisibility = nvisibility.mvisibility + if mvisibility == intrude_visibility then + modelbuilder.error(nvisibility, "Error: intrude is not a legal visibility for properties.") + mvisibility = public_visibility + end + end + if mclassdef.mclass.visibility == private_visibility then if mvisibility == protected_visibility then assert nvisibility != null modelbuilder.error(nvisibility, "Error: The only legal visibility for properties in a private class is private.") @@ -222,7 +412,17 @@ redef class APropdef return mvisibility end - private fun check_redef_property_visibility(modelbuilder: ModelBuilder, nclassdef: AClassdef, nvisibility: nullable AVisibility, mprop: MProperty) + private fun set_doc(mpropdef: MPropDef) + do + var ndoc = self.n_doc + if ndoc != null then + var mdoc = ndoc.to_mdoc + mpropdef.mdoc = mdoc + mdoc.original_mentity = mpropdef + end + end + + private fun check_redef_property_visibility(modelbuilder: ModelBuilder, nvisibility: nullable AVisibility, mprop: MProperty) do if nvisibility == null then return var mvisibility = nvisibility.mvisibility @@ -231,20 +431,29 @@ redef class APropdef end end - private fun check_redef_keyword(modelbuilder: ModelBuilder, nclassdef: AClassdef, kwredef: nullable Token, need_redef: Bool, mprop: MProperty): Bool + private fun check_redef_keyword(modelbuilder: ModelBuilder, mclassdef: MClassDef, kwredef: nullable Token, need_redef: Bool, mprop: MProperty): Bool do - if nclassdef.mprop2npropdef.has_key(mprop) then - modelbuilder.error(self, "Error: A property {mprop} is already defined in class {nclassdef.mclassdef.mclass}.") + if mclassdef.mprop2npropdef.has_key(mprop) then + modelbuilder.error(self, "Error: A property {mprop} is already defined in class {mclassdef.mclass} at line {mclassdef.mprop2npropdef[mprop].location.line_start}.") return false end + if mprop isa MMethod and mprop.is_toplevel != (parent isa ATopClassdef) then + if mprop.is_toplevel then + modelbuilder.error(self, "Error: {mprop} is a top level method.") + else + modelbuilder.error(self, "Error: {mprop} is not a top level method.") + end + return false + + end if kwredef == null then if need_redef then - modelbuilder.error(self, "Redef error: {nclassdef.mclassdef.mclass}::{mprop.name} is an inherited property. To redefine it, add the redef keyword.") + modelbuilder.error(self, "Redef error: {mclassdef.mclass}::{mprop.name} is an inherited property. To redefine it, add the redef keyword.") return false end else if not need_redef then - modelbuilder.error(self, "Error: No property {nclassdef.mclassdef.mclass}::{mprop.name} is inherited. Remove the redef keyword to define a new property.") + modelbuilder.error(self, "Error: No property {mclassdef.mclass}::{mprop.name} is inherited. Remove the redef keyword to define a new property.") return false end end @@ -269,15 +478,16 @@ redef class ASignature var ret_type: nullable MType = null # Visit and fill information about a signature - private fun visit_signature(modelbuilder: ModelBuilder, nclassdef: AClassdef): Bool + private fun visit_signature(modelbuilder: ModelBuilder, mclassdef: MClassDef): Bool do + var mmodule = mclassdef.mmodule var param_names = self.param_names var param_types = self.param_types for np in self.n_params do param_names.add(np.n_id.text) var ntype = np.n_type if ntype != null then - var mtype = modelbuilder.resolve_mtype(nclassdef, ntype) + var mtype = modelbuilder.resolve_mtype(mmodule, mclassdef, ntype) if mtype == null then return false # Skip error for i in [0..param_names.length-param_types.length[ do param_types.add(mtype) @@ -294,20 +504,16 @@ redef class ASignature end var ntype = self.n_type if ntype != null then - self.ret_type = modelbuilder.resolve_mtype(nclassdef, ntype) + self.ret_type = modelbuilder.resolve_mtype(mmodule, mclassdef, ntype) if self.ret_type == null then return false # Skip errir end - for nclosure in self.n_closure_decls do - if not nclosure.n_signature.visit_signature(modelbuilder, nclassdef) then return false - end - self.is_visited = true return true end # Build a visited signature - fun build_signature(modelbuilder: ModelBuilder, nclassdef: AClassdef): nullable MSignature + fun build_signature(modelbuilder: ModelBuilder): nullable MSignature do if param_names.length != param_types.length then # Some parameters are typed, other parameters are not typed. @@ -318,6 +524,7 @@ redef class ASignature var mparameters = new Array[MParameter] for i in [0..param_names.length[ do var mparameter = new MParameter(param_names[i], param_types[i], i == vararg_rank) + self.n_params[i].mparameter = mparameter mparameters.add(mparameter) end @@ -326,28 +533,57 @@ redef class ASignature end end +redef class AParam + # The associated mparameter if any + var mparameter: nullable MParameter = null +end + redef class AMethPropdef redef type MPROPDEF: MMethodDef - # The associated super init if any - var super_init: nullable MMethod - redef fun build_property(modelbuilder, nclassdef) + + # Can self be used as a root init? + private fun look_like_a_root_init(modelbuilder: ModelBuilder): Bool do - var is_init = self isa AInitPropdef - var mclassdef = nclassdef.mclassdef.as(not null) + # Need the `init` keyword + if n_kwinit == null then return false + # Need to by anonymous + if self.n_methid != null then return false + # No parameters + if self.n_signature.n_params.length > 0 then return false + # Cannot be private or something + if not self.n_visibility isa APublicVisibility then return false + # No annotation on itself + if get_single_annotation("old_style_init", modelbuilder) != null then return false + # Nor on its module + var amod = self.parent.parent.as(AModule) + var amoddecl = amod.n_moduledecl + if amoddecl != null then + var old = amoddecl.get_single_annotation("old_style_init", modelbuilder) + if old != null then return false + end + + return true + end + + redef fun build_property(modelbuilder, mclassdef) + do + var n_kwinit = n_kwinit + var n_kwnew = n_kwnew + var is_init = n_kwinit != null or n_kwnew != null var name: String var amethodid = self.n_methid var name_node: ANode if amethodid == null then - if self isa AMainMethPropdef then + if not is_init then name = "main" name_node = self - else if self isa AConcreteInitPropdef then + else if n_kwinit != null then name = "init" - name_node = self.n_kwinit - else if self isa AExternInitPropdef then + name_node = n_kwinit + else if n_kwnew != null then name = "init" - name_node = self.n_kwnew + name_node = n_kwnew else abort end @@ -366,26 +602,30 @@ redef class AMethPropdef var mprop: nullable MMethod = null if not is_init or n_kwredef != null then mprop = modelbuilder.try_get_mproperty_by_name(name_node, mclassdef, name).as(nullable MMethod) + if mprop == null and look_like_a_root_init(modelbuilder) then + mprop = modelbuilder.the_root_init_mmethod + end if mprop == null then - var mvisibility = new_property_visibility(modelbuilder, nclassdef, self.n_visibility) + var mvisibility = new_property_visibility(modelbuilder, mclassdef, self.n_visibility) mprop = new MMethod(mclassdef, name, mvisibility) + if look_like_a_root_init(modelbuilder) and modelbuilder.the_root_init_mmethod == null then + modelbuilder.the_root_init_mmethod = mprop + mprop.is_root_init = true + end mprop.is_init = is_init - mprop.is_new = self isa AExternInitPropdef - if not self.check_redef_keyword(modelbuilder, nclassdef, n_kwredef, false, mprop) then return + mprop.is_new = n_kwnew != null + if parent isa ATopClassdef then mprop.is_toplevel = true + if not self.check_redef_keyword(modelbuilder, mclassdef, n_kwredef, false, mprop) then return else - if n_kwredef == null then - if self isa AMainMethPropdef then - # no warning - else - if not self.check_redef_keyword(modelbuilder, nclassdef, n_kwredef, true, mprop) then return - end - end - check_redef_property_visibility(modelbuilder, nclassdef, self.n_visibility, mprop) + if not mprop.is_root_init and not self.check_redef_keyword(modelbuilder, mclassdef, n_kwredef, not self isa AMainMethPropdef, mprop) then return + check_redef_property_visibility(modelbuilder, self.n_visibility, mprop) end - nclassdef.mprop2npropdef[mprop] = self + mclassdef.mprop2npropdef[mprop] = self var mpropdef = new MMethodDef(mclassdef, mprop, self.location) + set_doc(mpropdef) + self.mpropdef = mpropdef modelbuilder.mpropdef2npropdef[mpropdef] = self if mpropdef.is_intro then @@ -395,11 +635,12 @@ redef class AMethPropdef end end - redef fun build_signature(modelbuilder, nclassdef) + redef fun build_signature(modelbuilder) do var mpropdef = self.mpropdef if mpropdef == null then return # Error thus skiped - var mmodule = mpropdef.mclassdef.mmodule + var mclassdef = mpropdef.mclassdef + var mmodule = mclassdef.mmodule var nsig = self.n_signature # Retrieve info from the signature AST @@ -408,7 +649,7 @@ redef class AMethPropdef var vararg_rank = -1 var ret_type: nullable MType = null # Return type from the AST if nsig != null then - if not nsig.visit_signature(modelbuilder, nclassdef) then return + if not nsig.visit_signature(modelbuilder, mclassdef) then return param_names = nsig.param_names param_types = nsig.param_types vararg_rank = nsig.vararg_rank @@ -431,8 +672,8 @@ redef class AMethPropdef end else if mpropdef.mproperty.is_init then # FIXME UGLY: inherit signature from a super-constructor - for msupertype in nclassdef.mclassdef.supertypes do - msupertype = msupertype.anchor_to(mmodule, nclassdef.mclassdef.bound_mtype) + for msupertype in mclassdef.supertypes do + 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 if msignature == null then @@ -465,29 +706,23 @@ redef class AMethPropdef var mparameters = new Array[MParameter] for i in [0..param_names.length[ do var mparameter = new MParameter(param_names[i], param_types[i], i == vararg_rank) + if nsig != null then nsig.n_params[i].mparameter = mparameter mparameters.add(mparameter) end msignature = new MSignature(mparameters, ret_type) mpropdef.msignature = msignature mpropdef.is_abstract = self isa ADeferredMethPropdef - - if nsig != null then - for nclosure in nsig.n_closure_decls do - var clos_signature = nclosure.n_signature.build_signature(modelbuilder, nclassdef) - if clos_signature == null then return - var mparameter = new MParameter(nclosure.n_id.text, clos_signature, false) - msignature.mclosures.add(mparameter) - end - end - + mpropdef.is_intern = self isa AInternMethPropdef + mpropdef.is_extern = self isa AExternPropdef end - redef fun check_signature(modelbuilder, nclassdef) + redef fun check_signature(modelbuilder) do var mpropdef = self.mpropdef if mpropdef == null then return # Error thus skiped - var mmodule = mpropdef.mclassdef.mmodule + var mclassdef = mpropdef.mclassdef + var mmodule = mclassdef.mmodule var nsig = self.n_signature var mysignature = self.mpropdef.msignature if mysignature == null then return # Error thus skiped @@ -510,9 +745,9 @@ redef class AMethPropdef for i in [0..mysignature.arity[ do var myt = mysignature.mparameters[i].mtype var prt = msignature.mparameters[i].mtype - if not myt.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, prt) and - not prt.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, myt) then - modelbuilder.error(nsig.n_params[i], "Redef Error: Wrong type for parameter `{mysignature.mparameters[i].name}'. found {myt}, expected {prt}.") + if not myt.is_subtype(mmodule, mclassdef.bound_mtype, prt) or + not prt.is_subtype(mmodule, mclassdef.bound_mtype, myt) then + modelbuilder.error(nsig.n_params[i], "Redef Error: Wrong type for parameter `{mysignature.mparameters[i].name}'. found {myt}, expected {prt} as in {mpropdef.mproperty.intro}.") end end end @@ -520,24 +755,46 @@ redef class AMethPropdef if ret_type == null then # Inherit the return type ret_type = precursor_ret_type - else if not ret_type.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, precursor_ret_type) then - modelbuilder.error(nsig.n_type.as(not null), "Redef Error: Wrong return type. found {ret_type}, expected {precursor_ret_type}.") + else if not ret_type.is_subtype(mmodule, mclassdef.bound_mtype, precursor_ret_type) then + modelbuilder.error(nsig.n_type.as(not null), "Redef Error: Wrong return type. found {ret_type}, expected {precursor_ret_type} as in {mpropdef.mproperty.intro}.") end end end + + if mysignature.arity > 0 then + # Check parameters visibility + for i in [0..mysignature.arity[ do + var nt = nsig.n_params[i].n_type + if nt != null then modelbuilder.check_visibility(nt, nt.mtype.as(not null), mpropdef) + end + var nt = nsig.n_type + if nt != null then modelbuilder.check_visibility(nt, nt.mtype.as(not null), mpropdef) + end end end redef class AAttrPropdef redef type MPROPDEF: MAttributeDef + # Is the node tagged `noinit`? + var noinit = false + + # Is the node taggeg lazy? + var is_lazy = false + + # The guard associated to a lasy attribute. + # Because some engines does not have a working `isset`, + # this additionnal attribute is used to guard the lazy initialization. + # TODO: to remove once isset is correctly implemented + var mlazypropdef: nullable MAttributeDef + # The associated getter (read accessor) if any var mreadpropdef: nullable MMethodDef writable # The associated setter (write accessor) if any var mwritepropdef: nullable MMethodDef writable - redef fun build_property(modelbuilder, nclassdef) + + redef fun build_property(modelbuilder, mclassdef) do - var mclassdef = nclassdef.mclassdef.as(not null) var mclass = mclassdef.mclass var name: String @@ -560,127 +817,139 @@ redef class AAttrPropdef # Old attribute style var mprop = modelbuilder.try_get_mproperty_by_name(nid, mclassdef, name) if mprop == null then - var mvisibility = new_property_visibility(modelbuilder, nclassdef, self.n_visibility) + var mvisibility = new_property_visibility(modelbuilder, mclassdef, self.n_visibility) mprop = new MAttribute(mclassdef, name, mvisibility) - if not self.check_redef_keyword(modelbuilder, nclassdef, self.n_kwredef, false, mprop) then return + if not self.check_redef_keyword(modelbuilder, mclassdef, self.n_kwredef, false, mprop) then return else assert mprop isa MAttribute - check_redef_property_visibility(modelbuilder, nclassdef, self.n_visibility, mprop) - if not self.check_redef_keyword(modelbuilder, nclassdef, self.n_kwredef, true, mprop) then return + check_redef_property_visibility(modelbuilder, self.n_visibility, mprop) + if not self.check_redef_keyword(modelbuilder, mclassdef, self.n_kwredef, true, mprop) then return end - nclassdef.mprop2npropdef[mprop] = self + mclassdef.mprop2npropdef[mprop] = self var mpropdef = new MAttributeDef(mclassdef, mprop, self.location) self.mpropdef = mpropdef modelbuilder.mpropdef2npropdef[mpropdef] = self + set_doc(mpropdef) var nreadable = self.n_readable - if nreadable != null then - var readname = name.substring_from(1) - var mreadprop = modelbuilder.try_get_mproperty_by_name(nid, mclassdef, readname).as(nullable MMethod) - if mreadprop == null then - var mvisibility = new_property_visibility(modelbuilder, nclassdef, nreadable.n_visibility) - mreadprop = new MMethod(mclassdef, readname, mvisibility) - if not self.check_redef_keyword(modelbuilder, nclassdef, nreadable.n_kwredef, false, mreadprop) then return - else - if not self.check_redef_keyword(modelbuilder, nclassdef, nreadable.n_kwredef, true, mreadprop) then return - check_redef_property_visibility(modelbuilder, nclassdef, nreadable.n_visibility, mreadprop) - end - nclassdef.mprop2npropdef[mreadprop] = self - - var mreadpropdef = new MMethodDef(mclassdef, mreadprop, self.location) - self.mreadpropdef = mreadpropdef - modelbuilder.mpropdef2npropdef[mreadpropdef] = self - end - + if nreadable != null then modelbuilder.error(nreadable, "Error: old-style getter no more supported") var nwritable = self.n_writable - if nwritable != null then - var writename = name.substring_from(1) + "=" - var mwriteprop = modelbuilder.try_get_mproperty_by_name(nid, mclassdef, writename).as(nullable MMethod) - if mwriteprop == null then - var mvisibility = new_property_visibility(modelbuilder, nclassdef, nwritable.n_visibility) - mwriteprop = new MMethod(mclassdef, writename, mvisibility) - if not self.check_redef_keyword(modelbuilder, nclassdef, nwritable.n_kwredef, false, mwriteprop) then return - else - if not self.check_redef_keyword(modelbuilder, nclassdef, nwritable.n_kwredef, true, mwriteprop) then return - check_redef_property_visibility(modelbuilder, nclassdef, nwritable.n_visibility, mwriteprop) - end - nclassdef.mprop2npropdef[mwriteprop] = self - - var mwritepropdef = new MMethodDef(mclassdef, mwriteprop, self.location) - self.mwritepropdef = mwritepropdef - modelbuilder.mpropdef2npropdef[mwritepropdef] = self - end + if nwritable != null then modelbuilder.error(nwritable, "Error: old-style setter no more supported") else # New attribute style var nid2 = self.n_id2.as(not null) - var mprop = new MAttribute(mclassdef, "@" + name, none_visibility) + var mprop = new MAttribute(mclassdef, "_" + name, private_visibility) var mpropdef = new MAttributeDef(mclassdef, mprop, self.location) self.mpropdef = mpropdef modelbuilder.mpropdef2npropdef[mpropdef] = self + set_doc(mpropdef) var readname = name var mreadprop = modelbuilder.try_get_mproperty_by_name(nid2, mclassdef, readname).as(nullable MMethod) if mreadprop == null then - var mvisibility = new_property_visibility(modelbuilder, nclassdef, self.n_visibility) + var mvisibility = new_property_visibility(modelbuilder, mclassdef, self.n_visibility) mreadprop = new MMethod(mclassdef, readname, mvisibility) - if not self.check_redef_keyword(modelbuilder, nclassdef, n_kwredef, false, mreadprop) then return + if not self.check_redef_keyword(modelbuilder, mclassdef, n_kwredef, false, mreadprop) then return else - if not self.check_redef_keyword(modelbuilder, nclassdef, n_kwredef, true, mreadprop) then return - check_redef_property_visibility(modelbuilder, nclassdef, self.n_visibility, mreadprop) + if not self.check_redef_keyword(modelbuilder, mclassdef, n_kwredef, true, mreadprop) then return + check_redef_property_visibility(modelbuilder, self.n_visibility, mreadprop) end - nclassdef.mprop2npropdef[mreadprop] = self + mclassdef.mprop2npropdef[mreadprop] = self var mreadpropdef = new MMethodDef(mclassdef, mreadprop, self.location) self.mreadpropdef = mreadpropdef modelbuilder.mpropdef2npropdef[mreadpropdef] = self + mreadpropdef.mdoc = mpropdef.mdoc + + var atlazy = self.get_single_annotation("lazy", modelbuilder) + if atlazy != null then + if n_expr == null then + modelbuilder.error(atlazy, "Error: a lazy attribute needs a value") + end + is_lazy = true + var mlazyprop = new MAttribute(mclassdef, "lazy _" + name, none_visibility) + var mlazypropdef = new MAttributeDef(mclassdef, mlazyprop, self.location) + self.mlazypropdef = mlazypropdef + end + + var atreadonly = self.get_single_annotation("readonly", modelbuilder) + if atreadonly != null then + if n_expr == null then + modelbuilder.error(atreadonly, "Error: a readonly attribute needs a value") + end + # No setter, so just leave + return + end var writename = name + "=" var nwritable = self.n_writable + var atwritable = self.get_single_annotation("writable", modelbuilder) + if atwritable != null then + if not atwritable.n_args.is_empty then + writename = atwritable.arg_as_id(modelbuilder) or else writename + end + end var mwriteprop = modelbuilder.try_get_mproperty_by_name(nid2, mclassdef, writename).as(nullable MMethod) var nwkwredef: nullable Token = null if nwritable != null then nwkwredef = nwritable.n_kwredef + if atwritable != null then nwkwredef = atwritable.n_kwredef if mwriteprop == null then var mvisibility if nwritable != null then - mvisibility = new_property_visibility(modelbuilder, nclassdef, nwritable.n_visibility) + mvisibility = new_property_visibility(modelbuilder, mclassdef, nwritable.n_visibility) + else if atwritable != null then + mvisibility = new_property_visibility(modelbuilder, mclassdef, atwritable.n_visibility) else mvisibility = private_visibility end mwriteprop = new MMethod(mclassdef, writename, mvisibility) - if not self.check_redef_keyword(modelbuilder, nclassdef, nwkwredef, false, mwriteprop) then return + if not self.check_redef_keyword(modelbuilder, mclassdef, nwkwredef, false, mwriteprop) then return else - if not self.check_redef_keyword(modelbuilder, nclassdef, nwkwredef, true, mwriteprop) then return + if not self.check_redef_keyword(modelbuilder, mclassdef, nwkwredef or else n_kwredef, true, mwriteprop) then return if nwritable != null then - check_redef_property_visibility(modelbuilder, nclassdef, nwritable.n_visibility, mwriteprop) + check_redef_property_visibility(modelbuilder, nwritable.n_visibility, mwriteprop) + else if atwritable != null then + check_redef_property_visibility(modelbuilder, atwritable.n_visibility, mwriteprop) end end - nclassdef.mprop2npropdef[mwriteprop] = self + mclassdef.mprop2npropdef[mwriteprop] = self var mwritepropdef = new MMethodDef(mclassdef, mwriteprop, self.location) self.mwritepropdef = mwritepropdef modelbuilder.mpropdef2npropdef[mwritepropdef] = self + mwritepropdef.mdoc = mpropdef.mdoc end end - redef fun build_signature(modelbuilder, nclassdef) + redef fun build_signature(modelbuilder) do var mpropdef = self.mpropdef if mpropdef == null then return # Error thus skiped - var mmodule = mpropdef.mclassdef.mmodule + var mclassdef = mpropdef.mclassdef + var mmodule = mclassdef.mmodule var mtype: nullable MType = null + var mreadpropdef = self.mreadpropdef + var ntype = self.n_type if ntype != null then - mtype = modelbuilder.resolve_mtype(nclassdef, ntype) + mtype = modelbuilder.resolve_mtype(mmodule, mclassdef, ntype) if mtype == null then return end + # Inherit the type from the getter (usually an abstact getter) + if mtype == null and mreadpropdef != null and not mreadpropdef.is_intro then + var msignature = mreadpropdef.mproperty.intro.msignature + if msignature == null then return # Error, thus skiped + mtype = msignature.return_mtype + end + + var nexpr = self.n_expr if mtype == null then - var nexpr = self.n_expr if nexpr != null then if nexpr isa ANewExpr then - mtype = modelbuilder.resolve_mtype(nclassdef, nexpr.n_type) + mtype = modelbuilder.resolve_mtype(mmodule, mclassdef, nexpr.n_type) else if nexpr isa AIntExpr then var cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int") if cla != null then mtype = cla.mclass_type @@ -703,22 +972,30 @@ redef class AAttrPropdef modelbuilder.error(self, "Error: Untyped attribute {mpropdef}. Implicit typing allowed only for literals and new.") end - else - modelbuilder.error(self, "Error: Untyped attribute {mpropdef}") + if mtype == null then return + end + else if ntype != null then + if nexpr isa ANewExpr then + var xmtype = modelbuilder.resolve_mtype(mmodule, mclassdef, nexpr.n_type) + if xmtype == mtype and modelbuilder.toolcontext.opt_warn.value >= 2 then + modelbuilder.warning(ntype, "Warning: useless type definition") + end end end - if mtype == null then return + if mtype == null then + modelbuilder.error(self, "Error: Untyped attribute {mpropdef}") + return + end mpropdef.static_mtype = mtype - var mreadpropdef = self.mreadpropdef if mreadpropdef != null then var msignature = new MSignature(new Array[MParameter], mtype) mreadpropdef.msignature = msignature end - var msritepropdef = self.mwritepropdef + var mwritepropdef = self.mwritepropdef if mwritepropdef != null then var name: String if n_id != null then @@ -730,13 +1007,19 @@ redef class AAttrPropdef var msignature = new MSignature([mparameter], null) mwritepropdef.msignature = msignature end + + var mlazypropdef = self.mlazypropdef + if mlazypropdef != null then + mlazypropdef.static_mtype = modelbuilder.model.get_mclasses_by_name("Bool").first.mclass_type + end end - redef fun check_signature(modelbuilder, nclassdef) + redef fun check_signature(modelbuilder) do var mpropdef = self.mpropdef if mpropdef == null then return # Error thus skiped - var mmodule = mpropdef.mclassdef.mmodule + var mclassdef = mpropdef.mclassdef + var mmodule = mclassdef.mmodule var ntype = self.n_type var mtype = self.mpropdef.static_mtype if mtype == null then return # Error thus skiped @@ -755,14 +1038,25 @@ redef class AAttrPropdef # Check getter and setter var meth = self.mreadpropdef - if meth != null then self.check_method_signature(modelbuilder, nclassdef, meth) + if meth != null then + self.check_method_signature(modelbuilder, meth) + var node: nullable ANode = ntype + if node == null then node = self + modelbuilder.check_visibility(node, mtype, meth) + end meth = self.mwritepropdef - if meth != null then self.check_method_signature(modelbuilder, nclassdef, meth) + if meth != null then + self.check_method_signature(modelbuilder, meth) + var node: nullable ANode = ntype + if node == null then node = self + modelbuilder.check_visibility(node, mtype, meth) + end end - private fun check_method_signature(modelbuilder: ModelBuilder, nclassdef: AClassdef, mpropdef: MMethodDef) + private fun check_method_signature(modelbuilder: ModelBuilder, mpropdef: MMethodDef) do - var mmodule = mpropdef.mclassdef.mmodule + var mclassdef = mpropdef.mclassdef + var mmodule = mclassdef.mmodule var nsig = self.n_type var mysignature = mpropdef.msignature if mysignature == null then return # Error thus skiped @@ -793,8 +1087,8 @@ redef class AAttrPropdef for i in [0..mysignature.arity[ do var myt = mysignature.mparameters[i].mtype var prt = msignature.mparameters[i].mtype - if not myt.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, prt) and - not prt.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, myt) then + if not myt.is_subtype(mmodule, mclassdef.bound_mtype, prt) or + not prt.is_subtype(mmodule, mclassdef.bound_mtype, myt) then var node: ANode if nsig != null then node = nsig else node = self modelbuilder.error(node, "Redef Error: Wrong type for parameter `{mysignature.mparameters[i].name}'. found {myt}, expected {prt}.") @@ -805,7 +1099,7 @@ redef class AAttrPropdef if ret_type == null then # Inherit the return type ret_type = precursor_ret_type - else if not ret_type.is_subtype(mmodule, nclassdef.mclassdef.bound_mtype, precursor_ret_type) then + else if not ret_type.is_subtype(mmodule, mclassdef.bound_mtype, precursor_ret_type) then var node: ANode if nsig != null then node = nsig else node = self modelbuilder.error(node, "Redef Error: Wrong return type. found {ret_type}, expected {precursor_ret_type}.") @@ -818,63 +1112,100 @@ end redef class ATypePropdef redef type MPROPDEF: MVirtualTypeDef - redef fun build_property(modelbuilder, nclassdef) + redef fun build_property(modelbuilder, mclassdef) do - var mclassdef = nclassdef.mclassdef.as(not null) var name = self.n_id.text var mprop = modelbuilder.try_get_mproperty_by_name(self.n_id, mclassdef, name) if mprop == null then - var mvisibility = new_property_visibility(modelbuilder, nclassdef, self.n_visibility) + var mvisibility = new_property_visibility(modelbuilder, mclassdef, self.n_visibility) mprop = new MVirtualTypeProp(mclassdef, name, mvisibility) - if not self.check_redef_keyword(modelbuilder, nclassdef, self.n_kwredef, false, mprop) then return + for c in name.chars do if c >= 'a' and c<= 'z' then + modelbuilder.warning(n_id, "Warning: lowercase in the virtual type {name}") + break + end + if not self.check_redef_keyword(modelbuilder, mclassdef, self.n_kwredef, false, mprop) then return else - if not self.check_redef_keyword(modelbuilder, nclassdef, self.n_kwredef, true, mprop) then return + if not self.check_redef_keyword(modelbuilder, mclassdef, self.n_kwredef, true, mprop) then return assert mprop isa MVirtualTypeProp - check_redef_property_visibility(modelbuilder, nclassdef, self.n_visibility, mprop) + check_redef_property_visibility(modelbuilder, self.n_visibility, mprop) end - nclassdef.mprop2npropdef[mprop] = self + mclassdef.mprop2npropdef[mprop] = self var mpropdef = new MVirtualTypeDef(mclassdef, mprop, self.location) self.mpropdef = mpropdef + modelbuilder.mpropdef2npropdef[mpropdef] = self + set_doc(mpropdef) + + var atfixed = get_single_annotation("fixed", modelbuilder) + if atfixed != null then + mpropdef.is_fixed = true + end end - redef fun build_signature(modelbuilder, nclassdef) + redef fun build_signature(modelbuilder) do var mpropdef = self.mpropdef if mpropdef == null then return # Error thus skiped - var mmodule = mpropdef.mclassdef.mmodule + var mclassdef = mpropdef.mclassdef + var mmodule = mclassdef.mmodule var mtype: nullable MType = null var ntype = self.n_type - mtype = modelbuilder.resolve_mtype(nclassdef, ntype) + mtype = modelbuilder.resolve_mtype(mmodule, mclassdef, ntype) if mtype == null then return mpropdef.bound = mtype # print "{mpropdef}: {mtype}" end - redef fun check_signature(modelbuilder, nclassdef) + redef fun check_signature(modelbuilder) do - var bound = self.mpropdef.bound - - # Fast case: the bound is not a formal type - if not bound isa MVirtualType then return - - var mmodule = nclassdef.mclassdef.mmodule - var anchor = nclassdef.mclassdef.bound_mtype + var mpropdef = self.mpropdef + if mpropdef == null then return # Error thus skiped - # Slow case: progress on each resolution until: (i) we loop, or (ii) we found a non formal type - var seen = [self.mpropdef.mproperty.mvirtualtype] - loop - if seen.has(bound) then + var bound = self.mpropdef.bound + if bound == null then return # Error thus skiped + + modelbuilder.check_visibility(n_type, bound, mpropdef) + + var mclassdef = mpropdef.mclassdef + var mmodule = mclassdef.mmodule + var anchor = mclassdef.bound_mtype + + # Check circularity + if bound isa MVirtualType then + # Slow case: progress on each resolution until: (i) we loop, or (ii) we found a non formal type + var seen = [self.mpropdef.mproperty.mvirtualtype] + loop + if seen.has(bound) then + seen.add(bound) + modelbuilder.error(self, "Error: circularity of virtual type definition: {seen.join(" -> ")}") + return + end seen.add(bound) - modelbuilder.error(self, "Error: circularity of virtual type definition: {seen.join(" -> ")}") - return + var next = bound.lookup_bound(mmodule, anchor) + if not next isa MVirtualType then break + bound = next + end + end + + # Check redefinitions + bound = mpropdef.bound.as(not null) + for p in mpropdef.mproperty.lookup_super_definitions(mmodule, anchor) do + var supbound = p.bound.as(not null) + if p.is_fixed then + modelbuilder.error(self, "Redef Error: Virtual type {mpropdef.mproperty} is fixed in super-class {p.mclassdef.mclass}") + break + end + if p.mclassdef.mclass == mclassdef.mclass then + # Still a warning to pass existing bad code + modelbuilder.warning(n_type, "Redef Error: a virtual type cannot be refined.") + break + end + if not bound.is_subtype(mmodule, anchor, supbound) then + modelbuilder.error(n_type, "Redef Error: Wrong bound type. Found {bound}, expected a subtype of {supbound}, as in {p}.") + break end - seen.add(bound) - var next = bound.lookup_bound(mmodule, anchor) - if not next isa MVirtualType then return - bound = next end end end