# Is the class computing super.
# Used to detect specialization loops.
- attr _computing_super: Bool
+ attr _computing_super: Bool = false
# Compute super classes of a class
meth compute_super_classes
continue
end
- var gname = glob.intro.name
- var conf_set: Array[MMGlobalProperty]
- if names.has_key(gname) then
- conf_set = names[gname]
- else
- conf_set = new Array[MMGlobalProperty]
- names[gname] = conf_set
- end
- conf_set.add(glob)
+ make_visible_an_inherited_global_property(glob)
end
end
end
+ # Make the name of a global property meaningful in the class
+ meth make_visible_an_inherited_global_property(glob: MMGlobalProperty)
+ do
+ var names = _properties_by_name
+ var gname = glob.intro.name
+ var conf_set: Array[MMGlobalProperty]
+ if names.has_key(gname) then
+ conf_set = names[gname]
+ else
+ conf_set = new Array[MMGlobalProperty]
+ names[gname] = conf_set
+ end
+ conf_set.add(glob)
+ end
+
# Add super stype of this current local class
meth add_direct_parent(p: MMAncestor)
do
assert not _local_property_by_global.has_key(glob)
assert glob != null
- var impls = glob.get_compatible_concrete_properties_for(self)
- if impls.length != 1 then
- stderr.write("Fatal error: inherit_local_property error\n")
- print("------- {module}::{self} {glob.intro.full_name}")
- for i in impls do
- print(" {i.full_name}")
- end
- print("------- {glob.concrete_property_hierarchy.first}")
- print("------- {glob.concrete_property_hierarchy.to_dot}")
- exit(1)
- end
- var impl = impls.first
- var ac = ancestor_for(impl.local_class)
- ac.local_class.inherit_global_properties
- var a = ac.stype
-
- assert a.local_class != self
- var sup = a.select_property(glob) # Select super prop
- assert sup != null
- var prop = sup.inherit_to(get_type) # special the new prop
- return prop
- end
-end
-
-redef class MMConcreteProperty
- # FIXME: use this
- meth is_deferred: Bool do return false
-end
+ var impl: MMLocalProperty
-redef class MMGlobalProperty
- # Get the most specific local properties defined in superclasses of c
- private meth get_compatible_concrete_properties_for(cla: MMLocalClass): Array[MMConcreteProperty]
- do
- var impl_hier = _concrete_property_hierarchy
- if impl_hier.length == 1 then return [intro]
- var impls = new ArraySet[MMConcreteProperty]
- var clache = cla.che
- if true then
- #print "{cla.module}::{cla} get glob {intro.local_class}::{intro.name}"
- for sc in cla.che.direct_greaters do
- #print " try {sc.module}::{sc} {sc.che != null} {sc.crhe != null} {sc.che != null}"
- var p = sc[self]
- if p == null then continue
- var impl = p.concrete_property
- impls.add(impl)
- end
+ var ghier = glob.property_hierarchy
+ var supers = che.direct_greaters
+ if ghier.length == 1 then
+ # Unredefined property
+ impl = glob.intro
+ else if supers.length == 1 then
+ # Single inheritance
+ impl = supers.first[glob]
else
- for impl in impl_hier do
- var bc = impl.local_class
- if clache < bc then
- impls.add(impl)
+ # Hard multiple inheritance
+ # First compute the set of bottom properties
+ var impls = new ArraySet[MMLocalProperty]
+ for sc in supers do
+ var p = sc[glob]
+ if p != null then impls.add(p)
end
+ # Second, extract most specific
+ var impls2 = ghier.select_smallests(impls)
+ # Conflict case (FIXME)
+ if impls2.length != 1 then
+ stderr.write("Fatal error: inherit_local_property error\n")
+ print("------- {module}::{self} {glob.intro.full_name}")
+ for i in impls2 do
+ print(" {i.full_name}")
+ end
+ print("------- {glob.property_hierarchy.first}")
+ print("------- {glob.property_hierarchy.to_dot}")
+ exit(1)
+ end
+ impl = impls2.first
end
- end
- return impl_hier.select_smallests(impls)
+
+ # FIXME: Why these 3 lines ?
+ #var ac = ancestor_for(impl.local_class)
+ #ac.local_class.inherit_global_properties
+ #var a = ac.stype
+ #assert a.local_class != self
+
+ # Register the local property
+ _local_property_by_global[glob] = impl
+
+ return impl
end
end
meth inherit_global(g: MMGlobalProperty)
do
set_global(g)
- # What the next line used for?
- g.add_concrete_property(concrete_property, g.get_compatible_concrete_properties_for(local_class))
- end
-
- # Create an adaptation of self to a different receiver
- meth inherit_to(t: MMType): MMLocalProperty is abstract
-
- # ?
- protected meth inherit_from(s: MMLocalProperty, t: MMType) # for the super bugs
- do
- assert _super_prop == null
- _super_prop = s
- if _global == null then
- set_global(s.global)
+ var impls = new Array[MMLocalProperty]
+ for sc in local_class.che.direct_greaters do
+ var p = sc[g]
+ if p == null then continue
+ impls.add(p)
end
+ g.add_local_property(self, impls)
end
-
-end
-
-redef class MMMethod
- redef meth inherit_to(t) do
- return new MMImplicitMethod(self, t)
- end
-end
-
-# A local property that is an adatation of an exiting one
-class MMImplicitProperty
-special MMLocalProperty
- # Create a property from an existing property and a new receiver
- init(prop: MMLocalProperty, bt: MMType)
- do
- super(prop.name, bt.local_class, prop.concrete_property)
- inherit_from(prop, bt)
- end
-end
-
-class MMImplicitMethod
-special MMMethod
-special MMImplicitProperty
- init(p, t) do super
-end
-
-redef class MMAttribute
- redef meth inherit_to(t)
- do
- return new MMImplicitAttribute(self,t)
- end
-end
-
-class MMImplicitAttribute
-special MMAttribute
-special MMImplicitProperty
- init(p, t) do super
end
redef class MMAncestor
nitlanguage / nit.git / blobdiff