if vpm == 3 then
return true
else if vpm == 0 then
- v.error(n, "Visibility error: Class {self} comes from the hidden module {cm}.") # TODO: should not occur
+ v.error(n, "Visibility error: Class {self} comes from the hidden module {pm}.") # TODO: should not occur
return false
else if visibility_level >= 3 then
v.error(n, "Visibility error: Class {self} is private.")
return true
else if vpm == 0 then
# TODO: should not occurs
- v.error(n, "Visibility error: Property {self} comes from the hidden module {cm}.")
+ v.error(n, "Visibility error: Property {self} comes from the hidden module {pm}.")
return false
else if visibility_level >= 3 then
v.error(n, "Visibility error: Property {self} is private.")
end
# Concrete NIT source method
-class MMSrcMethod
+abstract class MMSrcMethod
super MMMethod
redef fun is_intern do return false
+ redef fun is_extern do return false
redef fun is_abstract do return false
redef fun extern_name do return null
end
# Concrete NIT source method for an automatic accesor
-class MMAttrImplementationMethod
+abstract class MMAttrImplementationMethod
super MMSrcMethod
redef fun node: nullable AAttrPropdef do return mmmodule.nodes(self).as(nullable AAttrPropdef)
init(name: Symbol, cla: MMLocalClass, n: AAttrPropdef)
super MMSrcMethod
redef readable var _is_init: Bool
redef readable var _is_intern: Bool
+ redef readable var _is_extern: Bool
redef readable var _is_abstract: Bool
redef readable writable var _extern_name: nullable String # Will be computed during MMBuilder
+ redef readable var _explicit_casts : Set[MMImportedCast] = new HashSet[MMImportedCast]
+ redef readable var _explicit_imports : Set[MMExplicitImport] = new HashSet[MMExplicitImport]
redef fun node: nullable AMethPropdef do return mmmodule.nodes(self).as(nullable AMethPropdef)
init(name: Symbol, cla: MMLocalClass, n: nullable AMethPropdef)
do
super(name, cla)
cla.mmmodule.nodes(self) = n
- _is_init = node isa AConcreteInitPropdef
+ _is_init = node isa AInitPropdef
_is_intern = node isa AInternMethPropdef
+ _is_extern = node isa AExternPropdef
_is_abstract = node isa ADeferredMethPropdef
_extern_name = null
+
+ if is_extern then
+ mmmodule.is_extern_hybrid = true
+ end
end
end
###############################################################################
# Visitor used during the syntax analysis
-class AbsSyntaxVisitor
+abstract class AbsSyntaxVisitor
super Visitor
fun get_type_by_name(clsname: Symbol): MMType
do
fun stype: MMType is abstract
end
-class AAbsAbsSendExpr
+abstract class AAbsAbsSendExpr
super AExpr
# The signature of the called property (require is_typed)
fun prop_signature: MMSignature is abstract
fun raw_arguments: Array[AExpr] is abstract
end
-class AAbsSendExpr
+abstract class AAbsSendExpr
super AAbsAbsSendExpr
# The invoked method (require is_typed)
fun prop: MMMethod is abstract
fun return_type: nullable MMType is abstract
end
-class ASuperInitCall
+abstract class ASuperInitCall
super AAbsSendExpr
end
fun assign_method: MMMethod is abstract
end
-class ASendReassignExpr
+abstract class ASendReassignExpr
super ASendExpr
super AReassignFormExpr
# The invoked method used to read (require is_typed)
# Name of method
fun name: nullable Symbol is abstract
end
+
+redef class AExprs
+ # Return an array made of each expr
+ fun to_a: Array[AExpr] do return self.n_exprs.to_a
+end