# Force building recursively
if nclassdef.build_properties_is_done then return
nclassdef.build_properties_is_done = true
- var mclassdef = nclassdef.mclassdef.as(not null)
+ var mclassdef = nclassdef.mclassdef
+ if mclassdef == null then return # skip error
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
npropdef.build_signature(self)
end
for npropdef in nclassdef2.n_propdefs do
+ if not npropdef isa ATypePropdef then continue
+ # Check circularity
+ var mpropdef = npropdef.mpropdef
+ if mpropdef == null then continue
+ 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
+ end
+ end
+ for npropdef in nclassdef2.n_propdefs do
# Check ATypePropdef first since they may be required for the other properties
if not npropdef isa ATypePropdef then continue
npropdef.check_signature(self)
if sig == null then continue # Skip broken method
if not npropdef.mpropdef.is_intro then
- self.error(at, "Error: `autoinit` cannot be set on redefinitions")
+ self.error(at, "Error: `autoinit` cannot be set on redefinitions.")
continue
end
# 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`?")
+ toolcontext.error(nclassdef.location, "Error: `{mclassdef}` does not specialize `{the_root_init_mmethod.intro_mclassdef}`. Possible duplication of the root class `Object`?")
return
end
end
if autoinit.n_args.is_empty then
- error(autoinit, "Syntax error: `autoinit` expects method identifiers, use `noautoinit` to clear all autoinits.")
+ error(autoinit, "Syntax Error: `autoinit` expects method identifiers, use `noautoinit` to clear all autoinits.")
end
# Get and check each argument
for narg in autoinit.n_args do
var id = narg.as_id
if id == null then
- error(narg, "Syntax error: `autoinit` expects method identifiers.")
+ error(narg, "Syntax Error: `autoinit` expects method identifiers.")
return
end
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(", ")})")
+ # TODO: invalidate the initializer to avoid more errors
return
end
i += 1
# 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 original module of the type
- mtype = mtype.as_notnullable
+ mtype = mtype.undecorate
if mtype isa MClassType then
vis_type = mtype.mclass.visibility
mmodule_type = mtype.mclass.intro.mmodule
mmodule_type = mtype.mproperty.intro_mclassdef.mmodule
else if mtype isa MParameterType then
# nothing, always visible
+ else if mtype isa MNullType then
+ # nothing to do.
else
node.debug "Unexpected type {mtype}"
abort
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}`")
+ 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}`")
+ error(node, "Error: the {mproperty.visibility} property `{mproperty}` cannot contain the type `{mtype}` from the {vis_module_type} module `{mmodule_type}`.")
return
end
end
for t in mtype.arguments do check_visibility(node, t, mpropdef)
end
end
+
+ # Detect circularity errors for virtual types.
+ fun check_virtual_types_circularity(node: ANode, mproperty: MVirtualTypeProp, recv: MType, mmodule: MModule): Bool
+ do
+ # Check circularity
+ # Slow case: progress on each resolution until we visit all without getting a loop
+
+ # The graph used to detect loops
+ var mtype = mproperty.mvirtualtype
+ var poset = new POSet[MType]
+
+ # The work-list of types to resolve
+ var todo = new List[MType]
+ todo.add mtype
+
+ while not todo.is_empty do
+ # The visited type
+ var t = todo.pop
+
+ if not t.need_anchor then continue
+
+ # Get the types derived of `t` (subtypes and bounds)
+ var nexts
+ if t isa MNullableType then
+ nexts = [t.mtype]
+ else if t isa MGenericType then
+ nexts = t.arguments
+ else if t isa MVirtualType then
+ 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
+ nexts = new Array[MType]
+ for d in defs do
+ var next = defs.first.bound
+ if next == null then return false
+ nexts.add next
+ end
+ else if t isa MClassType then
+ # Basic type, nothing to to
+ continue
+ else if t isa MParameterType then
+ # Parameter types cannot depend on virtual types, so nothing to do
+ continue
+ else
+ abort
+ end
+
+ # For each one
+ for next in nexts do
+ if poset.has_edge(next, t) then
+ if mtype == next then
+ error(node, "Error: circularity of virtual type definition: {next} <-> {t}.")
+ else
+ error(node, "Error: circularity of virtual type definition: {mtype} -> {next} <-> {t}.")
+ end
+ return false
+ else
+ poset.add_edge(t, next)
+ todo.add next
+ end
+ end
+ end
+ return true
+ end
end
redef class MPropDef
# SELF must be declared in Object, otherwise this will create conflicts
if intro_mclassdef.mclass.name != "Object" then
- modelbuilder.error(nintro, "Error: the virtual type SELF must be declared in Object.")
+ modelbuilder.error(nintro, "Error: the virtual type `SELF` must be declared in `Object`.")
end
# SELF must be public
if mprop.visibility != public_visibility then
- modelbuilder.error(nintro, "Error: the virtual type SELF must be public.")
+ modelbuilder.error(nintro, "Error: the virtual type `SELF` must be public.")
end
# SELF must not be fixed
if intro.is_fixed then
- modelbuilder.error(nintro, "Error: the virtual type SELF cannot be fixed.")
+ modelbuilder.error(nintro, "Error: the virtual type `SELF` cannot be fixed.")
end
return
if nvisibility != null then
mvisibility = nvisibility.mvisibility
if mvisibility == intrude_visibility then
- modelbuilder.error(nvisibility, "Error: intrude is not a legal visibility for properties.")
+ 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.")
+ modelbuilder.error(nvisibility, "Error: `private` is the only legal visibility for properties in a private class.")
else if mvisibility == private_visibility then
assert nvisibility != null
- modelbuilder.advice(nvisibility, "useless-visibility", "Warning: private is superfluous since the only legal visibility for properties in a private class is private.")
+ modelbuilder.advice(nvisibility, "useless-visibility", "Warning: `private` is superfluous since the only legal visibility for properties in a private class is private.")
end
mvisibility = private_visibility
end
if nvisibility == null then return
var mvisibility = nvisibility.mvisibility
if mvisibility != mprop.visibility and mvisibility != public_visibility then
- modelbuilder.error(nvisibility, "Error: redefinition changed the visibility from a {mprop.visibility} to a {mvisibility}")
+ modelbuilder.error(nvisibility, "Error: redefinition changed the visibility from `{mprop.visibility}` to `{mvisibility}`.")
end
end
private fun check_redef_keyword(modelbuilder: ModelBuilder, mclassdef: MClassDef, kwredef: nullable Token, need_redef: Bool, mprop: MProperty): Bool
do
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
+ 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_root_init then return true
if kwredef == null then
if need_redef then
- modelbuilder.error(self, "Redef error: {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
end
else
if not need_redef then
- modelbuilder.error(self, "Error: No property {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
end
if np.n_dotdotdot != null then
if self.vararg_rank != -1 then
- modelbuilder.error(np, "Error: {param_names[self.vararg_rank]} is already a vararg")
+ modelbuilder.error(np, "Error: `{param_names[self.vararg_rank]}` is already a vararg")
return false
else
self.vararg_rank = param_names.length - 1
mprop.is_init = is_init
mprop.is_new = n_kwnew != null
if mprop.is_new then mclassdef.mclass.has_new_factory = true
- if parent isa ATopClassdef then mprop.is_toplevel = 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)
else
if not self.check_redef_keyword(modelbuilder, mclassdef, n_kwredef, not self isa AMainMethPropdef, mprop) then return
if param_names.length != msignature.arity then
var node: ANode
if nsig != null then node = nsig else node = self
- modelbuilder.error(node, "Redef error: {mpropdef} redefines {mpropdef.mproperty.intro} with {param_names.length} parameter(s), {msignature.arity} expected. Signature is {mpropdef}{msignature}")
+ modelbuilder.error(node, "Redef Error: expected {msignature.arity} parameter(s) for `{mpropdef.mproperty.name}{msignature}`; got {param_names.length}. See introduction at `{mpropdef.mproperty.full_name}`.")
return
end
else if mpropdef.mproperty.is_init and not mpropdef.mproperty.is_new then
if param_names.length != param_types.length then
# Some parameters are typed, other parameters are not typed.
- modelbuilder.error(nsig.n_params[param_types.length], "Error: Untyped parameter `{param_names[param_types.length]}'.")
+ modelbuilder.error(nsig.n_params[param_types.length], "Error: untyped parameter `{param_names[param_types.length]}'.")
return
end
# Check annotations
var at = self.get_single_annotation("lazy", modelbuilder)
- if at != null then modelbuilder.error(at, "Syntax error: `lazy` must be used on attributes.")
+ if at != null then modelbuilder.error(at, "Syntax Error: `lazy` must be used on attributes.")
end
redef fun check_signature(modelbuilder)
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.")
+ modelbuilder.error(nsig.n_type.as(not null), "Redef Error: `{mpropdef.mproperty}` is a procedure, not a function.")
+ self.mpropdef.msignature = null
return
end
var prt = msignature.mparameters[i].mtype
var node = nsig.n_params[i]
if not modelbuilder.check_sametype(node, mmodule, mclassdef.bound_mtype, myt, prt) then
- modelbuilder.error(node, "Redef Error: Wrong type for parameter `{mysignature.mparameters[i].name}'. found {myt}, expected {prt} as in {mpropdef.mproperty.intro}.")
+ modelbuilder.error(node, "Redef Error: expected `{prt}` for parameter `{mysignature.mparameters[i].name}'; got `{myt}`.")
+ self.mpropdef.msignature = null
end
end
end
# Inherit the return type
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: Wrong return type. found {ret_type}, expected {precursor_ret_type} as in {mpropdef.mproperty.intro}.")
+ modelbuilder.error(node, "Redef Error: expected `{precursor_ret_type}` for return type; got `{ret_type}`.")
+ self.mpropdef.msignature = null
end
end
end
var atabstract = self.get_single_annotation("abstract", modelbuilder)
if atabstract == null then
- if mclass.kind == interface_kind then
- modelbuilder.error(self, "Error: Attempt to define attribute {name} in the interface {mclass}.")
- else if mclass.kind == enum_kind then
- modelbuilder.error(self, "Error: Attempt to define attribute {name} in the enum class {mclass}.")
- else if mclass.kind == extern_kind then
- modelbuilder.error(self, "Error: Attempt to define attribute {name} in the extern class {mclass}.")
+ if not mclass.kind.need_init then
+ modelbuilder.error(self, "Error: attempt to define attribute `{name}` in the {mclass.kind} `{mclass}`.")
end
var mprop = new MAttribute(mclassdef, "_" + name, private_visibility)
has_value = n_expr != null or n_block != null
if atabstract != null and has_value then
- modelbuilder.error(atabstract, "Error: `abstract` attributes cannot have an initial value")
+ modelbuilder.error(atabstract, "Error: `abstract` attributes cannot have an initial value.")
return
end
if atnoinit != null then
noinit = true
if has_value then
- modelbuilder.error(atnoinit, "Error: `noautoinit` attributes cannot have an initial value")
+ modelbuilder.error(atnoinit, "Error: `noautoinit` attributes cannot have an initial value.")
return
end
if atabstract != null then
- modelbuilder.error(atnoinit, "Error: `noautoinit` attributes cannot be abstract")
+ modelbuilder.error(atnoinit, "Error: `noautoinit` attributes cannot be abstract.")
return
end
end
var atautoinit = self.get_single_annotation("autoinit", modelbuilder)
if atlazy != null or atautoinit != null then
if atlazy != null and atautoinit != null then
- modelbuilder.error(atlazy, "Error: lazy incompatible with autoinit")
+ modelbuilder.error(atlazy, "Error: `lazy` incompatible with `autoinit`.")
return
end
if not has_value then
if atlazy != null then
- modelbuilder.error(atlazy, "Error: a lazy attribute needs a value")
+ modelbuilder.error(atlazy, "Error: `lazy` attributes need a value.")
else if atautoinit != null then
- modelbuilder.error(atautoinit, "Error: a autoinit attribute needs a value")
+ modelbuilder.error(atautoinit, "Error: `autoinit` attributes need a value.")
end
+ has_value = true
return
end
is_lazy = true
var atreadonly = self.get_single_annotation("readonly", modelbuilder)
if atreadonly != null then
if not has_value then
- modelbuilder.error(atreadonly, "Error: a readonly attribute needs a value")
+ modelbuilder.error(atreadonly, "Error: `readonly` attributes need a value.")
end
# No setter, so just leave
return
var cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "String")
if cla != null then mtype = cla.mclass_type
else
- modelbuilder.error(self, "Error: Untyped attribute {mreadpropdef}. Implicit typing allowed only for literals and new.")
+ modelbuilder.error(self, "Error: untyped attribute `{mreadpropdef}`. Implicit typing allowed only for literals and new.")
end
if mtype == null then return
end
if mtype == null then
- modelbuilder.error(self, "Error: Untyped attribute {mreadpropdef}")
+ modelbuilder.error(self, "Error: untyped attribute `{mreadpropdef}`.")
return
end
if precursor_type == null then return
if mtype != precursor_type then
- modelbuilder.error(ntype.as(not null), "Redef Error: Wrong static type. found {mtype}, expected {precursor_type}.")
+ modelbuilder.error(ntype.as(not null), "Redef Error: expected `{precursor_type}` type as a bound; got `{mtype}`.")
return
end
end
if mysignature.arity != msignature.arity then
var node: ANode
if nsig != null then node = nsig else node = self
- modelbuilder.error(node, "Redef Error: {mysignature.arity} parameters found, {msignature.arity} expected. Signature is {mpropdef}{msignature}")
+ modelbuilder.error(node, "Redef Error: expected {msignature.arity} parameter(s) for `{mpropdef.mproperty.name}{msignature}`; got {mysignature.arity}. See introduction at `{mpropdef.mproperty.full_name}`.")
return
end
var precursor_ret_type = msignature.return_mtype
if ret_type != null and precursor_ret_type == null then
var node: ANode
if nsig != null then node = nsig else node = self
- modelbuilder.error(node, "Redef Error: {mpropdef.mproperty} is a procedure, not a function.")
+ modelbuilder.error(node, "Redef Error: `{mpropdef.mproperty}` is a procedure, not a function.")
return
end
var node: ANode
if nsig != null then node = nsig else node = self
if not modelbuilder.check_sametype(node, mmodule, mclassdef.bound_mtype, myt, prt) then
- modelbuilder.error(node, "Redef Error: Wrong type for parameter `{mysignature.mparameters[i].name}'. found {myt}, expected {prt}.")
+ modelbuilder.error(node, "Redef Error: expected `{prt}` type for parameter `{mysignature.mparameters[i].name}'; got `{myt}`.")
end
end
end
# Inherit the return type
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: Wrong return type. found {ret_type}, expected {precursor_ret_type}.")
+ modelbuilder.error(node, "Redef Error: expected `{precursor_ret_type}` return type; got `{ret_type}`.")
end
end
end
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_id, "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
var mpropdef = self.mpropdef
if mpropdef == null then return # Error thus skipped
- var bound = self.mpropdef.bound
+ var bound = mpropdef.bound
if bound == null then return # Error thus skipped
modelbuilder.check_visibility(n_type, bound, mpropdef)
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)
- var next = bound.lookup_bound(mmodule, anchor)
- if not next isa MVirtualType then break
- bound = next
- end
- end
-
var ntype = self.n_type
if modelbuilder.resolve_mtype(mmodule, mclassdef, ntype) == null then
mpropdef.bound = null
end
# Check redefinitions
- bound = mpropdef.bound.as(not null)
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 p.is_fixed then
- modelbuilder.error(self, "Redef Error: Virtual type {mpropdef.mproperty} is fixed in super-class {p.mclassdef.mclass}")
+ 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
break
end
if not modelbuilder.check_subtype(n_type, mmodule, anchor, bound, supbound) then
- modelbuilder.error(n_type, "Redef Error: Wrong bound type. Found {bound}, expected a subtype of {supbound}, as in {p}.")
+ modelbuilder.error(n_type, "Redef Error: expected `{supbound}` bound type; got `{bound}`.")
break
end
end
nitlanguage / nit.git / blobdiff