# Class specialization hierarchy sorter
private class CSHSorter
-special AbstractSorter[MMLocalClass]
- redef meth compare(a, b)
+ super AbstractSorter[MMLocalClass]
+ redef fun compare(a, b)
do
return a.cshe.rank <=> b.cshe.rank
end
redef class MMSrcModule
# Syntax analysis and MM construction for the module
# Require that supermodules are processed
- meth do_mmbuilder(tc: ToolContext)
+ fun do_mmbuilder(tc: ToolContext)
do
# Import global classes
import_global_classes
# Create local classes and attach them to global classes
var mmbv = new ClassBuilderVisitor(tc, self)
- mmbv.visit(node)
- if tc.error_count > 0 then exit(1)
+ mmbv.enter_visit(node)
+ tc.check_errors
+
+ if mhe.direct_greaters.is_empty then
+ process_default_classes(tc)
+ end
# Import unrefined local classes and attach them to global classes
import_local_classes
# Resolve classes in super clauses
var mmbv1 = new ClassSpecializationBuilderVisitor(tc, self)
- mmbv1.visit(node)
- if tc.error_count > 0 then exit(1)
+ mmbv1.enter_visit(node)
+ tc.check_errors
# 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
+ tc.check_errors
# Class that we will process now are those in the hierarchy
# Its mean all the visible classes and their super-classes
var mmbv1b = new ClassAncestorBuilder(tc, self)
for c in classes do
c.accept_class_visitor(mmbv1b)
+ tc.check_errors
c.compute_ancestors
end
- if tc.error_count > 0 then exit(1)
# 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
- if tc.error_count > 0 then exit(1)
+ 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
# Note that inherited unredefined property are processed on demand latter
end
- if tc.error_count > 0 then exit(1)
+ tc.check_errors
# Property signature analysis and inheritance conformance
var mmbv3 = new PropertyVerifierVisitor(tc, self)
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
- if tc.error_count > 0 then exit(1)
+ # Create some primitive default classes if they do not exists
+ fun process_default_classes(tc: ToolContext)
+ do
+ var name = once ("Object".to_symbol)
+ if not has_global_class_named(name) then
+ var c = new MMSrcLocalClass(self, name, null, 0)
+ c.new_global
+ src_local_classes[name] = c
+ end
+ name = once ("Bool".to_symbol)
+ if not has_global_class_named(name) then
+ var c = new MMSrcLocalClass(self, name, null, 0)
+ c.new_global
+ src_local_classes[name] = c
+ end
end
end
redef class MMLocalClass
# Accept a class visitor (on class nodes)
- private meth accept_class_visitor(v: AbsSyntaxVisitor)
+ private fun accept_class_visitor(v: AbsSyntaxVisitor)
do
end
# Accept a class visitor (on class properties)
- private meth accept_properties_visitor(v: AbsSyntaxVisitor)
+ private fun accept_properties_visitor(v: AbsSyntaxVisitor)
do
end
end
redef class MMSrcLocalClass
- redef meth accept_class_visitor(v)
+ redef fun accept_class_visitor(v)
do
- for n in nodes do
- v.visit(n)
+ 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 meth accept_properties_visitor(v)
+ redef fun accept_properties_visitor(v)
do
- for n in nodes do
- v.visit(n)
+ var n = node
+ while n != null do
+ v.enter_visit(n)
+ n = n.next_node
end
for p in src_local_properties do
end
end
- # A mixin class can be build the same way that one of its superclasses
- readable attr _is_mixin: Bool = false
-
# Introduce or inherit default constructors
- private meth process_default_constructors(v: PropertyBuilderVisitor)
+ private fun process_default_constructors(v: PropertyBuilderVisitor)
do
# Is there already a constructor ?
for gp in global_properties do
end
# Collect visible constructors in super stateful classes
+ 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
+ var initname = once ("init".to_symbol)
+ if sc.has_global_property_by_name(initname) then
+ var gp = sc.get_property_by_name(initname)
+ super_inits.add(self[gp])
+ end
+ end
+
+ # Collect unassigned attributes
+ var unassigned_attributes = new Array[MMSrcAttribute]
+ for a in src_local_properties do
+ if a isa MMSrcAttribute then
+ var n = a.node
+ if n.n_expr == null then unassigned_attributes.add(a)
+ end
end
if not super_constructors.is_empty then
for gp in super_constructors do
var sc = gp.local_class
if supers.has(sc) then continue
- assert sc isa MMSrcLocalClass
- if not sc.is_mixin then
+ if not sc.global.is_mixin then
supers.add(sc)
end
end
supers = che.order.select_smallests(supers)
# A mixin class can only have 0 or 1 most specific non-mixin superclass
- var superclass: MMLocalClass = null # This most specific non-mixin superclass (if any)
+ 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
make_visible_an_inherited_global_property(gp)
end
end
- _is_mixin = true
+ global.mixin_of = superclass.as(not null).global # FIXME Dear! this should break!
+ else
+ # v.error(nodes.first, "Error, constructor required in {self} since no anonimous init found in {sc}.")
+
+ # unassigned attributes, then implicit consructors are generated
+ var p = new MMImplicitInit(self, unassigned_attributes, super_inits.to_a)
+ add_src_local_property(v, p)
+ #print("Create implicit init {p} in {self} from {super_inits.join(", ")} + {unassigned_attributes.length} args")
end
end
# Add a source property
# Register it to the class and attach it to global property
- private meth add_src_local_property(v: PropertyBuilderVisitor, prop: MMLocalProperty)
+ private fun add_src_local_property(v: PropertyBuilderVisitor, prop: MMLocalProperty)
do
var pname = prop.name
# Check double definition in the same class
# Intro or redefinition ?
if has_global_property_by_name(pname) then
- var globs = properties_by_name[pname]
- if globs.length > 1 then
- v.error(prop.node, "Name error: {self} inherits {globs.length} global properties named {pname}.")
- end
- var g = globs.first
+ var g = get_property_by_name(pname)
prop.inherit_global(g)
end
- if prop.global == null then
- #print "{prop.full_name} is an introduction"
+ if not prop.is_global_set then
prop.new_global
- prop.global.is_init = prop.node isa AConcreteInitPropdef
+ prop.global.is_init = prop.is_init
end
end
end
redef class MMLocalProperty
- private meth accept_property_visitor(v: AbsSyntaxVisitor)
+ private fun accept_property_visitor(v: AbsSyntaxVisitor)
+ do
+ end
+end
+
+redef class MMImplicitInit
+ redef readable var _super_init: nullable MMLocalProperty = null
+ redef fun accept_property_visitor(v)
do
+ var base: nullable MMLocalProperty = null
+ for p in super_inits do
+ if p.signature.arity > 0 then
+ if base == null then
+ base = p
+ else
+ v.error(null, "Error: explicit constructor needed in {local_class} since both super-constructor {base.full_name} and {p.full_name} have paramters")
+ return
+ end
+ end
+ end
+ _super_init = base
+
+ var params = new Array[MMType]
+ if base != null then
+ var sig = base.signature
+ for i in [0..sig.arity[ do
+ params.add(sig[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))
+ end
+ signature = new MMSignature(params, null, local_class.get_type)
end
end
+
+
# Concrete NIT class specialization relation
class MMSrcAncestor
-special MMAncestor
- # The related AST node
- readable attr _node: ASuperclass
- redef readable attr _local_class: MMLocalClass
+ 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 attr _local_class_arity: Int
+ readable writable var _local_class_arity: Int = 0
# Current class formal parameters
- readable writable attr _formals: Map[Symbol, MMTypeFormalParameter]
+ readable writable var _formals: nullable Map[Symbol, MMTypeFormalParameter]
- redef meth visit(n) do n.accept_class_builder(self)
+ redef fun visit(n) do n.accept_class_builder(self)
init(tc, m) do super
end
# Another pass visitor for syntax analysis.
# * Build ancertors (with only class informations not the type one)
private class ClassSpecializationBuilderVisitor
-special AbsSyntaxVisitor
- redef meth visit(n) do n.accept_class_specialization_builder(self)
+ 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
- redef meth visit(n) do n.accept_class_ancestor_builder(self)
+ 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
- redef meth visit(n) do n.accept_class_verifier(self)
+ 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
- redef meth visit(n) do n.accept_property_builder(self)
+ 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
+
+ redef fun visit(n) do n.accept_property_verifier(self)
+
+ init(tc, m)
+ do
+ super
+ _signature_builder = new SignatureBuilder
+ end
+end
+
+# Information about a signature currently build
+private class SignatureBuilder
# Current visited parameter types
- readable writable attr _params: Array[PParam]
+ readable writable var _params: Array[AParam] = new Array[AParam]
# Visited parameters without type information added
- readable writable attr _untyped_params: Array[PParam]
+ readable writable var _untyped_params: Array[AParam] = new Array[AParam]
# Position of the current star parameter
- readable writable attr _vararg_rank: Int
+ readable writable var _vararg_rank: Int = -1
- # Current signature
- readable writable attr _signature: MMSignature
+ # Current closure declarations
+ readable writable var _closure_decls: Array[AClosureDecl] = new Array[AClosureDecl]
- redef meth visit(n) do n.accept_property_verifier(self)
+ # True is a problen occured durring building
+ readable writable var _has_error_occured: Bool = false
- init(tc, m) do super
+ # Current signature
+ readable writable var _signature: nullable MMSignature = null
end
###############################################################################
-redef class PNode
- private meth accept_class_builder(v: ClassBuilderVisitor) do accept_abs_syntax_visitor(v)
- private meth accept_class_specialization_builder(v: ClassSpecializationBuilderVisitor) do accept_abs_syntax_visitor(v)
- private meth accept_class_ancestor_builder(v: ClassAncestorBuilder) do accept_abs_syntax_visitor(v)
- private meth accept_class_verifier(v: ClassVerifierVisitor) do accept_abs_syntax_visitor(v)
- private meth accept_property_builder(v: PropertyBuilderVisitor) do accept_abs_syntax_visitor(v)
- private meth accept_property_verifier(v: PropertyVerifierVisitor) do accept_abs_syntax_visitor(v)
+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)
+ private fun accept_class_verifier(v: ClassVerifierVisitor) do accept_abs_syntax_visitor(v)
+ private fun accept_property_builder(v: PropertyBuilderVisitor) do accept_abs_syntax_visitor(v)
+ private fun accept_property_verifier(v: PropertyVerifierVisitor) do accept_abs_syntax_visitor(v)
end
redef class AModule
# Import supermodules and compute visibility
- meth import_super_modules(tc: ToolContext, mod: MMSrcModule)
+ 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: 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 meth accept_class_builder(v)
+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 class PImport
+redef class AImport
# Imported module name (or null)
- meth module_name: Symbol is abstract
+ fun module_name: nullable Symbol is abstract
# Visibility level (intrude/public/private)
- meth visibility_level: Int is abstract
+ fun visibility_level: Int is abstract
end
-redef class AImport
- redef meth module_name
+redef class AStdImport
+ redef fun module_name
do
return n_id.to_symbol
end
- redef meth visibility_level
+ redef fun visibility_level
do
return n_visibility.level
end
end
redef class ANoImport
- redef meth module_name
+ redef fun module_name
do
return null
end
end
-redef class PVisibility
+redef class AVisibility
# Visibility level
- meth level: Int is abstract
+ fun level: Int is abstract
end
redef class APublicVisibility
- redef meth level do return 1
+ redef fun level do return 1
end
redef class AProtectedVisibility
- redef meth level do return 2
+ redef fun level do return 2
end
redef class APrivateVisibility
- redef meth level do return 3
+ redef fun level do return 3
end
redef class AIntrudeVisibility
- redef meth level do return 0
+ redef fun level do return 0
end
-redef class PClassdef
- redef readable attr _local_class: MMSrcLocalClass
+redef class AClassdef
+ redef fun local_class: MMSrcLocalClass do return _local_class.as(not null)
+ var _local_class: nullable MMSrcLocalClass
# Name of the class
- meth name: Symbol is abstract
+ fun name: Symbol is abstract
# Number of formal parameters
- meth arity: Int do return 0
+ fun arity: Int do return 0
# Visibility of the class
- meth visibility_level: Int do return 1
+ fun visibility_level: Int do return 1
- redef meth accept_class_builder(v)
+ 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.line}.")
+ 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(name, self, arity)
- mod.add_local_class(local_class)
+ local_class = new MMSrcLocalClass(mod, name, self, arity)
+ _local_class = local_class
local_classes[name] = local_class
- var g = mod.global_class_named(name)
- if g == null then
- # Intro
- local_class.new_global
- g = local_class.global
+ if not mod.has_global_class_named(name) then
+ build_class_introduction(v)
else
- local_class.set_global(g)
+ 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 = new HashMap[Symbol, MMTypeFormalParameter]
+ v.formals = local_class.formal_dict
#####
super
#####
- _local_class.formal_dict = v.formals
v.formals = null
end
- redef meth accept_abs_syntax_visitor(v)
+ fun build_class_introduction(v: AbsSyntaxVisitor)
do
- v.local_class = _local_class
- super
- v.local_class = null
- end
-end
+ local_class.new_global
+ var glob = local_class.global
-redef class PClasskind
- meth is_interface: Bool do return false
- meth is_universal: Bool do return false
- meth is_abstract: Bool do return false
-end
-
-redef class AInterfaceClasskind
- redef meth is_interface do return true
-end
-redef class AUniversalClasskind
- redef meth is_universal do return true
-end
-redef class AAbstractClasskind
- redef meth is_abstract do return true
-end
-
-redef class AClassdef
- redef meth name
- do
- return n_id.to_symbol
- end
- redef meth arity
- do
- return n_formaldefs.length
- end
- redef meth accept_class_verifier(v)
- do
- super
- var glob = _local_class.global
- if glob.intro == _local_class then
- # Intro
- 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.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
-
- 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}.")
- 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}.")
- end
- else
- if cg.is_universal then
- v.error(self, "Special error: Class {name} try to specialise universal class {c.name}.")
- end
- end
-
- end
- return
+ glob.is_interface = n_classkind.is_interface
+ glob.is_abstract = n_classkind.is_abstract
+ glob.is_enum = n_classkind.is_enum
end
+ end
- # Redef
+ fun build_class_refinement(v: AbsSyntaxVisitor, glob: MMGlobalClass)
+ do
+ local_class.set_global(glob)
- glob.check_visibility(v, self, v.module)
- if n_kwredef == null then
+ 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
v.error(self, "Redef error: Formal parameter arity missmatch; got {_local_class.arity}, expected {glob.intro.arity}.")
end
- if
- not glob.is_interface and n_classkind.is_interface or
+ 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_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
- redef meth visibility_level
+ 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
+ super
+ v.local_class = null
+ end
+end
+
+redef class AClasskind
+ fun is_interface: 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 AEnumClasskind
+ redef fun is_enum do return true
+end
+redef class AAbstractClasskind
+ redef fun is_abstract do return true
+end
+
+redef class AStdClassdef
+ redef fun name
+ do
+ return n_id.to_symbol
+ end
+ redef fun arity
+ do
+ return n_formaldefs.length
+ end
+
+ redef fun visibility_level
do
return n_visibility.level
end
end
redef class AMainClassdef
- redef meth name
+ redef fun name
do
return once "Sys".to_symbol
end
end
redef class ATopClassdef
- redef meth name
+ redef fun name
do
return once "Object".to_symbol
end
end
-class MMSrcTypeFormalParameter
-special MMTypeFormalParameter
- # The associated node
- readable attr _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)
- attr _formal: MMSrcTypeFormalParameter
+ var _formal: nullable MMTypeFormalParameter
- redef meth accept_class_builder(v)
+ 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)
super
end
- redef meth accept_class_verifier(v)
+ redef fun accept_class_verifier(v)
do
super
var c = v.local_class
var o = c.global.intro
if c == o then
if n_type == null then
- _formal.bound = v.module.type_any
+ _formal.bound = v.mmmodule.type_any.as_nullable
else
- _formal.bound = n_type.get_stype(v)
+ 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
- _formal.bound = n_type.get_stype(v)
+ var stype = n_type.get_stype(v)
+ if stype == null then return
+ _formal.bound = stype
if _formal.bound != ob then
v.error(self, "Redef error: Cannot change formal parameter type of class {c}; got {_formal.bound}, expected {ob}.")
end
end
redef class ASuperclass
- readable attr _ancestor: MMSrcAncestor
+ readable var _ancestor: nullable MMSrcAncestor
- redef meth accept_class_specialization_builder(v)
+ redef fun accept_class_specialization_builder(v)
do
super
var c = n_type.get_local_class(v)
- var ancestor = new MMSrcAncestor(self, c)
+ if c == null then return
+ var ancestor = new MMSrcAncestor(c)
_ancestor = ancestor
v.local_class.add_direct_parent(ancestor)
end
- redef meth accept_class_ancestor_builder(v)
+ redef fun accept_class_ancestor_builder(v)
do
super
_ancestor.stype = n_type.get_unchecked_stype(v)
_ancestor.inheriter = v.local_class.get_type
end
- redef meth accept_class_verifier(v)
+ redef fun accept_class_verifier(v)
do
super
n_type.check_conform(v)
end
end
-redef class PPropdef
+redef class APropdef
# Process and check properties of the property.
# * Distinguish inits and methods
# * Inherit or check visibility.
# * Check redef errors.
# * Check forbiden attribute definitions.
# * Check signature conformance.
- private meth process_and_check(v: PropertyVerifierVisitor, prop: MMLocalProperty, has_redef: Bool, visibility_level: Int)
+ private fun process_and_check(v: PropertyVerifierVisitor, prop: MMLocalProperty, has_redef: Bool, visibility_level: Int)
do
if prop.global.intro == prop then
do_and_check_intro(v, prop, has_redef, visibility_level)
end
# The part of process_and_check when prop is an introduction
- private meth do_and_check_intro(v: PropertyVerifierVisitor, prop: MMLocalProperty, has_redef: Bool, visibility_level: Int)
+ private fun do_and_check_intro(v: PropertyVerifierVisitor, prop: MMLocalProperty, has_redef: Bool, visibility_level: Int)
do
var glob = prop.global
var gbc = prop.local_class.global
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
var supers = prop.local_class.super_methods_named(prop.name)
inherit_signature(v, prop, supers)
end
- if prop.signature != null then
+ if prop.signature != null or v.signature_builder.has_error_occured then
# ok
- else if not v.untyped_params.is_empty then
- v.error(v.untyped_params.first, "Error: Untyped parameter.")
+ 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)
+ for clos in v.signature_builder.closure_decls do
+ prop.signature.closures.add(clos.variable.closure)
+ end
end
end
end
- private meth inherit_signature(v: PropertyVerifierVisitor, prop: MMLocalProperty, supers: Array[MMLocalProperty])
+ private fun inherit_signature(v: PropertyVerifierVisitor, prop: MMLocalProperty, supers: Array[MMLocalProperty])
do
var s = prop.signature
for ip in supers do
var isig = ip.signature.adaptation_to(v.local_class.get_type)
if s == null then
- if v.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}")
+ if v.signature_builder.params.length != isig.arity then
return
end
- for p in v.params do
+ for p in v.signature_builder.params do
var t = isig[p.position]
p.stype = t
if p.position == isig.vararg_rank then
end
# The part of process_and_check when prop is a redefinition
- private meth do_and_check_redef(v: PropertyVerifierVisitor, prop: MMLocalProperty, has_redef: Bool, visibility_level: Int)
+ private fun do_and_check_redef(v: PropertyVerifierVisitor, prop: MMLocalProperty, has_redef: Bool, visibility_level: Int)
do
var is_init = self isa AConcreteInitPropdef
var glob = prop.global
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 v.params.length != isig.arity then
+ if v.signature_builder.params.length != isig.arity then
v.error(self, "Redef error: {prop.local_class}::{prop} redefines {ip.local_class}::{ip} with {isig.arity} parameter(s).")
return
end
- for p in v.params do
+ if v.signature_builder.closure_decls.length != isig.closures.length then
+ v.error(self, "Redef error: {prop.local_class}::{prop} redefines {ip.local_class}::{ip} with {isig.arity} closure(s).")
+ return
+ end
+ for p in v.signature_builder.params do
var t = isig[p.position]
p.stype = t
if p.position == isig.vararg_rank then
end
s = isig
prop.signature = s
+ #print "s is null"
end
+ var nberr = v.tc.error_count
+ #print "Check {prop.local_class}::{prop}{s} vs {ip.local_class}::{ip}{isig}"
+ #print "s={s.object_id} isig={isig.object_id} isigorig={i.signature.object_id}"
+
#print "orig signature: {i.signature.recv} . {i.signature}"
#print "inh signature: {isig.recv} . {isig}"
#print "redef signature: {s.recv} . {s}"
- if glob.is_init and i.local_class.global != prop.local_class.global then
- # Do not check signature
- else if s.arity != isig.arity then
+ 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}.")
+ for j in [0..s.arity[ do
+ if s[j] != isig[j] then
+ v.error(self, "Redef error: Expected {isig[j]} (as in {ip.local_class}::{ip}), got {s[j]} in {prop.local_class}::{prop}.")
end
end
end
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}.")
+ 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}.")
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 class AAttrPropdef
- redef readable attr _readmethod: MMSrcMethod
- redef readable attr _writemethod: MMSrcMethod
- redef readable attr _prop: MMSrcAttribute
+ redef readable var _readmethod: nullable MMSrcMethod
+ redef readable var _writemethod: nullable MMSrcMethod
+ var _prop: nullable MMSrcAttribute
+ redef fun prop do return _prop.as(not null)
- redef meth accept_property_builder(v)
+ redef fun accept_property_builder(v)
do
super
- var name = n_id.to_symbol
- var prop = new MMSrcAttribute(name, v.local_class, self)
+ 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
- _readmethod = new MMReadImplementationMethod(name, v.local_class, self)
- v.local_class.add_src_local_property(v, _readmethod)
+ 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
- _writemethod = new MMWriteImplementationMethod(name, v.local_class, self)
- v.local_class.add_src_local_property(v, _writemethod)
+ 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)
end
end
- redef meth accept_property_verifier(v)
+ redef fun accept_property_verifier(v)
do
super
var t: MMType
if n_type != null then
- t = n_type.get_stype(v)
+ 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)
- _prop.signature = signature
+ prop.signature = signature
var visibility_level = n_visibility.level
- process_and_check(v, _prop, n_kwredef != null, visibility_level)
- if n_readable != null then
- _readmethod.signature = signature
- process_and_check(v, _readmethod, n_readable.n_kwredef != null, visibility_level)
- n_type.check_visibility(v, _readmethod)
+ 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 != 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
- _writemethod.signature = new MMSignature(new Array[MMType].with(t), null, v.local_class.get_type)
- process_and_check(v, _writemethod, n_writable.n_kwredef != null, visibility_level)
- n_type.check_visibility(v, _writemethod)
+ 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)
+ 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
- redef meth accept_abs_syntax_visitor(v)
+ redef fun accept_abs_syntax_visitor(v)
do
- v.local_property = prop
+ v.local_property = _prop
super
v.local_property = null
end
redef class AMethPropdef
# Name of the method
- readable attr _name: Symbol
+ readable var _name: nullable Symbol
- redef readable attr _method: MMMethSrcMethod
+ var _method: nullable MMMethSrcMethod
+ redef fun method do return _method.as(not null)
- redef meth accept_property_builder(v)
+ redef fun accept_property_builder(v)
do
super
+ var name: Symbol
if n_methid == null then
if self isa AConcreteInitPropdef then
- _name = once "init".to_symbol
+ name = once "init".to_symbol
else
- _name = once "main".to_symbol
+ name = once "main".to_symbol
end
- else
- _name = n_methid.name
+ else
+ name = n_methid.name.as(not null)
# 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
- _name = once "unary -".to_symbol
+ if ns != null and ns.n_params.length == 0 then
+ name = once "unary -".to_symbol
end
end
end
- var prop = new MMMethSrcMethod(_name, v.local_class, self)
+ _name = name
+ var prop = new MMMethSrcMethod(name, v.local_class, self)
_method = prop
v.local_class.add_src_local_property(v, prop)
end
- redef meth accept_property_verifier(v)
+ redef fun accept_property_verifier(v)
do
- v.params = new Array[PParam]
- v.untyped_params = new Array[PParam]
- v.signature = null
- v.vararg_rank = -1
-
+ v.signature_builder = new SignatureBuilder
super
- if v.signature == null then
+ if v.signature_builder.has_error_occured then return
+
+ if v.signature_builder.signature == null then
#_method.signature = new MMSignature(new Array[MMType], null, v.local_class.get_type)
else
- _method.signature = v.signature
+ method.signature = v.signature_builder.signature.as(not null)
end
var visibility_level = 1
if n_visibility != null and n_visibility.level > 1 then
visibility_level = n_visibility.level
end
- process_and_check(v, _method, n_kwredef != null, visibility_level)
- if n_signature != null then n_signature.check_visibility(v, _method)
+ process_and_check(v, method, n_kwredef != null, visibility_level)
+ if n_signature != null then n_signature.check_visibility(v, method)
end
- redef meth accept_abs_syntax_visitor(v)
+ redef fun accept_abs_syntax_visitor(v)
do
- v.local_property = method
+ v.local_property = _method
super
v.local_property = null
end
end
redef class AMainMethPropdef
- redef meth process_and_check(v, prop, has_redef, visibility_level)
+ 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)
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 readable attr _prop: MMSrcTypeProperty
+ redef fun prop do return _prop.as(not null)
+ var _prop: nullable MMSrcTypeProperty
- redef meth accept_property_builder(v)
+ redef fun accept_property_builder(v)
do
super
var name = n_id.to_symbol
v.local_class.add_src_local_property(v, prop)
end
- redef meth accept_property_verifier(v)
+ 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)
- _prop.signature = signature
+ prop.signature = signature
var visibility_level = n_visibility.level
- process_and_check(v, _prop, n_kwredef != null, visibility_level)
+ process_and_check(v, prop, n_kwredef != null, visibility_level)
end
- redef meth accept_abs_syntax_visitor(v)
+ redef fun accept_abs_syntax_visitor(v)
do
- v.local_property = prop
+ v.local_property = _prop
super
v.local_property = null
end
# Visitor used to build a full method name from multiple tokens
private class MethidAccumulator
-special Visitor
- readable attr _name: String
- redef meth visit(n)
+ super Visitor
+ readable var _name: Buffer = new Buffer
+ redef fun visit(n)
do
if n isa Token then
_name.append(n.text)
n.visit_all(self)
end
end
-
- init
- do
- _name = new String
- end
end
-redef class PMethid
+redef class AMethid
# Method name
- readable attr _name: Symbol
+ readable var _name: nullable Symbol
- redef meth accept_property_builder(v)
+ redef fun accept_property_builder(v)
do
var accumulator = new MethidAccumulator
- accumulator.visit(self)
- _name = accumulator.name.to_symbol
+ accumulator.enter_visit(self)
+ _name = accumulator.name.to_s.to_symbol
super
end
end
-redef class PSignature
- # Check that visibilities of types in the signature are compatible with the visibility of the property.
- meth check_visibility(v: AbsSyntaxVisitor, p: MMLocalProperty) is abstract
-end
-
redef class ASignature
- redef meth accept_property_verifier(v)
+ redef fun accept_property_verifier(v)
do
super
- if not v.untyped_params.is_empty then
- if v.untyped_params.first != v.params.first or n_type != null then
- v.error(v.untyped_params.first, "Syntax error: untyped parameter.")
+ if v.signature_builder.has_error_occured then
+ return
+ else if not v.signature_builder.untyped_params.is_empty then
+ if v.signature_builder.untyped_params.first != v.signature_builder.params.first or n_type != null then
+ v.error(v.signature_builder.untyped_params.first, "Syntax error: untyped parameter.")
return
end
- else if not v.params.is_empty or n_type != null then
+ else if not v.signature_builder.params.is_empty or n_type != null then
var pars = new Array[MMType]
- for p in v.params do
- pars.add(p.stype)
+ for p in v.signature_builder.params do
+ pars.add(p.stype.as(not null))
end
- var ret: MMType = null
+ var ret: nullable MMType = null
if n_type != null then
ret = n_type.get_stype(v)
+ if ret == null then
+ v.signature_builder.has_error_occured = true
+ return
+ end
+ end
+ v.signature_builder.signature = new MMSignature(pars, ret, v.local_class.get_type)
+ if v.signature_builder.vararg_rank >= 0 then
+ v.signature_builder.signature.vararg_rank = v.signature_builder.vararg_rank
end
- v.signature = new MMSignature(pars, ret, v.local_class.get_type)
- if v.vararg_rank >= 0 then
- v.signature.vararg_rank = v.vararg_rank
+ for clos in v.signature_builder.closure_decls do
+ v.signature_builder.signature.closures.add(clos.variable.closure)
end
end
end
- redef meth 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 readable attr _position: Int
+redef class AParam
+ redef readable var _position: Int = 0
- redef readable attr _variable: Variable
+ redef fun variable: ParamVariable do return _variable.as(not null)
+ var _variable: nullable ParamVariable
# The type of the parameter in signature
- readable writable attr _stype: MMType
+ readable writable var _stype: nullable MMType
- redef meth accept_property_verifier(v)
+ redef fun accept_property_verifier(v)
do
super
- _position = v.params.length
- _variable = new Variable(n_id.to_symbol, self)
- v.params.add(self)
- v.untyped_params.add(self)
+ _position = v.signature_builder.params.length
+ _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
var stype = n_type.get_stype(v)
- for p in v.untyped_params do
+ if stype == null then
+ v.signature_builder.has_error_occured = true
+ return
+ end
+ for p in v.signature_builder.untyped_params do
p.stype = stype
if is_vararg then
- if v.vararg_rank == -1 then
- v.vararg_rank = p.position
+ if v.signature_builder.vararg_rank == -1 then
+ v.signature_builder.vararg_rank = p.position
else
v.error(self, "Error: A vararg parameter is already defined.")
end
- stype = v.type_array(stype)
+ stype = v.type_array(stype)
end
p.variable.stype = stype
end
- v.untyped_params.clear
+ v.signature_builder.untyped_params.clear
end
end
- meth is_vararg: Bool is abstract
+ fun is_vararg: Bool do return n_dotdotdot != null
end
-redef class AParam
- redef meth is_vararg do return n_dotdotdot != null
-end
+redef class AClosureDecl
+ redef readable var _position: Int = 0
-redef class PType
- # Check that visibilities of types in the signature are compatible with the visibility of the property.
- private meth check_visibility(v: AbsSyntaxVisitor, p: MMLocalProperty) is abstract
+ redef fun variable: ClosureVariable do return _variable.as(not null)
+ var _variable: nullable ClosureVariable
+
+ redef fun accept_property_verifier(v)
+ do
+ var old_signature_builder = v.signature_builder
+ v.signature_builder = new SignatureBuilder
+ super
+ if v.signature_builder.has_error_occured then
+ return
+ end
+ var sig = v.signature_builder.signature
+ if sig == null then
+ sig = new MMSignature(new Array[MMType], 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.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 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, n_id, clos)
+ end
end
redef class AType
- redef meth 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)
if t == null then return
var bc = t.local_class
- if bc == null then return
if bc.global.visibility_level >= 3 then
v.error(self, "Access error: Class {bc} is private and cannot be used in the signature of the non-private property {p}.")
end
end
end
-redef class PExpr
- redef meth accept_class_builder(v) do end
- redef meth accept_property_builder(v) do end
- redef meth accept_property_verifier(v) do end
+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
end
nitlanguage / nit.git / blobdiff