X-Git-Url: http://nitlanguage.org diff --git a/src/syntax/mmbuilder.nit b/src/syntax/mmbuilder.nit deleted file mode 100644 index 78ce89b..0000000 --- a/src/syntax/mmbuilder.nit +++ /dev/null @@ -1,1274 +0,0 @@ -# This file is part of NIT ( http://www.nitlanguage.org ). -# -# Copyright 2008 Jean Privat -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -# Build MM entity from NIT AST and check conformance of these entities. -# This module introduce specific MM class (MMSrcXXX) that specialize the abstract one from metamodel -# -package mmbuilder - -import syntax_base - -# Class specialization hierarchy sorter -private class CSHSorter -special AbstractSorter[MMLocalClass] - redef fun compare(a, b) - do - return a.cshe.rank <=> b.cshe.rank - end - - init do end -end - -redef class MMSrcModule - # Syntax analysis and MM construction for the module - # Require that supermodules are processed - 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.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.enter_visit(node) - tc.check_errors - - # Compute specialization relation - for c in local_classes do - 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 - # Note that leaves invisible classes are not in the 'classes' set - var classes = class_specialization_hierarchy.to_a - - # Prepare class list to process the following in a right order - var sorter = once new CSHSorter - sorter.sort(classes) - - # Compute class ancestors types - var mmbv1b = new ClassAncestorBuilder(tc, self) - for c in classes do - c.accept_class_visitor(mmbv1b) - tc.check_errors - c.compute_ancestors - end - - # Check class conformity - var mmbv1c = new ClassVerifierVisitor(tc, self) - for c in classes do - c.accept_class_visitor(mmbv1c) - end - tc.check_errors - - # Property inhritance and introduction - var mmbv2 = new PropertyBuilderVisitor(tc, self) - for c in classes do - # 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 - c.process_default_constructors(mmbv2) - end - - # Note that inherited unredefined property are processed on demand latter - end - tc.check_errors - - # Property signature analysis and inheritance conformance - var mmbv3 = new PropertyVerifierVisitor(tc, self) - for c in classes do - c.accept_properties_visitor(mmbv3) - end - - tc.check_errors - end - - # 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 fun accept_class_visitor(v: AbsSyntaxVisitor) - do - end - - # Accept a class visitor (on class properties) - private fun accept_properties_visitor(v: AbsSyntaxVisitor) - do - end -end - -redef class MMSrcLocalClass - redef fun accept_class_visitor(v) - 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 - var n = node - while n != null do - v.enter_visit(n) - n = n.next_node - end - - for p in src_local_properties do - p.accept_property_visitor(v) - end - end - - # Introduce or inherit default constructors - private fun process_default_constructors(v: PropertyBuilderVisitor) - do - # Is there already a constructor ? - for gp in global_properties do - if gp.is_init then - # Return if explicit constructor in the class - if gp.intro.local_class == self then return - end - 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 - 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 - # Select most specific classes introducing inheritable constructors - # Mixin classes are skipped - var supers = new Array[MMLocalClass] - for gp in super_constructors do - var sc = gp.local_class - if supers.has(sc) then continue - 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: nullable MMLocalClass = null # This most specific non-mixin superclass (if any) - - if supers.length > 1 then - 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 - - for gp in super_constructors do - # Inherit constructors : the one of the non-mixin super class or all from the all mixin super-classes - if superclass == null or gp.local_class == superclass then - make_visible_an_inherited_global_property(gp) - end - end - 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 fun add_src_local_property(v: PropertyBuilderVisitor, prop: MMLocalProperty) - do - var pname = prop.name - # Check double definition in the same class - if src_local_properties.has_key(pname) then - v.error(prop.node, "Error: A property {pname} is already defined in class {name}.") - return - end - src_local_properties[pname] = prop - - # Intro or redefinition ? - if has_global_property_by_name(pname) then - var g = get_property_by_name(pname) - prop.inherit_global(g) - end - - if not prop.is_global_set then - prop.new_global - prop.global.is_init = prop.is_init - end - end -end - -redef class MMLocalProperty - 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 - redef readable var _local_class: MMLocalClass - - init(c: MMLocalClass) - do - _local_class = c - end -end - -############################################################################### - -# A pass visitor for syntax analysis. -# * Build the classes and attach them to global classes -# * Collect generic formal parameters. -private class ClassBuilderVisitor -special AbsSyntaxVisitor - # Current class arity - readable writable var _local_class_arity: Int = 0 - - # Current class formal parameters - readable writable var _formals: nullable Map[Symbol, MMTypeFormalParameter] - - 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 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 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 fun visit(n) do n.accept_class_verifier(self) - init(tc, m) do super -end - - -# Another pass visitor for syntax analysis. -# * Build propertie names -# * Build local properties and attache them to global properties -# * Attach bound to formal types -private class PropertyBuilderVisitor -special 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 - - # 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 var _params: Array[AParam] = new Array[AParam] - - # Visited parameters without type information added - readable writable var _untyped_params: Array[AParam] = new Array[AParam] - - # Position of the current star parameter - readable writable var _vararg_rank: Int = -1 - - # Current closure declarations - readable writable var _closure_decls: Array[AClosureDecl] = new Array[AClosureDecl] - - # True is a problen occured durring building - readable writable var _has_error_occured: Bool = false - - # Current signature - readable writable var _signature: nullable MMSignature = null -end - -############################################################################### - -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 - 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 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 - else - no_import = i - end - end - if no_import != null then - if not module_names_to_import.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 - var stdname = once "standard".to_symbol - module_names_to_import.add(stdname) - module_visibility[stdname] = 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 - end -end - -redef class AModuledecl - redef fun accept_class_builder(v) - do - if n_id.to_symbol != v.mmmodule.name then - v.error(n_id, "Error: Package name missmatch between {v.mmmodule.name} and {n_id.to_symbol}") - end - end -end - -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 AStdImport - redef fun module_name - do - return n_id.to_symbol - end - redef fun visibility_level - do - return n_visibility.level - end -end -redef class ANoImport - redef fun module_name - do - return null - end -end - -redef class AVisibility - # Visibility level - fun level: Int is abstract -end -redef class APublicVisibility - redef fun level do return 1 -end -redef class AProtectedVisibility - redef fun level do return 2 -end -redef class APrivateVisibility - redef fun level do return 3 -end -redef class AIntrudeVisibility - redef fun level do return 0 -end - - -redef class AClassdef - redef fun local_class: MMSrcLocalClass do return _local_class.as(not null) - var _local_class: nullable MMSrcLocalClass - - # Name of the class - fun name: Symbol is abstract - - # Number of formal parameters - fun arity: Int do return 0 - - # Visibility of the class - fun visibility_level: Int do return 1 - - redef fun accept_class_builder(v) - do - var local_class: MMSrcLocalClass - 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 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.node.location.line_start}.") - return - end - # 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_classes[name] = local_class - if not mod.has_global_class_named(name) then - local_class.new_global - else - local_class.set_global(mod.global_class_named(name)) - end - - end - _local_class = local_class - v.local_class_arity = 0 - v.formals = local_class.formal_dict - - ##### - super - ##### - - v.formals = null - 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_universal: 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 -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 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 - 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}.") - 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 - end - - # Redef - - 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}.") - 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 - then - v.error(self, "Redef error: cannot change kind of class {name}.") - end - end - - redef fun visibility_level - do - return n_visibility.level - end -end - -redef class AMainClassdef - redef fun name - do - return once "Sys".to_symbol - end -end - -redef class ATopClassdef - redef fun name - do - return once "Object".to_symbol - end -end - -redef class AFormaldef - # The associated formal generic parameter (MM entity) - var _formal: nullable MMTypeFormalParameter - - redef fun accept_class_builder(v) - do - var name = n_id.to_symbol - 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) - v.formals[name] = formal_type - super - end - - 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.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.mmmodule) - if n_type == null then - _formal.bound = ob - else - 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 - end - end -end - -redef class ASuperclass - readable var _ancestor: nullable MMSrcAncestor - - redef fun accept_class_specialization_builder(v) - do - super - var c = n_type.get_local_class(v) - if c == null then return - var ancestor = new MMSrcAncestor(c) - _ancestor = ancestor - v.local_class.add_direct_parent(ancestor) - end - - 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 fun accept_class_verifier(v) - do - super - n_type.check_conform(v) - end -end - -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 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) - else - do_and_check_redef(v, prop, has_redef, visibility_level) - end - end - - # The part of process_and_check when prop is an introduction - 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 v.local_class.global.visibility_level >= 3 then - # Method of private classes are private - visibility_level = 3 - end - glob.visibility_level = visibility_level - if has_redef then - v.error(self, "Error: No property {prop.local_class}::{prop} is inherited. Remove the redef keyword to define a new property.") - end - 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}.") - 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}.") - end - end - if prop.signature == null then - if glob.is_init then - var supers = prop.local_class.super_methods_named(prop.name) - inherit_signature(v, prop, supers) - end - if prop.signature != null or v.signature_builder.has_error_occured then - # ok - 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 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.signature_builder.params.length != isig.arity then - 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 - t = v.type_array(t) - end - p.variable.stype = t - end - - s = isig - prop.signature = s - end - end - end - - # The part of process_and_check when prop is a redefinition - 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 - - if not has_redef then - v.error(self, "Redef error: {prop.local_class}::{prop} is an inherited property. To redefine it, add the redef keyword.") - return - end - if glob.is_init and not is_init then - v.error(self, "Redef error: A method {prop.local_class}::{prop} cannot redefine a constructor.") - else if not glob.is_init and is_init then - v.error(self, "Redef error: A constructor {prop.local_class}::{prop} cannot redefine a method.") - end - - var s = prop.signature - #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 s == null then - #print "{prop.full_name} inherits signature from {ip.full_name}" - 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 - 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 - t = v.type_array(t) - end - p.variable.stype = t - 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 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 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 - - var srt = s.return_type - var isrt = isig.return_type - if srt == null and isrt != null then - v.error(self, "Redef error: The procedure {prop.local_class}::{prop} redefines the function {ip.local_class}::{ip}.") - 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}.") - 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}.") - 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.mmmodule, true) - end -end - -redef class AAttrPropdef - 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 fun accept_property_builder(v) - do - super - var name = n_id.to_symbol - 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 - 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 - var writemethod = new MMWriteImplementationMethod(name, lc, self) - _writemethod = writemethod - v.local_class.add_src_local_property(v, writemethod) - end - end - - redef fun accept_property_verifier(v) - do - super - var t: MMType - if n_type != null then - 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.") - return - end - - var prop = prop - 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 - var m = _readmethod.as(not null) - m.signature = signature - process_and_check(v, m, n_readable.n_kwredef != null, visibility_level) - n_type.check_visibility(v, m) - end - if n_writable != 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) - n_type.check_visibility(v, m) - end - end - - redef fun accept_abs_syntax_visitor(v) - do - v.local_property = _prop - super - v.local_property = null - end -end - -redef class AMethPropdef - # Name of the method - readable var _name: nullable Symbol - - var _method: nullable MMMethSrcMethod - redef fun method do return _method.as(not null) - - 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 - else - name = once "main".to_symbol - end - 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 != null and ns.n_params.length == 0 then - name = once "unary -".to_symbol - end - end - end - _name = name - var prop = new MMMethSrcMethod(name, v.local_class, self) - _method = prop - v.local_class.add_src_local_property(v, prop) - end - - redef fun accept_property_verifier(v) - do - v.signature_builder = new SignatureBuilder - super - - 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_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) - end - - redef fun accept_abs_syntax_visitor(v) - do - v.local_property = _method - super - v.local_property = null - end -end - -redef class AMainMethPropdef - 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) - # 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_builder(v) - do - super - var name = n_id.to_symbol - var prop = new MMSrcTypeProperty(name, v.local_class, self) - _prop = prop - v.local_class.add_src_local_property(v, prop) - end - - 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 - var visibility_level = n_visibility.level - process_and_check(v, prop, n_kwredef != null, visibility_level) - end - - redef fun accept_abs_syntax_visitor(v) - do - v.local_property = _prop - super - v.local_property = null - end -end - -# Visitor used to build a full method name from multiple tokens -private class MethidAccumulator -special Visitor - readable var _name: Buffer = new Buffer - redef fun visit(n) - do - if n isa Token then - _name.append(n.text) - else - n.visit_all(self) - end - end -end - -redef class AMethid - # Method name - readable var _name: nullable Symbol - - redef fun accept_property_builder(v) - do - var accumulator = new MethidAccumulator - accumulator.enter_visit(self) - _name = accumulator.name.to_s.to_symbol - super - end -end - -redef class ASignature - redef fun accept_property_verifier(v) - do - super - 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.signature_builder.params.is_empty or n_type != null then - var pars = new Array[MMType] - for p in v.signature_builder.params do - pars.add(p.stype.as(not null)) - end - 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 - for clos in v.signature_builder.closure_decls do - v.signature_builder.signature.closures.add(clos.variable.closure) - end - end - end - - # 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 - if n.n_type != null then n.n_type.check_visibility(v, p) - end - if n_type != null then n_type.check_visibility(v, p) - end -end - -redef class AParam - redef readable var _position: Int = 0 - - redef fun variable: ParamVariable do return _variable.as(not null) - var _variable: nullable ParamVariable - - # The type of the parameter in signature - readable writable var _stype: nullable MMType - - redef fun accept_property_verifier(v) - do - super - _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) - 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.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) - end - p.variable.stype = stype - end - v.signature_builder.untyped_params.clear - end - end - - fun is_vararg: Bool do return n_dotdotdot != null -end - -redef class AClosureDecl - redef readable var _position: Int = 0 - - 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 - # 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.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 - for n in n_types do - n.check_visibility(v, p) - end - end -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