if mpropdef.bound == null then continue
if not check_virtual_types_circularity(npropdef, mpropdef.mproperty, mclassdef.bound_mtype, mclassdef.mmodule) then
# Invalidate the bound
- mpropdef.bound = mclassdef.mmodule.model.null_type
+ mpropdef.is_broken = true
+ mpropdef.bound = new MBottomType(mclassdef.mmodule.model)
end
end
for npropdef in nclassdef2.n_propdefs do
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
for npropdef in nclassdef.n_propdefs do
if npropdef isa AMethPropdef then
if not npropdef.is_autoinit then continue # Skip non tagged autoinit
- if npropdef.mpropdef == null then return # Skip broken method
- var sig = npropdef.mpropdef.msignature
+ var mpropdef = npropdef.mpropdef
+ if mpropdef == null then return # Skip broken method
+ var sig = mpropdef.msignature
if sig == null then continue # Skip broken method
- for param in sig.mparameters do
- var ret_type = param.mtype
- var mparameter = new MParameter(param.name, ret_type, false)
- mparameters.add(mparameter)
- end
- initializers.add(npropdef.mpropdef.mproperty)
- npropdef.mpropdef.mproperty.is_autoinit = true
+ mparameters.add_all sig.mparameters
+ initializers.add(mpropdef.mproperty)
+ mpropdef.mproperty.is_autoinit = true
end
if npropdef isa AAttrPropdef then
var mreadpropdef = npropdef.mreadpropdef
- if mreadpropdef == null or mreadpropdef.msignature == null then return # Skip broken attribute
+ if mreadpropdef == null then return # Skip broken attribute
+ var msignature = mreadpropdef.msignature
+ if msignature == null then return # Skip broken attribute
if npropdef.noinit then continue # Skip noinit attribute
var atlateinit = npropdef.get_single_annotation("lateinit", self)
if atlateinit != null then
end
if npropdef.has_value then continue
var paramname = mreadpropdef.mproperty.name
- var ret_type = mreadpropdef.msignature.return_mtype
+ var ret_type = msignature.return_mtype
if ret_type == null then return
var mparameter = new MParameter(paramname, ret_type, false)
mparameters.add(mparameter)
end
end
+ var the_root_init_mmethod = self.the_root_init_mmethod
if the_root_init_mmethod == null then return
# Look for most-specific new-stype init definitions
end
# Else create the local implicit basic init definition
- var mprop = the_root_init_mmethod.as(not null)
+ 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
- nclassdef.mfree_init = mpropdef
self.toolcontext.info("{mclassdef} gets a free constructor for attributes {mpropdef}{msignature}", 3)
mclassdef.mclass.root_init = mpropdef
end
mtype = mtype.undecorate
if mtype isa MClassType then
vis_type = mtype.mclass.visibility
- mmodule_type = mtype.mclass.intro.mmodule
+ mmodule_type = mtype.mclass.intro_mmodule
else if mtype isa MVirtualType then
vis_type = mtype.mproperty.visibility
mmodule_type = mtype.mproperty.intro_mclassdef.mmodule
# nothing, always visible
else if mtype isa MNullType then
# nothing to do.
+ else if mtype isa MBottomType then
+ # nothing to do.
else
node.debug "Unexpected type {mtype}"
abort
var vt = t.mproperty
# Because `vt` is possibly unchecked, we have to do the bound-lookup manually
var defs = vt.lookup_definitions(mmodule, recv)
- # TODO something to manage correctly bound conflicts
- assert not defs.is_empty
+ if defs.is_empty then return false
nexts = new Array[MType]
for d in defs do
var next = defs.first.bound
redef class AClassdef
# Marker used in `ModelBuilder::build_properties`
private var build_properties_is_done = false
-
- # The free init (implicitely constructed by the class if required)
- var mfree_init: nullable MMethodDef = null
end
redef class MClass
res = false
end
end
+ if not res then is_broken = true
return res
end
end
mprop.is_new = n_kwnew != null
if mprop.is_new then mclassdef.mclass.has_new_factory = true
if name == "sys" then mprop.is_toplevel = true # special case for sys allowed in `new` factories
- self.check_redef_keyword(modelbuilder, mclassdef, n_kwredef, false, mprop)
+ if not self.check_redef_keyword(modelbuilder, mclassdef, n_kwredef, false, mprop) then
+ mprop.is_broken = true
+ return
+ end
else
+ if mprop.is_broken then
+ return
+ end
if 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
if is_init then
for p, n in mclassdef.mprop2npropdef do
if p != mprop and p isa MMethod and p.name == name then
- check_redef_keyword(modelbuilder, mclassdef, n_kwredef, false, p)
+ if not check_redef_keyword(modelbuilder, mclassdef, n_kwredef, false, p) then
+ mprop.is_broken = true
+ return
+ end
break
end
end
var mclassdef = mpropdef.mclassdef
var mmodule = mclassdef.mmodule
var nsig = self.n_signature
- var mysignature = self.mpropdef.msignature
+ var mysignature = mpropdef.msignature
if mysignature == null then return # Error thus skiped
# Check
if nsig != null then
if not nsig.check_signature(modelbuilder, mclassdef) then
- self.mpropdef.msignature = null # invalidate
+ mpropdef.msignature = null # invalidate
+ mpropdef.is_broken = true
return # Forward error
end
end
var precursor_ret_type = msignature.return_mtype
var ret_type = mysignature.return_mtype
if ret_type != null and precursor_ret_type == null then
- modelbuilder.error(nsig.n_type.as(not null), "Redef Error: `{mpropdef.mproperty}` is a procedure, not a function.")
- self.mpropdef.msignature = null
+ modelbuilder.error(nsig.n_type, "Redef Error: `{mpropdef.mproperty}` is a procedure, not a function.")
+ mpropdef.msignature = null
+ mpropdef.is_broken = true
return
end
var node = nsig.n_params[i]
if not modelbuilder.check_sametype(node, mmodule, mclassdef.bound_mtype, myt, prt) then
modelbuilder.error(node, "Redef Error: expected `{prt}` for parameter `{mysignature.mparameters[i].name}'; got `{myt}`.")
- self.mpropdef.msignature = null
+ mpropdef.msignature = null
+ mpropdef.is_broken = true
end
end
end
ret_type = precursor_ret_type
else if not modelbuilder.check_subtype(node, mmodule, mclassdef.bound_mtype, ret_type, precursor_ret_type) then
modelbuilder.error(node, "Redef Error: expected `{precursor_ret_type}` for return type; got `{ret_type}`.")
- self.mpropdef.msignature = null
+ mpropdef.msignature = null
+ mpropdef.is_broken = true
end
end
end
- if mysignature.arity > 0 then
+ if nsig != null then
# Check parameters visibility
for i in [0..mysignature.arity[ do
var nt = nsig.n_params[i].n_type
# For parameters, type is always useless in a redef.
# For return type, type is useless if not covariant with introduction.
redef fun check_repeated_types(modelbuilder) do
+ var mpropdef = self.mpropdef
+ if mpropdef == null then return
if mpropdef.is_intro or n_signature == null then return
# check params
for param in n_signature.n_params do
end
is_lazy = true
var mlazyprop = new MAttribute(mclassdef, "lazy _" + name, none_visibility)
+ mlazyprop.is_fictive = true
var mlazypropdef = new MAttributeDef(mclassdef, mlazyprop, self.location)
+ mlazypropdef.is_fictive = true
self.mlazypropdef = mlazypropdef
end
if nexpr != null then
if nexpr isa ANewExpr then
mtype = modelbuilder.resolve_mtype_unchecked(mmodule, mclassdef, nexpr.n_type, true)
+ else if nexpr isa AAsCastExpr then
+ mtype = modelbuilder.resolve_mtype_unchecked(mmodule, mclassdef, nexpr.n_type, true)
else if nexpr isa AIntegerExpr then
var cla: nullable MClass = null
if nexpr.value isa Int then
# Type is useless if the attribute type is the same thant the intro.
redef fun check_repeated_types(modelbuilder) do
+ var mreadpropdef = self.mreadpropdef
+ if mreadpropdef == null then return
if mreadpropdef.is_intro or n_type == null then return
# get intro
var intro = mreadpropdef.mproperty.intro
redef fun build_property(modelbuilder, mclassdef)
do
- var name = self.n_id.text
- var mprop = modelbuilder.try_get_mproperty_by_name(self.n_id, mclassdef, name)
+ var name = self.n_qid.n_id.text
+ var mprop = modelbuilder.try_get_mproperty_by_name(self.n_qid, mclassdef, name)
if mprop == null then
var mvisibility = new_property_visibility(modelbuilder, mclassdef, self.n_visibility)
mprop = new MVirtualTypeProp(mclassdef, name, mvisibility)
for c in name.chars do if c >= 'a' and c<= 'z' then
- modelbuilder.warning(n_id, "bad-type-name", "Warning: lowercase in the virtual type `{name}`.")
+ modelbuilder.warning(n_qid, "bad-type-name", "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, mclassdef, self.n_kwredef, true, mprop) then return
assert mprop isa MVirtualTypeProp
check_redef_property_visibility(modelbuilder, self.n_visibility, mprop)
end
- mclassdef.mprop2npropdef[mprop] = self
var mpropdef = new MVirtualTypeDef(mclassdef, mprop, self.location)
self.mpropdef = mpropdef
- modelbuilder.mpropdef2npropdef[mpropdef] = self
if mpropdef.is_intro then
modelbuilder.toolcontext.info("{mpropdef} introduces new type {mprop.full_name}", 4)
else
modelbuilder.toolcontext.info("{mpropdef} redefines type {mprop.full_name}", 4)
end
+ if not self.check_redef_keyword(modelbuilder, mclassdef, self.n_kwredef, not mpropdef.is_intro, mprop) then
+ mpropdef.is_broken =true
+ end
+ mclassdef.mprop2npropdef[mprop] = self
+ modelbuilder.mpropdef2npropdef[mpropdef] = self
set_doc(mpropdef, modelbuilder)
var atfixed = get_single_annotation("fixed", modelbuilder)
# Check redefinitions
for p in mpropdef.mproperty.lookup_super_definitions(mmodule, anchor) do
var supbound = p.bound
- if supbound == null then break # broken super bound, skip error
+ if supbound == null or supbound isa MBottomType or p.is_broken then break # broken super bound, skip error
if p.is_fixed then
modelbuilder.error(self, "Redef Error: virtual type `{mpropdef.mproperty}` is fixed in super-class `{p.mclassdef.mclass}`.")
break