# Public clients need to use `mpropdef2node` to access stuff.
private var mpropdef2npropdef = new HashMap[MPropDef, APropdef]
+ # Associate a `npropdef` with its `mpropdef`
+ #
+ # Be careful, this method is unsafe, no checking is done when it's used.
+ # The safe way to add method it's to use the `build_property`
+ #
+ # See `mpropdef2npropdef`
+ fun unsafe_add_mpropdef2npropdef(mpropdef: MPropDef,npropdef: APropdef)
+ do
+ mpropdef2npropdef[mpropdef] = npropdef
+ end
+
# Retrieve the associated AST node of a mpropertydef.
# This method is used to associate model entity with syntactic entities.
#
toolcontext.run_phases_on_npropdef(res)
return res
end
- if mpropdef isa MMethodDef and mpropdef.mproperty.is_root_init then
- res = mclassdef2nclassdef.get_or_null(mpropdef.mclassdef)
- if res != null then return res
- end
+ # Fall back to the class node if any.
+ res = mclassdef2nclassdef.get_or_null(mpropdef.mclassdef)
+ if res != null then return res
return null
end
var mparameters = new Array[MParameter]
var msignature = new MSignature(mparameters, null)
mpropdef.msignature = msignature
- mpropdef.new_msignature = msignature
mprop.is_init = true
self.toolcontext.info("{mclassdef} gets a free empty constructor {mpropdef}{msignature}", 3)
the_root_init_mmethod = mprop
- return
end
# Is there already a constructor defined?
if mpropdef.mproperty.is_root_init then
assert defined_init == null
defined_init = mpropdef
- else if mpropdef.mproperty.name == "init" then
- # An explicit old-style init named "init", so return
+ end
+ if mpropdef.name == "defaultinit" then
return
end
end
+ if mclassdef.default_init != null then return
+
if not nclassdef isa AStdClassdef then return
# Collect undefined attributes
if mpropdef == null then return # Skip broken method
var sig = mpropdef.msignature
if sig == null then continue # Skip broken method
-
mparameters.add_all sig.mparameters
initializers.add(mpropdef.mproperty)
mpropdef.mproperty.is_autoinit = true
if the_root_init_mmethod == null then return
# 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`?")
- return
+ var spropdefs = new ArraySet[MMethodDef]
+ for x in mclassdef.in_hierarchy.direct_greaters do
+ var y = x.mclass.intro.default_init
+ if y == null then continue
+ if y.is_broken or y.msignature == null then return
+ spropdefs.add y
end
# Look at the autoinit class-annotation
abort
end
end
- else
+ else if spropdefs.not_empty then
# Search the longest-one and checks for conflict
var longest = spropdefs.first
if spropdefs.length > 1 then
mparameters.clear
initializers.clear
else
- # 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)
- mclassdef.mclass.root_init = longest
- return
- end
-
# Combine the inherited list to what is collected
if longest.initializers.length > 0 then
- mparameters.prepend longest.new_msignature.mparameters
+ mparameters.prepend longest.msignature.mparameters
initializers.prepend longest.initializers
end
end
end
- # If we already have a basic init definition, then setup its initializers
- if defined_init != null then
- defined_init.initializers.add_all(initializers)
+ # Create a specific new autoinit constructor
+ do
+ var mprop = new MMethod(mclassdef, "defaultinit", nclassdef.location, public_visibility)
+ mprop.is_init = true
+ var mpropdef = new MMethodDef(mclassdef, mprop, nclassdef.location)
+ mpropdef.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)
- mclassdef.mclass.root_init = defined_init
- return
+ mpropdef.msignature = msignature
+ mclassdef.default_init = mpropdef
+ self.toolcontext.info("{mclassdef} gets a free auto constructor `{mpropdef}{msignature}`. {spropdefs}", 3)
+ mclassdef.mclass.the_root_init_mmethod = the_root_init_mmethod
end
-
- # Else create the local implicit basic init definition
- 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
- self.toolcontext.info("{mclassdef} gets a free constructor for attributes {mpropdef}{msignature}", 3)
- mclassdef.mclass.root_init = mpropdef
end
# Check the visibility of `mtype` as an element of the signature of `mpropdef`.
redef class MClass
# The base init of the class.
- # Used to get the common new_msignature and initializers
#
- # TODO: Where to put this information is not clear because unlike other
- # informations, the initialisers are stable in a same class.
- var root_init: nullable MMethodDef = null
+ # TODO: merge with `root_init` and `ModelBuilder::the_root_init_mmethod` if possible
+ var the_root_init_mmethod: nullable MMethod = null
end
redef class MClassDef
var name: String
var amethodid = self.n_methid
var name_node: ANode
+ var is_old_style_init = false
if amethodid == null then
if n_kwinit != null then
name = "init"
name_node = n_kwinit
+ var old_style_annot = get_single_annotation("old_style_init", modelbuilder)
+ if old_style_annot != null or self.n_signature.n_params.not_empty then
+ name = "defaultinit"
+ if old_style_annot != null then is_old_style_init = true
+ end
else if n_kwnew != null then
name = "new"
name_node = n_kwnew
var look_like_a_root_init = look_like_a_root_init(modelbuilder, mclassdef)
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 not is_init or n_kwredef != null or look_like_a_root_init then mprop = modelbuilder.try_get_mproperty_by_name(name_node, mclassdef, name).as(nullable MMethod)
if mprop == null and look_like_a_root_init then
mprop = modelbuilder.the_root_init_mmethod
var nb = n_block
mclassdef.mprop2npropdef[mprop] = self
var mpropdef = new MMethodDef(mclassdef, mprop, self.location)
+ if mpropdef.name == "defaultinit" and mclassdef.is_intro then
+ assert mclassdef.default_init == null
+ mpropdef.is_old_style_init = is_old_style_init
+ mclassdef.default_init = mpropdef
+ if mpropdef.is_intro then
+ mpropdef.initializers.add mprop
+ mpropdef.is_calling_init = true
+ end
+ end
set_doc(mpropdef, modelbuilder)
var mmodule = mclassdef.mmodule
var nsig = self.n_signature
- if mproperty.is_root_init and not mclassdef.is_intro then
- var root_init = mclassdef.mclass.root_init
- if root_init != null then
- # Inherit the initializers by refinement
- mpropdef.new_msignature = root_init.new_msignature
- assert mpropdef.initializers.is_empty
- mpropdef.initializers.add_all root_init.initializers
- 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
end
mclassdef.mprop2npropdef[mreadprop] = self
+ var attr_mpropdef = mpropdef
+ if attr_mpropdef != null then
+ mreadprop.getter_for = attr_mpropdef.mproperty
+ attr_mpropdef.mproperty.getter = mreadprop
+ end
+
var mreadpropdef = new MMethodDef(mclassdef, mreadprop, self.location)
self.mreadpropdef = mreadpropdef
modelbuilder.mpropdef2npropdef[mreadpropdef] = self
end
mclassdef.mprop2npropdef[mwriteprop] = self
+ if attr_mpropdef != null then
+ mwriteprop.setter_for = attr_mpropdef.mproperty
+ attr_mpropdef.mproperty.setter = mwriteprop
+ end
+
var mwritepropdef = new MMethodDef(mclassdef, mwriteprop, self.location)
self.mwritepropdef = mwritepropdef
modelbuilder.mpropdef2npropdef[mwritepropdef] = self
var nexpr = self.n_expr
if mtype == null then
if nexpr != null then
- if nexpr isa ANewExpr then
- mtype = modelbuilder.resolve_mtype_unchecked(mclassdef, nexpr.n_type, true)
- else if nexpr isa AAsCastExpr then
- mtype = modelbuilder.resolve_mtype_unchecked(mclassdef, nexpr.n_type, true)
- else if nexpr isa AIntegerExpr then
- var cla: nullable MClass = null
- if nexpr.value isa Int then
- cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int")
- else if nexpr.value isa Byte then
- cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Byte")
- else if nexpr.value isa Int8 then
- cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int8")
- else if nexpr.value isa Int16 then
- cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int16")
- else if nexpr.value isa UInt16 then
- cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "UInt16")
- else if nexpr.value isa Int32 then
- cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int32")
- else if nexpr.value isa UInt32 then
- cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "UInt32")
- else
- # Should not happen, and should be updated as new types are added
- abort
- end
- if cla != null then mtype = cla.mclass_type
- else if nexpr isa AFloatExpr then
- var cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Float")
- if cla != null then mtype = cla.mclass_type
- else if nexpr isa ACharExpr then
- var cla: nullable MClass
- if nexpr.is_ascii then
- cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Byte")
- else if nexpr.is_code_point then
- cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int")
- else
- cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Char")
- end
- if cla != null then mtype = cla.mclass_type
- else if nexpr isa ABoolExpr then
- var cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Bool")
- if cla != null then mtype = cla.mclass_type
- else if nexpr isa ASuperstringExpr then
- var cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "String")
- if cla != null then mtype = cla.mclass_type
- else if nexpr isa AStringFormExpr then
- var cla: nullable MClass
- if nexpr.is_bytestring then
- cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Bytes")
- else if nexpr.is_re then
- cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Regex")
- else if nexpr.is_string then
- cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "String")
- else
- abort
- end
- if cla != null then mtype = cla.mclass_type
- else
- modelbuilder.error(self, "Error: untyped attribute `{mreadpropdef}`. Implicit typing allowed only for literals and new.")
- end
-
+ mtype = infer_static_type(modelbuilder, nexpr, mclassdef, mmodule, mreadpropdef)
if mtype == null then return
end
else if ntype != null and inherited_type == mtype then
check_repeated_types(modelbuilder)
end
+ # Detect the static type from the value assigned to the attribute `self`
+ #
+ # Return the static type if it can be safely inferred.
+ private fun infer_static_type(modelbuilder: ModelBuilder, nexpr: AExpr,
+ mclassdef: MClassDef, mmodule: MModule, mreadpropdef: MPropDef): nullable MType
+ do
+ var mtype = null
+ if nexpr isa ANewExpr then
+ mtype = modelbuilder.resolve_mtype_unchecked(mclassdef, nexpr.n_type, true)
+ else if nexpr isa AAsCastExpr then
+ mtype = modelbuilder.resolve_mtype_unchecked(mclassdef, nexpr.n_type, true)
+ else if nexpr isa AIntegerExpr then
+ var cla: nullable MClass = null
+ if nexpr.value isa Int then
+ cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int")
+ else if nexpr.value isa Byte then
+ cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Byte")
+ else if nexpr.value isa Int8 then
+ cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int8")
+ else if nexpr.value isa Int16 then
+ cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int16")
+ else if nexpr.value isa UInt16 then
+ cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "UInt16")
+ else if nexpr.value isa Int32 then
+ cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int32")
+ else if nexpr.value isa UInt32 then
+ cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "UInt32")
+ else
+ # Should not happen, and should be updated as new types are added
+ abort
+ end
+ if cla != null then mtype = cla.mclass_type
+ else if nexpr isa AFloatExpr then
+ var cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Float")
+ if cla != null then mtype = cla.mclass_type
+ else if nexpr isa ACharExpr then
+ var cla: nullable MClass
+ if nexpr.is_code_point then
+ cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int")
+ else
+ cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Char")
+ end
+ if cla != null then mtype = cla.mclass_type
+ else if nexpr isa ABoolExpr then
+ var cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Bool")
+ if cla != null then mtype = cla.mclass_type
+ else if nexpr isa ASuperstringExpr then
+ var cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "String")
+ if cla != null then mtype = cla.mclass_type
+ else if nexpr isa AStringFormExpr then
+ var cla: nullable MClass
+ if nexpr.is_bytestring then
+ cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Bytes")
+ else if nexpr.is_re then
+ cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Regex")
+ else if nexpr.is_string then
+ cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "String")
+ else
+ abort
+ end
+ if cla != null then mtype = cla.mclass_type
+ else if nexpr isa AArrayExpr and nexpr.n_type == null and nexpr.n_exprs.not_empty then
+ # Non-empty arrays without an explicit type
+
+ var item_mtypes = new Set[MType]
+ var fails = false
+ for node in nexpr.n_exprs do
+ var item_mtype = infer_static_type(modelbuilder, node, mclassdef, mmodule, mreadpropdef)
+ if item_mtype == null then
+ fails = true
+ else
+ item_mtypes.add item_mtype
+ end
+ end
+
+ if fails then return null # Failed to infer some types
+
+ if item_mtypes.length > 1 then
+ modelbuilder.error(self, "Type Error: ambiguous array type {item_mtypes.join(" ")}")
+ end
+
+ mtype = mmodule.array_type(item_mtypes.first)
+ else if nexpr isa AUminusExpr and (nexpr.n_expr isa AIntegerExpr or nexpr.n_expr isa AFloatExpr) then
+ # The Int and Float unary - is defined in `kernel`, so this may
+ # result in an invalid behavior when using a custom kernel.
+ # A workaround is to declare the attribute static type.
+ # This is still very useful, especially to novice programmers.
+ mtype = infer_static_type(modelbuilder, nexpr.n_expr, mclassdef, mmodule, mreadpropdef)
+ else if nexpr isa AOnceExpr then
+ mtype = infer_static_type(modelbuilder, nexpr.n_expr, mclassdef, mmodule, mreadpropdef)
+ else
+ modelbuilder.error(self, "Error: untyped attribute `{mreadpropdef}`. Implicit typing allowed only for literals and new.")
+ end
+ return mtype
+ end
+
redef fun check_signature(modelbuilder)
do
var mpropdef = self.mpropdef
nitlanguage / nit.git / blobdiff