package mmbuilder
import syntax_base
+private import primitive_info
+
+redef class ToolContext
+ redef fun handle_property_conflict(lc, impls)
+ do
+ var location: nullable Location = null
+ if lc isa MMSrcLocalClass then
+ var node = lc.node
+ if node != null then node.location
+ end
+ #if location == null then location = lc.mmmodule.location
+ var clas = new Array[MMLocalClass]
+ for i in impls do
+ clas.add(i.local_class)
+ end
+ self.fatal_error(location, "Property inheritance conflict in class {lc} for `{impls.first.name}': conflicting properties are defined in {clas.join(", ")}")
+ end
+end
# Class specialization hierarchy sorter
private class CSHSorter
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_enum 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_extern and not c.global.is_interface then
c.process_default_constructors(mmbv2)
end
n = n.next_node
end
- for p in src_local_properties do
+ for p in src_local_properties.values do
p.accept_property_visitor(v)
end
end
var super_inits = new ArraySet[MMLocalProperty]
var super_constructors = new ArraySet[MMGlobalProperty]
for sc in che.direct_greaters do
- if sc.global.is_enum or sc.global.is_interface then continue
+ if sc.global.is_enum and not sc.global.is_extern 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)
# Collect unassigned attributes
var unassigned_attributes = new Array[MMSrcAttribute]
- for a in src_local_properties do
+ for a in src_local_properties.values do
if a isa MMSrcAttribute then
var n = a.node
if n.n_expr == null then unassigned_attributes.add(a)
end
_super_init = base
- var params = new Array[MMType]
+ var params = new Array[MMParam]
if base != null then
var sig = base.signature
for i in [0..sig.arity[ do
- params.add(sig[i])
+ params.add(sig.params[i])
end
end
for a in unassigned_attributes do
var sig = a.signature
if sig == null then return # Broken attribute definition
- params.add(sig.return_type.as(not null))
+ var name = a.name
+ if name.to_s.first == '_' or name.to_s.first == '@' then
+ name = a.to_s.substring_from(1).to_symbol
+ end
+ params.add(new MMParam(sig.return_type.as(not null), name))
end
signature = new MMSignature(params, null, local_class.get_type)
end
redef fun accept_class_builder(v)
do
if n_name.n_id.to_symbol != v.mmmodule.name then
- v.error(n_name.n_id, "Error: Module name missmatch between {v.mmmodule.name} and {n_name.n_id.to_symbol}")
+ v.error(n_name.n_id, "Error: Module name mismatch between {v.mmmodule.name} and {n_name.n_id.to_symbol}")
end
end
end
fun is_interface: Bool do return false
fun is_enum: Bool do return false
fun is_abstract: Bool do return false
+ fun is_extern : Bool do return false
end
redef class AInterfaceClasskind
redef class AEnumClasskind
redef fun is_enum do return true
end
+redef class AExternClasskind
+ redef fun is_extern do return true
+end
redef class AAbstractClasskind
redef fun is_abstract do return true
end
do
return n_formaldefs.length
end
+ redef fun accept_class_specialization_builder(v)
+ do
+ super
+
+ var glob = local_class.global
+ if glob.intro == local_class then
+ glob.is_interface = n_classkind.is_interface
+ glob.is_abstract = n_classkind.is_abstract
+ glob.is_enum = n_classkind.is_enum
+ glob.is_extern = n_classkind.is_extern
+ glob.visibility_level = visibility_level
+ end
+ end
+ redef fun accept_class_verifier(v)
+ do
+ super
+ var glob = _local_class.global
+ if glob.intro == _local_class then
+ # Intro
+ 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
+ if glob.is_extern then
+ glob.mmmodule.is_extern_hybrid = true
+ end
+
+ 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 glob.is_extern then
+ if not cg.is_interface and not cg.is_extern then
+ v.error(self, "Special error: Extern 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}.")
+ else if cg.is_extern then
+ v.error(self, "Special error: Class {name} try to specialise extern 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 mismatch; got {_local_class.arity}, expected {glob.intro.arity}.")
+ end
+
+ if
+ not glob.is_interface and n_classkind.is_interface or
+ not glob.is_abstract and n_classkind.is_abstract or
+ not glob.is_enum and n_classkind.is_enum or
+ not glob.is_extern and n_classkind.is_extern
+ then
+ v.error(self, "Redef error: cannot change kind of class {name}.")
+ end
+ end
redef fun visibility_level
do
v.error(self, "Error: Attempt to define attribute {prop} in the interface {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}.")
+ else if gbc.is_extern then
+ v.error(self, "Error: Attempt to define attribute {prop} in the extern class {prop.local_class}.")
end
else if glob.is_init then
if gbc.is_interface then
else if gbc.is_enum then
v.error(self, "Error: Attempt to define a constructor {prop} in the enum {prop.local_class}.")
end
+
+ # ok in extern
end
if prop.signature == null then
if glob.is_init then
else if not v.signature_builder.untyped_params.is_empty then
v.error(v.signature_builder.untyped_params.first, "Error: Untyped parameter.")
else
- prop.signature = new MMSignature(new Array[MMType], null, v.local_class.get_type)
+ prop.signature = new MMSignature(new Array[MMParam], null, v.local_class.get_type)
for clos in v.signature_builder.closure_decls do
prop.signature.closures.add(clos.variable.closure)
end
# 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 is_init = self isa AInitPropdef
var glob = prop.global
if not has_redef then
t = v.type_array(t)
end
p.variable.stype = t
+
+ isig.params[p.position].name = p.variable.name
end
s = isig
prop.signature = 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}.")
+ else if s.arity > 0 then
+ if self isa AMethPropdef then
+ # A standard method
+ for j in [0..s.arity[ do
+ if s[j] != isig[j] then
+ v.error(n_signature.n_params[j], "Redef error: Expected {isig[j]}, as in {ip.local_class}::{ip}.")
+ end
end
+ else if self isa AAttrPropdef then
+ # A write accessor
+ if s[0] != isig[0] then
+ v.error(n_type, "Redef error: Expected {isig[0]}, as in the parameter of {ip.local_class}::{ip}.")
+ end
+
+ else
+ abort #
end
end
else if srt != null and isrt == null then
v.error(self, "Redef error: The function {prop.local_class}::{prop} redefines the procedure {ip.local_class}::{ip}.")
else if srt != null and isrt != null and not srt < isrt then
- v.error(self, "Redef error: Expected {isrt} (as in {ip.local_class}::{ip}), got {srt} in {prop.local_class}::{prop}.")
+ var n: nullable ANode = null
+ if self isa AMethPropdef then
+ n = self.n_signature.n_type
+ else if self isa AAttrPropdef then
+ n = self.n_type
+ else if self isa ATypePropdef then
+ n = self.n_type
+ end
+ v.error(n, "Redef error: Expected {isrt}, as in {ip.local_class}::{ip}.")
else if not s < isig and nberr == v.tc.error_count then
# Systematic fallback for conformance check
v.error(self, "Redef error: Incompatible redefinition of {ip.local_class}::{ip} with {prop.local_class}::{prop}")
else if srt != null and isrt != null and srt != isrt and prop isa MMAttribute then
# FIXME: To remove
- v.warning(self, "Redef warning: Expected {isrt} (as in {ip.local_class}::{ip}), got {srt} in {prop.local_class}::{prop}.")
+ v.warning(self, "Redef warning: Expected {isrt}, as in {ip.local_class}::{ip}.")
end
end
redef fun accept_property_verifier(v)
do
super
- var t: MMType
+ var t: nullable MMType = null
if n_type != null then
var t0 = n_type.get_stype(v)
if t0 != null then t = t0 else return
- else
+ else if n_expr != null then
+ t = n_expr.get_easy_stype(v)
+ end
+
+ if t == null then
v.error(self, "Not yet implemented: Attribute definition {prop.local_class}::{prop} requires an explicit type.")
return
end
var prop = prop
- var signature = new MMSignature(new Array[MMType], t, v.local_class.get_type)
+ var signature = new MMSignature(new Array[MMParam], t, v.local_class.get_type)
prop.signature = signature
var visibility_level = n_visibility.level
process_and_check(v, prop, n_id != null and n_kwredef != null, visibility_level)
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)
+ if n_type != null then n_type.check_visibility(v, m)
end
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)
+ m.signature = new MMSignature(new Array[MMParam].with_items(new MMParam(t, once "value".to_symbol)), null, v.local_class.get_type)
var vl = visibility_level
if n_id == null then
if n_writable == null then vl = 3 else vl = n_writable.n_visibility.level # write accessor has a specific visibility
end
process_and_check(v, m, n_writable != null and n_writable.n_kwredef != null, vl)
- n_type.check_visibility(v, m)
+ if n_type != null then n_type.check_visibility(v, m)
end
end
super
var name: Symbol
if n_methid == null then
- if self isa AConcreteInitPropdef then
+ if self isa AInitPropdef then
name = once "init".to_symbol
else
name = once "main".to_symbol
redef fun process_and_check(v, prop, has_redef, visibility_level)
do
prop.global.visibility_level = visibility_level
- prop.signature = new MMSignature(new Array[MMType], null, v.local_class.get_type)
+ prop.signature = new MMSignature(new Array[MMParam], null, v.local_class.get_type)
# Disable all checks for main
end
end
-redef class AExternMethPropdef
+redef class AExternPropdef
redef fun accept_property_verifier(v)
do
super # Compute signature
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}"
+ ename = method.default_extern_name
end
method.extern_name = ename
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)
+ var signature = new MMSignature(new Array[MMParam], n_type.get_stype(v), v.local_class.get_type)
prop.signature = signature
var visibility_level = n_visibility.level
process_and_check(v, prop, n_kwredef != null, visibility_level)
end
redef class AMethid
- # Method name
- readable var _name: nullable Symbol
+ redef readable var _name: nullable Symbol
redef fun accept_property_builder(v)
do
return
end
else if not v.signature_builder.params.is_empty or n_type != null then
- var pars = new Array[MMType]
+ var pars = new Array[MMParam]
for p in v.signature_builder.params do
- pars.add(p.stype.as(not null))
+ pars.add( new MMParam( p.stype.as(not null), p.n_id.to_symbol ) )
end
var ret: nullable MMType = null
if n_type != null then
end
var sig = v.signature_builder.signature
if sig == null then
- sig = new MMSignature(new Array[MMType], null, v.local_class.get_type)
+ sig = new MMSignature(new Array[MMParam], null, v.local_class.get_type)
end
if sig.return_type != null and n_kwbreak != null then
v.error(self, "Syntax Error: A break block cannot have a return value.")
end
# Add the finalizer to the closure signature
- var finalize_sig = new MMSignature(new Array[MMType], null, v.mmmodule.type_any) # FIXME should be no receiver
+ var finalize_sig = new MMSignature(new Array[MMParam], null, v.mmmodule.type_any) # FIXME should be no receiver
var finalizer_clos = new MMClosure(once ("break".to_symbol), finalize_sig, false, true)
sig.closures.add(finalizer_clos)
redef fun accept_class_builder(v) do end
redef fun accept_property_builder(v) do end
redef fun accept_property_verifier(v) do end
+
+ private fun get_easy_stype(v:PropertyVerifierVisitor) : nullable MMType do return null
+end
+
+redef class ABoolExpr
+ redef fun get_easy_stype(v) do return v.type_bool
+end
+
+redef class AStringExpr
+ redef fun get_easy_stype(v) do return v.type_string
+end
+
+redef class ACharExpr
+ redef fun get_easy_stype(v) do return v.type_char
+end
+
+redef class AIntExpr
+ redef fun get_easy_stype(v) do return v.type_int
+end
+
+redef class AFloatExpr
+ redef fun get_easy_stype(v) do return v.type_float
+end
+
+redef class ANewExpr
+ redef fun get_easy_stype(v) do return n_type.get_stype(v)
end
nitlanguage / nit.git / blobdiff