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
# 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)
# 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 no_import: nullable AImport = null
for i in n_imports do
var n = i.module_name
if n != null then
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
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
var local_classes = mod.src_local_classes
if (local_classes.has_key(name)) then
local_class = local_classes[name]
- if self isa AClassdef then
+ 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
end
-redef class PClasskind
+redef class AClasskind
fun is_interface: Bool do return false
fun is_universal: Bool do return false
fun is_abstract: Bool do return false
redef fun is_abstract do return true
end
-redef class AClassdef
+redef class AStdClassdef
redef fun name
do
return n_id.to_symbol
end
end
-redef class PPropdef
+redef class APropdef
# Process and check properties of the property.
# * Distinguish inits and methods
# * Inherit or check visibility.
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
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
# 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
end
end
-redef class PMethid
+redef class AMethid
# Method name
readable var _name: nullable Symbol
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
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
# 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 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
nitlanguage / nit.git / blobdiff