# Compute specialization relation
for c in local_classes do
- if visibility_for(c.global.intro.module) < c.global.visibility_level then
+ if visibility_for(c.global.intro.mmmodule) < c.global.visibility_level then
continue
end
c.compute_super_classes
# Property inhritance and introduction
var mmbv2 = new PropertyBuilderVisitor(tc, self)
for c in classes do
- # Inherit global properties
- c.inherit_global_properties
-
# Global property introduction and redefinition
c.accept_class_visitor(mmbv2)
# Default and inherited constructor if needed
- if c isa MMSrcLocalClass and c.global.intro == c and not c.global.is_universal and not c.global.is_interface then
+ if c isa MMSrcLocalClass and c.global.intro == c and not c.global.is_enum and not c.global.is_interface then
c.process_default_constructors(mmbv2)
end
c.accept_properties_visitor(mmbv3)
end
- # Check inherited local properties
- for c in classes do
- for g in c.global_properties do
- if visibility_for(g.intro.module) < g.visibility_level then continue
- var p = c[g]
- end
- end
-
tc.check_errors
end
var super_inits = new ArraySet[MMLocalProperty]
var super_constructors = new ArraySet[MMGlobalProperty]
for sc in che.direct_greaters do
- if sc.global.is_universal or sc.global.is_interface then continue
+ if sc.global.is_enum or sc.global.is_interface then continue
for gp in sc.global_properties do
if not gp.is_init then continue
super_constructors.add(gp)
end
end
-redef class APackagedecl
+redef class AModuledecl
redef fun accept_class_builder(v)
do
- if n_id.to_symbol != v.module.name then
- v.error(n_id, "Error: Package name missmatch between {v.module.name} and {n_id.to_symbol}")
+ if n_id.to_symbol != v.mmmodule.name then
+ v.error(n_id, "Error: Module name missmatch between {v.mmmodule.name} and {n_id.to_symbol}")
end
end
end
redef fun accept_class_builder(v)
do
var local_class: MMSrcLocalClass
- var mod = v.module
+ var mod = v.mmmodule
var local_classes = mod.src_local_classes
if (local_classes.has_key(name)) then
local_class = local_classes[name]
redef class AClasskind
fun is_interface: Bool do return false
- fun is_universal: Bool do return false
+ fun is_enum: Bool do return false
fun is_abstract: Bool do return false
end
redef class AInterfaceClasskind
redef fun is_interface do return true
end
-redef class AUniversalClasskind
- redef fun is_universal do return true
+redef class AEnumClasskind
+ redef fun is_enum do return true
end
redef class AAbstractClasskind
redef fun is_abstract do return true
glob.visibility_level = visibility_level
glob.is_interface = n_classkind.is_interface
glob.is_abstract = n_classkind.is_abstract
- glob.is_universal = n_classkind.is_universal
+ glob.is_enum = n_classkind.is_enum
if n_kwredef != null then
v.error(self, "Redef error: No class {name} is imported. Remove the redef keyword to define a new class.")
end
for c in _local_class.cshe.direct_greaters do
var cg = c.global
if glob.is_interface then
- if cg.is_universal then
- v.error(self, "Special error: Interface {name} try to specialise universal class {c.name}.")
+ if cg.is_enum then
+ v.error(self, "Special error: Interface {name} try to specialise enum class {c.name}.")
else if not cg.is_interface then
v.error(self, "Special error: Interface {name} try to specialise class {c.name}.")
end
- else if glob.is_universal then
- if not cg.is_interface and not cg.is_universal then
- v.error(self, "Special error: Universal class {name} try to specialise class {c.name}.")
+ else if glob.is_enum then
+ if not cg.is_interface and not cg.is_enum then
+ v.error(self, "Special error: Enum class {name} try to specialise class {c.name}.")
end
else
- if cg.is_universal then
- v.error(self, "Special error: Class {name} try to specialise universal class {c.name}.")
+ if cg.is_enum then
+ v.error(self, "Special error: Class {name} try to specialise enum class {c.name}.")
end
end
# Redef
- glob.check_visibility(v, self, v.module)
+ glob.check_visibility(v, self, v.mmmodule)
if n_kwredef == null then
v.error(self, "Redef error: {name} is an imported class. Add the redef keyword to refine it.")
return
if
not glob.is_interface and n_classkind.is_interface or
not glob.is_abstract and n_classkind.is_abstract or
- not glob.is_universal and n_classkind.is_universal
+ not glob.is_enum and n_classkind.is_enum
then
v.error(self, "Redef error: cannot change kind of class {name}.")
end
var o = c.global.intro
if c == o then
if n_type == null then
- _formal.bound = v.module.type_any.as_nullable
+ _formal.bound = v.mmmodule.type_any.as_nullable
else
var stype = n_type.get_stype(v)
if stype == null then return
_formal.bound = stype
end
else
- var ob = o.get_formal(_formal.position).bound.for_module(v.module)
+ var ob = o.get_formal(_formal.position).bound.for_module(v.mmmodule)
if n_type == null then
_formal.bound = ob
else
if glob.is_attribute then
if gbc.is_interface then
v.error(self, "Error: Attempt to define attribute {prop} in the interface {prop.local_class}.")
- else if gbc.is_universal then
- v.error(self, "Error: Attempt to define attribute {prop} in the universal class {prop.local_class}.")
+ else if gbc.is_enum then
+ v.error(self, "Error: Attempt to define attribute {prop} in the enum class {prop.local_class}.")
end
else if glob.is_init then
if gbc.is_interface then
v.error(self, "Error: Attempt to define a constructor {prop} in the class {prop.local_class}.")
- else if gbc.is_universal then
- v.error(self, "Error: Attempt to define a constructor {prop} in the universal {prop.local_class}.")
+ else if gbc.is_enum then
+ v.error(self, "Error: Attempt to define a constructor {prop} in the enum {prop.local_class}.")
end
end
if prop.signature == null then
end
var s = prop.signature
- #print "process {prop.local_class.module}::{prop.local_class}::{prop} from global {prop.global.local_property.local_class.module}::{prop.global.local_property.local_class}::{prop.global.local_property}"
+ #print "process {prop.local_class.mmmodule}::{prop.local_class}::{prop} from global {prop.global.local_property.local_class.mmmodule}::{prop.global.local_property.local_class}::{prop.global.local_property}"
for i in prop.prhe.direct_greaters do
var ip = i.local_class[prop.global]
var isig = i.signature.adaptation_to(v.local_class.get_type)
if visibility_level != 1 and glob.visibility_level != visibility_level then
v.error(self, "Redef error: {prop.local_class}::{prop} redefinition cannot change visibility.")
end
- glob.check_visibility(v, self, v.module, true)
+ glob.check_visibility(v, self, v.mmmodule, true)
end
end
redef fun accept_property_builder(v)
do
super
- var name = n_id.to_symbol
+ var name: Symbol
+ if n_id != null then
+ name = n_id.to_symbol
+ else
+ name = ("@" + n_id2.text).to_symbol
+ end
var lc = v.local_class
var prop = new MMSrcAttribute(name, lc, self)
_prop = prop
v.local_class.add_src_local_property(v, prop)
- if n_readable != null then
- name = n_id.text.substring_from(1).to_symbol
+ if n_readable != null or n_id == null then
+ if n_id != null then
+ name = n_id.text.substring_from(1).to_symbol
+ else
+ name = n_id2.to_symbol
+ end
var readmethod = new MMReadImplementationMethod(name, lc, self)
_readmethod = readmethod
v.local_class.add_src_local_property(v, readmethod)
end
- if n_writable != null then
- name = (n_id.text.substring_from(1) + "=").to_symbol
+ if n_writable != null or n_id == null then
+ if n_id != null then
+ name = (n_id.text.substring_from(1) + "=").to_symbol
+ else
+ name = (n_id2.text + "=").to_symbol
+ end
var writemethod = new MMWriteImplementationMethod(name, lc, self)
_writemethod = writemethod
v.local_class.add_src_local_property(v, writemethod)
var t0 = n_type.get_stype(v)
if t0 != null then t = t0 else return
else
- v.error(self, "Not yet implemented: Attribute definition {_prop.local_class}::{_prop} requires an explicit type.")
+ v.error(self, "Not yet implemented: Attribute definition {prop.local_class}::{prop} requires an explicit type.")
return
end
var signature = new MMSignature(new Array[MMType], t, v.local_class.get_type)
prop.signature = signature
var visibility_level = n_visibility.level
- process_and_check(v, prop, n_kwredef != null, visibility_level)
- if n_readable != null then
+ process_and_check(v, prop, n_id != null and n_kwredef != null, visibility_level)
+ if n_readable != null or n_id == null then
var m = _readmethod.as(not null)
m.signature = signature
- process_and_check(v, m, n_readable.n_kwredef != null, visibility_level)
+ process_and_check(v, m, (n_readable != null and n_readable.n_kwredef != null) or (n_id == null and n_kwredef != null), visibility_level)
n_type.check_visibility(v, m)
end
- if n_writable != null then
+ if n_writable != null or n_id == null then
var m = _writemethod.as(not null)
m.signature = new MMSignature(new Array[MMType].with_items(t), null, v.local_class.get_type)
- process_and_check(v, m, n_writable.n_kwredef != null, visibility_level)
+ var vl = visibility_level
+ if n_id == null then
+ if n_writable == null then vl = 3 else vl = n_writable.n_visibility.level # write accessor has a specific visibility
+ end
+ process_and_check(v, m, n_writable != null and n_writable.n_kwredef != null, vl)
n_type.check_visibility(v, m)
end
end
end
end
+redef class AExternMethPropdef
+ redef fun accept_property_verifier(v)
+ do
+ super # Compute signature
+ var ename: String
+ if n_extern != null then
+ ename = n_extern.text
+ ename = ename.substring(1, ename.length-2)
+ else
+ ename = "{method.mmmodule.name}_{method.local_class.name}_{method.local_class.name}_{method.name}_{method.signature.arity}"
+ end
+ method.extern_name = ename
+ end
+end
+
redef class ATypePropdef
redef fun prop do return _prop.as(not null)
var _prop: nullable MMSrcTypeProperty
do
super
_position = v.signature_builder.params.length
- _variable = new ParamVariable(n_id.to_symbol, self)
+ _variable = new ParamVariable(n_id.to_symbol, n_id)
v.signature_builder.params.add(self)
v.signature_builder.untyped_params.add(self)
if n_type != null then
end
# Add the finalizer to the closure signature
- var finalize_sig = new MMSignature(new Array[MMType], null, v.module.type_any) # FIXME should be no receiver
+ var finalize_sig = new MMSignature(new Array[MMType], null, v.mmmodule.type_any) # FIXME should be no receiver
var finalizer_clos = new MMClosure(once ("break".to_symbol), finalize_sig, false, true)
sig.closures.add(finalizer_clos)
v.signature_builder = old_signature_builder
_position = old_signature_builder.closure_decls.length
old_signature_builder.closure_decls.add(self)
- _variable = new ClosureVariable(n_id.to_symbol, self, clos)
+ _variable = new ClosureVariable(n_id.to_symbol, n_id, clos)
end
end
nitlanguage / nit.git / blobdiff