import modelbuilder
redef class ToolContext
+ # Run `AModule::build_classes` on each module
var modelize_class_phase: Phase = new ModelizeClassPhase(self, null)
end
error(nclassdef, "Redef error: No imported class {name} to refine.")
return
end
+
+ # Check for conflicting class full-names in the project
+ if mmodule.mgroup != null and mvisibility >= protected_visibility then
+ var mclasses = model.get_mclasses_by_name(name)
+ if mclasses != null then for other in mclasses do
+ if other.intro_mmodule.mgroup != null and other.intro_mmodule.mgroup.mproject == mmodule.mgroup.mproject then
+ error(nclassdef, "Error: A class named `{other.full_name}` is already defined in module `{other.intro_mmodule}` at {other.intro.location}.")
+ break
+ end
+ end
+ end
+
mclass = new MClass(mmodule, name, names, mkind, mvisibility)
#print "new class {mclass}"
else if nclassdef isa AStdClassdef and nmodule.mclass2nclassdef.has_key(mclass) then
warning(nfdt, "useless-bound", "Warning: Useless formal parameter type since `{bound}` cannnot have subclasses.")
end
else if mclass.mclassdefs.is_empty then
+ if objectclass == null then
+ error(nfd, "Error: Formal parameter type `{pname}' unbounded but no Object class exist.")
+ return
+ end
# No bound, then implicitely bound by nullable Object
var bound = objectclass.mclass_type.as_nullable
bounds.add(bound)
private fun check_supertypes(nmodule: AModule, nclassdef: AClassdef)
do
var mmodule = nmodule.mmodule.as(not null)
- var objectclass = try_get_mclass_by_name(nmodule, mmodule, "Object")
var mclass = nclassdef.mclass.as(not null)
var mclassdef = nclassdef.mclassdef.as(not null)
nmodule.build_classes_is_done = true
var mmodule = nmodule.mmodule.as(not null)
for imp in mmodule.in_importation.direct_greaters do
-
- if not mmodule2nmodule.has_key(imp) then continue
- build_classes(mmodule2nmodule[imp])
+ var nimp = mmodule2node(imp)
+ if nimp != null then build_classes(nimp)
end
if errcount != toolcontext.error_count then return
end
end
- # Register the nclassdef associated to each mclassdef
- # FIXME: why not refine the `MClassDef` class with a nullable attribute?
- var mclassdef2nclassdef: HashMap[MClassDef, AClassdef] = new HashMap[MClassDef, AClassdef]
-
- # Return the static type associated to the node `ntype`.
- # `mmodule` and `mclassdef` is the context where the call is made (used to understand formal types)
- # In case of problem, an error is displayed on `ntype` and null is returned.
- # FIXME: the name "resolve_mtype" is awful
- fun resolve_mtype_unchecked(mmodule: MModule, mclassdef: nullable MClassDef, ntype: AType, with_virtual: Bool): nullable MType
- do
- var name = ntype.n_id.text
- var res: MType
-
- # Check virtual type
- if mclassdef != null and with_virtual then
- var prop = try_get_mproperty_by_name(ntype, mclassdef, name).as(nullable MVirtualTypeProp)
- if prop != null then
- if not ntype.n_types.is_empty then
- error(ntype, "Type error: formal type {name} cannot have formal parameters.")
- end
- res = prop.mvirtualtype
- if ntype.n_kwnullable != null then res = res.as_nullable
- ntype.mtype = res
- return res
- end
- end
-
- # Check parameter type
- if mclassdef != null and mclassdef.parameter_names.has(name) then
- if not ntype.n_types.is_empty then
- error(ntype, "Type error: formal type {name} cannot have formal parameters.")
- end
- for i in [0..mclassdef.parameter_names.length[ do
- if mclassdef.parameter_names[i] == name then
- res = mclassdef.mclass.mclass_type.arguments[i]
- if ntype.n_kwnullable != null then res = res.as_nullable
- ntype.mtype = res
- return res
- end
- end
- abort
- end
-
- # Check class
- var mclass = try_get_mclass_by_name(ntype, mmodule, name)
- if mclass != null then
- var arity = ntype.n_types.length
- if arity != mclass.arity then
- if arity == 0 then
- error(ntype, "Type error: '{name}' is a generic class.")
- else if mclass.arity == 0 then
- error(ntype, "Type error: '{name}' is not a generic class.")
- else
- error(ntype, "Type error: '{name}' has {mclass.arity} parameters ({arity} are provided).")
- end
- return null
- end
- if arity == 0 then
- res = mclass.mclass_type
- if ntype.n_kwnullable != null then res = res.as_nullable
- ntype.mtype = res
- return res
- else
- var mtypes = new Array[MType]
- for nt in ntype.n_types do
- var mt = resolve_mtype_unchecked(mmodule, mclassdef, nt, with_virtual)
- if mt == null then return null # Forward error
- mtypes.add(mt)
- end
- res = mclass.get_mtype(mtypes)
- if ntype.n_kwnullable != null then res = res.as_nullable
- ntype.mtype = res
- return res
- end
- end
-
- # If everything fail, then give up :(
- error(ntype, "Type error: class {name} not found in module {mmodule}.")
- return null
- end
-
- # Return the static type associated to the node `ntype`.
- # `mmodule` and `mclassdef` is the context where the call is made (used to understand formal types)
- # In case of problem, an error is displayed on `ntype` and null is returned.
- # FIXME: the name "resolve_mtype" is awful
- fun resolve_mtype(mmodule: MModule, mclassdef: nullable MClassDef, ntype: AType): nullable MType
- do
- var mtype = ntype.mtype
- if mtype == null then mtype = resolve_mtype_unchecked(mmodule, mclassdef, ntype, true)
- if mtype == null then return null # Forward error
-
- if ntype.checked_mtype then return mtype
- if mtype isa MGenericType then
- var mclass = mtype.mclass
- for i in [0..mclass.arity[ do
- var bound = mclass.intro.bound_mtype.arguments[i]
- var nt = ntype.n_types[i]
- var mt = resolve_mtype(mmodule, mclassdef, nt)
- if mt == null then return null # forward error
- var anchor
- if mclassdef != null then anchor = mclassdef.bound_mtype else anchor = null
- if not mt.is_subtype(mmodule, anchor, bound) then
- error(nt, "Type error: expected {bound}, got {mt}")
- return null
- end
- end
- end
- ntype.checked_mtype = true
- return mtype
- end
-
+ # Registration of the nclassdef associated to each mclassdef
+ private var mclassdef2nclassdef = new HashMap[MClassDef, AClassdef]
end
redef class AModule
# The associated bound
var bound: nullable MType = null
end
-
-redef class AType
- # The mtype associated to the node
- var mtype: nullable MType = null
-
- # Is the mtype a valid one?
- var checked_mtype: Bool = false
-end