# Class specialization hierarchy sorter
private class CSHSorter
-special AbstractSorter[MMLocalClass]
+ super AbstractSorter[MMLocalClass]
redef fun compare(a, b)
do
return a.cshe.rank <=> b.cshe.rank
# 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
end
# Check class conformity
- var mmbv1b = new ClassVerifierVisitor(tc, self)
+ var mmbv1c = new ClassVerifierVisitor(tc, self)
for c in classes do
- c.accept_class_visitor(mmbv1b)
+ c.accept_class_visitor(mmbv1c)
end
tc.check_errors
# 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
redef class MMSrcLocalClass
redef fun accept_class_visitor(v)
do
- for n in nodes do
+ var n = node
+ while n != null do
v.enter_visit(n)
+ n = n.next_node
end
end
# Accept a class visitor (on class properties)
redef fun accept_properties_visitor(v)
do
- for n in nodes do
+ var n = node
+ while n != null do
v.enter_visit(n)
+ n = n.next_node
end
for p in src_local_properties do
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)
var superclass: nullable MMLocalClass = null # This most specific non-mixin superclass (if any)
if supers.length > 1 then
- v.error(nodes.first, "Error: Explicit constructor required in {self} since multiple inheritance of constructor is forbiden. Conflicting classes are {supers.join(", ")}. Costructors are {super_constructors.join(", ")}.")
+ v.error(node, "Error: Explicit constructor required in {self} since multiple inheritance of constructor is forbiden. Conflicting classes are {supers.join(", ")}. Costructors are {super_constructors.join(", ")}.")
return
else if supers.length == 1 then
superclass = supers.first
end
_super_init = base
- var params = new Array[MMType]
+ var params = new Array[MMParam]
if base != null then
var sig = base.signature
for i in [0..sig.arity[ do
- params.add(sig[i])
+ params.add(sig.params[i])
end
end
for a in unassigned_attributes do
var sig = a.signature
if sig == null then return # Broken attribute definition
- params.add(sig.return_type.as(not null))
+ var name = a.name
+ if name.to_s.first == '_' or name.to_s.first == '@' then
+ name = a.to_s.substring_from(1).to_symbol
+ end
+ params.add(new MMParam(sig.return_type.as(not null), name))
end
signature = new MMSignature(params, null, local_class.get_type)
end
# Concrete NIT class specialization relation
class MMSrcAncestor
-special MMAncestor
- # The related AST node
- readable var _node: ASuperclass
+ super MMAncestor
redef readable var _local_class: MMLocalClass
- init(n: ASuperclass, c: MMLocalClass)
+ init(c: MMLocalClass)
do
- _node = n
_local_class = c
end
end
# * Build the classes and attach them to global classes
# * Collect generic formal parameters.
private class ClassBuilderVisitor
-special AbsSyntaxVisitor
+ super AbsSyntaxVisitor
# Current class arity
readable writable var _local_class_arity: Int = 0
# Another pass visitor for syntax analysis.
# * Build ancertors (with only class informations not the type one)
private class ClassSpecializationBuilderVisitor
-special AbsSyntaxVisitor
+ super AbsSyntaxVisitor
redef fun visit(n) do n.accept_class_specialization_builder(self)
init(tc, m) do super
end
# Another pass visitor for syntax analysis.
# * Compute types in ancestors
private class ClassAncestorBuilder
-special AbsSyntaxVisitor
+ super AbsSyntaxVisitor
redef fun visit(n) do n.accept_class_ancestor_builder(self)
init(tc, m) do super
end
# Another pass visitor for syntax analysis.
# * Checks classes in regard to superclasses
private class ClassVerifierVisitor
-special AbsSyntaxVisitor
+ super AbsSyntaxVisitor
redef fun visit(n) do n.accept_class_verifier(self)
init(tc, m) do super
end
# * Build local properties and attache them to global properties
# * Attach bound to formal types
private class PropertyBuilderVisitor
-special AbsSyntaxVisitor
+ super AbsSyntaxVisitor
redef fun visit(n) do n.accept_property_builder(self)
init(tc, m) do super
end
# Another pass pass visitor for syntax analysis.
# * Check property conformance
private class PropertyVerifierVisitor
-special AbsSyntaxVisitor
+ super AbsSyntaxVisitor
# The signature currently build
readable writable var _signature_builder: SignatureBuilder
# Information about a signature currently build
private class SignatureBuilder
# Current visited parameter types
- readable writable var _params: Array[PParam] = new Array[PParam]
+ readable writable var _params: Array[AParam] = new Array[AParam]
# Visited parameters without type information added
- readable writable var _untyped_params: Array[PParam] = new Array[PParam]
+ readable writable var _untyped_params: Array[AParam] = new Array[AParam]
# Position of the current star parameter
readable writable var _vararg_rank: Int = -1
###############################################################################
-redef class PNode
+redef class ANode
private fun accept_class_builder(v: ClassBuilderVisitor) do accept_abs_syntax_visitor(v)
private fun accept_class_specialization_builder(v: ClassSpecializationBuilderVisitor) do accept_abs_syntax_visitor(v)
private fun accept_class_ancestor_builder(v: ClassAncestorBuilder) do accept_abs_syntax_visitor(v)
fun import_super_modules(tc: ToolContext, mod: MMSrcModule)
do
# Import super-modules
- var module_names_to_import = new Array[Symbol]
- var module_visibility = new HashMap[Symbol, Int]
- var no_import: nullable PImport = null
+ var supers = new Array[MMModule]
+ var no_import: nullable AImport = null
for i in n_imports do
var n = i.module_name
if n != null then
- module_names_to_import.add(n)
- module_visibility[n] = i.visibility_level
+ var m = tc.get_module(n, mod)
+ supers.add(m)
+ mod.add_super_module(m, i.visibility_level)
else
no_import = i
end
end
if no_import != null then
- if not module_names_to_import.is_empty then
- tc.error("{no_import.locate}: Error: Top modules cannot import other modules.")
+ if not supers.is_empty then
+ tc.error(no_import.location, "Error: Top modules cannot import other modules.")
end
- else if module_names_to_import.is_empty then
+ else if supers.is_empty then
var stdname = once "standard".to_symbol
- module_names_to_import.add(stdname)
- module_visibility[stdname] = 1
+ var m = tc.get_module(stdname, mod)
+ supers.add(m)
+ mod.add_super_module(m, 1)
end
- mod.import_supers_modules(module_names_to_import)
-
- for mname in module_names_to_import do
- var level = module_visibility[mname]
- var m = tc.get_module(mname, mod)
- mod.add_super_module(m, level)
- end
+ tc.add_module(mod, supers)
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_name.n_id.to_symbol != v.mmmodule.name then
+ v.error(n_name.n_id, "Error: Module name mismatch between {v.mmmodule.name} and {n_name.n_id.to_symbol}")
end
end
end
-redef class PImport
+redef class AImport
# Imported module name (or null)
fun module_name: nullable Symbol is abstract
# Visibility level (intrude/public/private)
fun visibility_level: Int is abstract
end
-redef class AImport
+redef class AStdImport
redef fun module_name
do
- return n_id.to_symbol
+ return n_name.n_id.to_symbol
end
redef fun visibility_level
do
end
end
-redef class PVisibility
+redef class AVisibility
# Visibility level
fun level: Int is abstract
end
end
-redef class PClassdef
+redef class AClassdef
redef fun local_class: MMSrcLocalClass do return _local_class.as(not null)
var _local_class: nullable MMSrcLocalClass
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]
- if self isa AClassdef then
+ _local_class = local_class
+ if self isa AStdClassdef then
# If we are not a special implicit class then rant
- v.error(self, "Error: A class {name} is already defined at line {local_class.nodes.first.first_token.location.line_start}.")
+ v.error(self, "Error: A class {name} is already defined at line {local_class.node.location.line_start}.")
return
end
- local_class.nodes.add(self)
+ # Add the new node after the last node
+ var n = local_class.node
+ while n.next_node != null do n = n.next_node
+ n.next_node = self
else
local_class = new MMSrcLocalClass(mod, name, self, arity)
+ _local_class = local_class
local_classes[name] = local_class
if not mod.has_global_class_named(name) then
- local_class.new_global
+ build_class_introduction(v)
else
- local_class.set_global(mod.global_class_named(name))
+ var glob = mod.global_class_named(name)
+ build_class_refinement(v, glob)
end
end
- _local_class = local_class
v.local_class_arity = 0
v.formals = local_class.formal_dict
v.formals = null
end
+ fun build_class_introduction(v: AbsSyntaxVisitor)
+ do
+ local_class.new_global
+ var glob = local_class.global
+
+ glob.visibility_level = visibility_level
+ if self isa AStdClassdef then
+ if n_kwredef != null then
+ v.error(self, "Redef error: No class {name} is imported. Remove the redef keyword to define a new class.")
+ return
+ end
+ glob.is_interface = n_classkind.is_interface
+ glob.is_abstract = n_classkind.is_abstract
+ glob.is_enum = n_classkind.is_enum
+ end
+ end
+
+ fun build_class_refinement(v: AbsSyntaxVisitor, glob: MMGlobalClass)
+ do
+ local_class.set_global(glob)
+
+ glob.check_visibility(v, self, v.mmmodule)
+ if self isa AStdClassdef and n_kwredef == null then
+ v.error(self, "Redef error: {name} is an imported class. Add the redef keyword to refine it.")
+ return
+ end
+
+ if glob.intro.arity != _local_class.arity then
+ v.error(self, "Redef error: Formal parameter arity missmatch; got {_local_class.arity}, expected {glob.intro.arity}.")
+ end
+
+ if self isa AStdClassdef and (not glob.is_interface and n_classkind.is_interface or
+ not glob.is_abstract and n_classkind.is_abstract or
+ not glob.is_enum and n_classkind.is_enum)
+ then
+ v.error(self, "Redef error: cannot change kind of class {name}.")
+ end
+ end
+
+ redef fun accept_class_verifier(v)
+ do
+ super
+ var glob = _local_class.global
+ for c in _local_class.cshe.direct_greaters do
+ var cg = c.global
+ if glob.is_interface then
+ 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_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_enum then
+ v.error(self, "Special error: Class {name} try to specialise enum class {c.name}.")
+ end
+ end
+
+ end
+ end
+
redef fun accept_abs_syntax_visitor(v)
do
v.local_class = _local_class
end
end
-redef class PClasskind
+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
end
-redef class AClassdef
+redef class AStdClassdef
redef fun name
do
return n_id.to_symbol
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
end
if glob.intro.arity != _local_class.arity then
- v.error(self, "Redef error: Formal parameter arity missmatch; got {_local_class.arity}, expected {glob.intro.arity}.")
+ v.error(self, "Redef error: Formal parameter arity mismatch; got {_local_class.arity}, expected {glob.intro.arity}.")
end
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
end
end
-class MMSrcTypeFormalParameter
-special MMTypeFormalParameter
- # The associated node
- readable var _node: AFormaldef
-
- init(name: Symbol, pos: Int, local_class: MMLocalClass, n: AFormaldef)
- do
- super(name, pos, local_class)
- _node = n
- end
-end
-
redef class AFormaldef
# The associated formal generic parameter (MM entity)
- var _formal: nullable MMSrcTypeFormalParameter
+ var _formal: nullable MMTypeFormalParameter
redef fun accept_class_builder(v)
do
var name = n_id.to_symbol
- var formal_type = new MMSrcTypeFormalParameter(name, v.local_class_arity, v.local_class, self)
+ var formal_type = new MMTypeFormalParameter(name, v.local_class_arity, v.local_class)
_formal = formal_type
v.local_class_arity = v.local_class_arity + 1
v.local_class.register_formal(formal_type)
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
super
var c = n_type.get_local_class(v)
if c == null then return
- var ancestor = new MMSrcAncestor(self, c)
+ var ancestor = new MMSrcAncestor(c)
_ancestor = ancestor
v.local_class.add_direct_parent(ancestor)
end
end
end
-redef class PPropdef
+redef class APropdef
# Process and check properties of the property.
# * Distinguish inits and methods
# * Inherit or check visibility.
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
else if not v.signature_builder.untyped_params.is_empty then
v.error(v.signature_builder.untyped_params.first, "Error: Untyped parameter.")
else
- prop.signature = new MMSignature(new Array[MMType], null, v.local_class.get_type)
+ prop.signature = new MMSignature(new Array[MMParam], null, v.local_class.get_type)
for clos in v.signature_builder.closure_decls do
prop.signature.closures.add(clos.variable.closure)
end
if s == null then
if v.signature_builder.params.length != isig.arity then
- #prop.node.printl("v.params.length {v.params.length} != isig.arity {isig.arity} ; {prop.full_name} vs {ip.full_name}")
return
end
for p in v.signature_builder.params do
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)
+ var isig = i.signature
+ if isig == null then break # previous signature is invalid
+ isig = isig.adaptation_to(v.local_class.get_type)
if s == null then
#print "{prop.full_name} inherits signature from {ip.full_name}"
if s.arity != isig.arity then
v.error(self, "Redef error: {prop.local_class}::{prop} redefines {ip.local_class}::{ip} with {isig.arity} parameter(s).")
- else
- for i in [0..s.arity[ do
- if s[i] != isig[i] then
- v.error(self, "Redef error: Expected {isig[i]} (as in {ip.local_class}::{ip}), got {s[i]} in {prop.local_class}::{prop}.")
+ else if s.arity > 0 then
+ if self isa AMethPropdef then
+ # A standard method
+ for j in [0..s.arity[ do
+ if s[j] != isig[j] then
+ v.error(n_signature.n_params[j], "Redef error: Expected {isig[j]}, as in {ip.local_class}::{ip}.")
+ end
+ end
+ else if self isa AAttrPropdef then
+ # A write accessor
+ if s[0] != isig[0] then
+ v.error(n_type, "Redef error: Expected {isig[0]}, as in the parameter of {ip.local_class}::{ip}.")
end
+
+ else
+ abort #
end
end
else if srt != null and isrt == null then
v.error(self, "Redef error: The function {prop.local_class}::{prop} redefines the procedure {ip.local_class}::{ip}.")
else if srt != null and isrt != null and not srt < isrt then
- v.error(self, "Redef error: Expected {isrt} (as in {ip.local_class}::{ip}), got {srt} in {prop.local_class}::{prop}.")
+ var n: nullable ANode = null
+ if self isa AMethPropdef then
+ n = self.n_signature.n_type
+ else if self isa AAttrPropdef then
+ n = self.n_type
+ else if self isa ATypePropdef then
+ n = self.n_type
+ end
+ v.error(n, "Redef error: Expected {isrt}, as in {ip.local_class}::{ip}.")
else if not s < isig and nberr == v.tc.error_count then
# Systematic fallback for conformance check
v.error(self, "Redef error: Incompatible redefinition of {ip.local_class}::{ip} with {prop.local_class}::{prop}")
else if srt != null and isrt != null and srt != isrt and prop isa MMAttribute then
# FIXME: To remove
- v.warning(self, "Redef warning: Expected {isrt} (as in {ip.local_class}::{ip}), got {srt} in {prop.local_class}::{prop}.")
+ v.warning(self, "Redef warning: Expected {isrt}, as in {ip.local_class}::{ip}.")
end
end
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 prop = prop
- var signature = new MMSignature(new Array[MMType], t, v.local_class.get_type)
+ var signature = new MMSignature(new Array[MMParam], 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)
+ m.signature = new MMSignature(new Array[MMParam].with_items(new MMParam(t, once "value".to_symbol)), null, v.local_class.get_type)
+ 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
# FIXME: Add the 'unary' keyword
if n_methid.name == (once "-".to_symbol) then
var ns = n_signature
- if ns isa ASignature and ns.n_params.length == 0 then
+ if ns != null and ns.n_params.length == 0 then
name = once "unary -".to_symbol
end
end
redef fun process_and_check(v, prop, has_redef, visibility_level)
do
prop.global.visibility_level = visibility_level
- prop.signature = new MMSignature(new Array[MMType], null, v.local_class.get_type)
+ prop.signature = new MMSignature(new Array[MMParam], null, v.local_class.get_type)
# Disable all checks for main
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
redef fun accept_property_verifier(v)
do
super
- var signature = new MMSignature(new Array[MMType], n_type.get_stype(v), v.local_class.get_type)
+ var signature = new MMSignature(new Array[MMParam], n_type.get_stype(v), v.local_class.get_type)
prop.signature = signature
var visibility_level = n_visibility.level
process_and_check(v, prop, n_kwredef != null, visibility_level)
# Visitor used to build a full method name from multiple tokens
private class MethidAccumulator
-special Visitor
+ super Visitor
readable var _name: Buffer = new Buffer
redef fun visit(n)
do
end
end
-redef class PMethid
- # Method name
- readable var _name: nullable Symbol
+redef class AMethid
+ redef readable var _name: nullable Symbol
redef fun accept_property_builder(v)
do
end
end
-redef class PSignature
- # Check that visibilities of types in the signature are compatible with the visibility of the property.
- fun check_visibility(v: AbsSyntaxVisitor, p: MMLocalProperty) is abstract
-end
-
redef class ASignature
redef fun accept_property_verifier(v)
do
return
end
else if not v.signature_builder.params.is_empty or n_type != null then
- var pars = new Array[MMType]
+ var pars = new Array[MMParam]
for p in v.signature_builder.params do
- pars.add(p.stype.as(not null))
+ pars.add( new MMParam( p.stype.as(not null), p.n_id.to_symbol ) )
end
var ret: nullable MMType = null
if n_type != null then
end
end
- redef fun check_visibility(v, p)
+ # Check that visibilities of types in the signature are compatible with the visibility of the property.
+ fun check_visibility(v: AbsSyntaxVisitor, p: MMLocalProperty)
do
if p.global.visibility_level >= 3 then return
for n in n_params do
end
end
-redef class PParam
+redef class AParam
redef readable var _position: Int = 0
redef fun variable: ParamVariable do return _variable.as(not null)
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
end
- fun is_vararg: Bool is abstract
-end
-
-redef class AParam
- redef fun is_vararg do return n_dotdotdot != null
+ fun is_vararg: Bool do return n_dotdotdot != null
end
redef class AClosureDecl
end
var sig = v.signature_builder.signature
if sig == null then
- sig = new MMSignature(new Array[MMType], null, v.local_class.get_type)
+ sig = new MMSignature(new Array[MMParam], null, v.local_class.get_type)
end
if sig.return_type != null and n_kwbreak != null then
v.error(self, "Syntax Error: A break block cannot have a return value.")
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 finalizer_clos = new MMClosure(finalize_sig, false, true)
+ var finalize_sig = new MMSignature(new Array[MMParam], 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)
- var clos = new MMClosure(sig, n_kwbreak != null, n_expr != null)
+ var name = n_id.to_symbol
+ var clos = new MMClosure(name, sig, n_kwbreak != null, n_expr != null)
+ for c in old_signature_builder.closure_decls do
+ if c.n_id.to_symbol == name then
+ v.error(n_id, "A closure '!{name}' already defined at {c.n_id.location.relative_to(n_id.location)}.")
+ return
+ end
+ end
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
-redef class PType
- # Check that visibilities of types in the signature are compatible with the visibility of the property.
- private fun check_visibility(v: AbsSyntaxVisitor, p: MMLocalProperty) is abstract
-end
-
redef class AType
- redef fun check_visibility(v, p)
+ # Check that visibilities of types in the signature are compatible with the visibility of the property.
+ private fun check_visibility(v: AbsSyntaxVisitor, p: MMLocalProperty)
do
if p.global.visibility_level >= 3 then return
var t = get_stype(v)
end
end
-redef class PExpr
+redef class AExpr
redef fun accept_class_builder(v) do end
redef fun accept_property_builder(v) do end
redef fun accept_property_verifier(v) do end