# 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
var initializers = new Array[MProperty]
for npropdef in nclassdef.n_propdefs do
if npropdef isa AMethPropdef then
- if npropdef.mpropdef == null then return # Skip broken attribute
+ if npropdef.mpropdef == null then return # Skip broken method
var at = npropdef.get_single_annotation("autoinit", self)
if at == null then continue # Skip non tagged init
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
for param in sig.mparameters do
var ret_type = param.mtype
- var mparameter = new MParameter(param.name, ret_type, false)
+ var mparameter = new MParameter(param.name, ret_type, false, ret_type isa MNullableType)
mparameters.add(mparameter)
end
initializers.add(npropdef.mpropdef.mproperty)
npropdef.mpropdef.mproperty.is_autoinit = true
end
if npropdef isa AAttrPropdef then
- if npropdef.mpropdef == null then return # Skip broken attribute
+ var mreadpropdef = npropdef.mreadpropdef
+ if mreadpropdef == null or mreadpropdef.msignature == null then return # Skip broken attribute
if npropdef.noinit then continue # Skip noinit attribute
var atautoinit = npropdef.get_single_annotation("autoinit", self)
if atautoinit != null then
# For autoinit attributes, call the reader to force
# the lazy initialization of the attribute.
- initializers.add(npropdef.mreadpropdef.mproperty)
- npropdef.mreadpropdef.mproperty.is_autoinit = true
+ initializers.add(mreadpropdef.mproperty)
+ mreadpropdef.mproperty.is_autoinit = true
continue
end
if npropdef.has_value then continue
- var paramname = npropdef.mpropdef.mproperty.name.substring_from(1)
- var ret_type = npropdef.mpropdef.static_mtype
+ var paramname = mreadpropdef.mproperty.name
+ var ret_type = mreadpropdef.msignature.return_mtype
if ret_type == null then return
- var mparameter = new MParameter(paramname, ret_type, false)
+ var mparameter = new MParameter(paramname, ret_type, false, ret_type isa MNullableType)
mparameters.add(mparameter)
var msetter = npropdef.mwritepropdef
if msetter == null then
- # No setter, it is a old-style attribute, so just add it
+ # No setter, it is a readonly attribute, so just add it
initializers.add(npropdef.mpropdef.mproperty)
npropdef.mpropdef.mproperty.is_autoinit = true
else
# 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
if pd isa MMethodDef then
# Get the signature resolved for the current receiver
var sig = pd.msignature.resolve_for(mclassdef.mclass.mclass_type, mclassdef.bound_mtype, mclassdef.mmodule, false)
- mparameters.add_all sig.mparameters
+ # Because the last parameter of setters is never default, try to default them for the autoinit.
+ for param in sig.mparameters do
+ if not param.is_default and param.mtype isa MNullableType then
+ param = new MParameter(param.name, param.mtype, param.is_vararg, true)
+ end
+ mparameters.add(param)
+ end
else
# TODO attributes?
abort
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
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 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}")
+ error(node, "Error: circularity of virtual type definition: {next} <-> {t}.")
else
- error(node, "Error: circularity of virtual type definition: {mtype} -> {next} <-> {t}")
+ error(node, "Error: circularity of virtual type definition: {mtype} -> {next} <-> {t}.")
end
return false
else
# 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
name = amethodid.collect_text
name_node = amethodid
- if name == "-" and self.n_signature.n_params.length == 0 then
+ var arity = self.n_signature.n_params.length
+ if name == "+" and arity == 0 then
+ name = "unary +"
+ else if name == "-" and arity == 0 then
name = "unary -"
+ else if name == "~" and arity == 0 then
+ name = "unary ~"
+ else
+ if amethodid.is_binary and arity != 1 then
+ modelbuilder.error(self.n_signature, "Syntax Error: binary operator `{name}` requires exactly one parameter; got {arity}.")
+ else if amethodid.min_arity > arity then
+ modelbuilder.error(self.n_signature, "Syntax Error: `{name}` requires at least {amethodid.min_arity} parameter(s); got {arity}.")
+ end
end
end
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
end
end
+ var accept_special_last_parameter = self.n_methid == null or self.n_methid.accept_special_last_parameter
+ var return_is_mandatory = self.n_methid != null and self.n_methid.return_is_mandatory
+
# Retrieve info from the signature AST
var param_names = new Array[String] # Names of parameters from the AST
var param_types = new Array[MType] # Types of parameters from the AST
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
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)
+ var is_default = false
+ if vararg_rank == -1 and param_types[i] isa MNullableType then
+ if i < param_names.length-1 or accept_special_last_parameter then
+ is_default = true
+ end
+ end
+ var mparameter = new MParameter(param_names[i], param_types[i], i == vararg_rank, is_default)
if nsig != null then nsig.n_params[i].mparameter = mparameter
mparameters.add(mparameter)
end
# In `new`-factories, the return type is by default the classtype.
if ret_type == null and mpropdef.mproperty.is_new then ret_type = mclassdef.mclass.mclass_type
+ # Special checks for operator methods
+ if not accept_special_last_parameter and mparameters.not_empty and mparameters.last.is_vararg then
+ modelbuilder.error(self.n_signature.n_params.last, "Error: illegal variadic parameter `{mparameters.last}` for `{mpropdef.mproperty.name}`.")
+ end
+ if ret_type == null and return_is_mandatory then
+ modelbuilder.error(self.n_methid, "Error: mandatory return type for `{mpropdef.mproperty.name}`.")
+ end
+
msignature = new MSignature(mparameters, ret_type)
mpropdef.msignature = msignature
mpropdef.is_abstract = self.get_single_annotation("abstract", modelbuilder) != null
# 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
end
end
+redef class AMethid
+ # Is a return required?
+ #
+ # * True for operators and brackets.
+ # * False for id and assignment.
+ fun return_is_mandatory: Bool do return true
+
+ # Can the last parameter be special like a vararg?
+ #
+ # * False for operators: the last one is in fact the only one.
+ # * False for assignments: it is the right part of the assignment.
+ # * True for ids and brackets.
+ fun accept_special_last_parameter: Bool do return false
+
+ # The minimum required number of parameters.
+ #
+ # * 1 for binary operators
+ # * 1 for brackets
+ # * 1 for assignments
+ # * 2 for bracket assignments
+ # * 0 for ids
+ fun min_arity: Int do return 1
+
+ # Is the `self` a binary operator?
+ fun is_binary: Bool do return true
+end
+
+redef class AIdMethid
+ redef fun return_is_mandatory do return false
+ redef fun accept_special_last_parameter do return true
+ redef fun min_arity do return 0
+ redef fun is_binary do return false
+end
+
+redef class ABraMethid
+ redef fun accept_special_last_parameter do return true
+ redef fun is_binary do return false
+end
+
+redef class ABraassignMethid
+ redef fun return_is_mandatory do return false
+ redef fun min_arity do return 2
+ redef fun is_binary do return false
+end
+
+redef class AAssignMethid
+ redef fun return_is_mandatory do return false
+ redef fun is_binary do return false
+end
+
redef class AAttrPropdef
redef type MPROPDEF: MAttributeDef
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 mwritepropdef != null then
var name: String
name = n_id2.text
- var mparameter = new MParameter(name, mtype, false)
+ var mparameter = new MParameter(name, mtype, false, false)
var msignature = new MSignature([mparameter], null)
mwritepropdef.msignature = msignature
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 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