X-Git-Url: http://nitlanguage.org diff --git a/src/syntax/typing.nit b/src/syntax/typing.nit index cdb4378..379c7f0 100644 --- a/src/syntax/typing.nit +++ b/src/syntax/typing.nit @@ -18,8 +18,8 @@ package typing import syntax_base -import escape -import control_flow +import flow +import scope redef class MMSrcModule # Walk trough the module and type statments and expressions @@ -37,22 +37,44 @@ end # * Resolve call and attribute access # * Check type conformance private class TypingVisitor -special AbsSyntaxVisitor + super AbsSyntaxVisitor redef fun visit(n) do if n != null then n.accept_typing(self) end - # Current knowledge about variables names and types - fun variable_ctx: VariableContext do return _variable_ctx.as(not null) - writable var _variable_ctx: nullable VariableContext + # Current knowledge about scoped things (variable, labels, etc.) + readable var _scope_ctx: ScopeContext = new ScopeContext(self) - # Non-bypassable knowledge about variables names and types - fun base_variable_ctx: VariableContext do return _base_variable_ctx.as(not null) - writable var _base_variable_ctx: nullable VariableContext + # Current knowledge about control flow + fun flow_ctx: FlowContext do return _flow_ctx.as(not null) + writable var _flow_ctx: nullable FlowContext + + # Mark a local variable as set + fun mark_is_set(va: Variable) + do + if flow_ctx.is_set(va) then return + flow_ctx = flow_ctx.sub_setvariable(va) + end - # Current knowledge about escapable blocks - readable writable var _escapable_ctx: EscapableContext = new EscapableContext(self) + # Mark the flow context as unreashable + fun mark_unreash(n: ANode) + do + flow_ctx = flow_ctx.sub_unreash(n) + end + + # Enter in an expression as inside a new local variable scope + fun enter_visit_block(node: nullable AExpr) + do + if node == null then return + scope_ctx.push(node) + enter_visit(node) + scope_ctx.pop + end + + # Non-bypassable knowledge about variables names and types + fun base_flow_ctx: FlowContext do return _base_flow_ctx.as(not null) + writable var _base_flow_ctx: nullable FlowContext # The current reciever fun self_var: ParamVariable do return _self_var.as(not null) @@ -67,24 +89,27 @@ special AbsSyntaxVisitor # Is a other constructor of the same class invoked readable writable var _explicit_other_init_call: Bool = false - # Make the if_true_variable_ctx of the expression effective - private fun use_if_true_variable_ctx(e: AExpr) + # Make the if_true_flow_ctx of the expression effective + private fun use_if_true_flow_ctx(e: AExpr) do - var ctx = e.if_true_variable_ctx - if ctx != null then variable_ctx = ctx + var ctx = e.if_true_flow_ctx + if ctx != null then flow_ctx = ctx end - # Make the if_false_variable_ctx of the expression effective - private fun use_if_false_variable_ctx(e: AExpr) + # Make the if_false_flow_ctx of the expression effective + private fun use_if_false_flow_ctx(e: AExpr) do - var ctx = e.if_false_variable_ctx - if ctx != null then variable_ctx = ctx + var ctx = e.if_false_flow_ctx + if ctx != null then flow_ctx = ctx end + # Are we inside a default closure definition ? + readable writable var _is_default_closure_definition: Bool = false + # Number of nested once readable writable var _once_count: Int = 0 - init(tc, module) do super + init(tc, mod) do super private fun get_default_constructor_for(n: ANode, c: MMLocalClass, prop: MMSrcMethod): nullable MMMethod do @@ -118,14 +143,14 @@ special AbsSyntaxVisitor else if candidates.length > 0 then var a = new Array[String] for p in candidates do - a.add("{p.full_name}{p.signature}") + a.add("{p.full_name}{p.signature.as(not null)}") end v.error(n, "Error: Conflicting default constructor to call for {c}: {a.join(", ")}.") return null else if false_candidates.length > 0 then var a = new Array[String] for p in false_candidates do - a.add("{p.full_name}{p.signature}") + a.add("{p.full_name}{p.signature.as(not null)}") end v.error(n, "Error: there is no available compatible constrctor in {c}. Discarded candidates are {a.join(", ")}.") return null @@ -151,8 +176,6 @@ end redef class AClassdef redef fun accept_typing(v) do - v.variable_ctx = new RootVariableContext(v, self) - v.base_variable_ctx = v.variable_ctx v.self_var = new ParamVariable("self".to_symbol, self) v.self_var.stype = local_class.get_type super @@ -167,25 +190,29 @@ end redef class AAttrPropdef redef fun accept_typing(v) do - var old_var_ctx = v.variable_ctx - v.variable_ctx = old_var_ctx.sub(self) + v.flow_ctx = new RootFlowContext(v, self) + v.base_flow_ctx = v.flow_ctx + + v.scope_ctx.push(self) _self_var = v.self_var super if n_expr != null then v.check_conform_expr(n_expr.as(not null), prop.signature.return_type.as(not null)) end - v.variable_ctx = old_var_ctx + v.scope_ctx.pop end end redef class AMethPropdef redef fun accept_typing(v) do - var old_var_ctx = v.variable_ctx - v.variable_ctx = old_var_ctx.sub(self) + v.flow_ctx = new RootFlowContext(v, self) + v.base_flow_ctx = v.flow_ctx + + v.scope_ctx.push(self) _self_var = v.self_var super - v.variable_ctx = old_var_ctx + v.scope_ctx.pop end end @@ -193,7 +220,7 @@ redef class AConcreteMethPropdef redef fun after_typing(v) do super - if v.variable_ctx.unreash == false and method.signature.return_type != null then + if not v.flow_ctx.unreash and method.signature.return_type != null then v.error(self, "Control error: Reached end of function (a 'return' with a value was expected).") end end @@ -220,12 +247,12 @@ redef class AConcreteInitPropdef var cur_c: nullable MMLocalClass = null if i < l then cur_m = explicit_super_init_calls[i] - cur_c = cur_m.global.intro.local_class.for_module(v.module) + cur_c = cur_m.global.intro.local_class.for_module(v.mmmodule) end var j = 0 while j < v.local_class.cshe.direct_greaters.length do var c = v.local_class.cshe.direct_greaters[j] - if c.global.is_interface or c.global.is_universal or c.global.is_mixin then + if c.global.is_interface or c.global.is_enum or c.global.is_mixin then j += 1 else if cur_c != null and (c.cshe <= cur_c or cur_c.global.is_mixin) then if c == cur_c then j += 1 @@ -233,7 +260,7 @@ redef class AConcreteInitPropdef i += 1 if i < l then cur_m = explicit_super_init_calls[i] - cur_c = cur_m.global.intro.local_class.for_module(v.module) + cur_c = cur_m.global.intro.local_class.for_module(v.mmmodule) else cur_m = null cur_c = null @@ -253,7 +280,7 @@ end redef class AParam redef fun after_typing(v) do - v.variable_ctx.add(variable) + v.scope_ctx.add_variable(variable) end end @@ -264,33 +291,41 @@ redef class AClosureDecl redef fun accept_typing(v) do # Register the closure for ClosureCallExpr - v.variable_ctx.add(variable) + v.scope_ctx.add_variable(variable) - var old_var_ctx = v.variable_ctx - var old_base_var_ctx = v.base_variable_ctx - v.base_variable_ctx = v.variable_ctx - v.variable_ctx = v.variable_ctx.sub(self) + var old_flow_ctx = v.flow_ctx + var old_base_flow_ctx = v.base_flow_ctx + v.base_flow_ctx = v.flow_ctx - var escapable = new EscapableClosure(self, variable.closure, null) + var blist: nullable Array[AExpr] = null + var t = v.local_property.signature.return_type + if t != null then blist = new Array[AExpr] + var escapable = new EscapableClosure(self, variable.closure, blist) _escapable = escapable - v.escapable_ctx.push(escapable) + v.scope_ctx.push_escapable(escapable, null) + + v.is_default_closure_definition = true super + v.is_default_closure_definition = false + if n_expr != null then - if v.variable_ctx.unreash == false then + if v.flow_ctx.unreash == false then if variable.closure.signature.return_type != null then v.error(self, "Control error: Reached end of block (a 'continue' with a value was expected).") - else if variable.closure.is_break then - v.error(self, "Control error: Reached end of break block (an 'abort' was expected).") + else if variable.closure.is_break and escapable.break_list != null then + v.error(self, "Control error: Reached end of break block (a 'break' with a value was expected).") end end end + if blist != null then for x in blist do + v.check_conform_expr(x, t) + end - old_var_ctx.merge(v.variable_ctx) - v.variable_ctx = old_var_ctx - v.base_variable_ctx = old_base_var_ctx - v.escapable_ctx.pop + v.flow_ctx = old_flow_ctx + v.base_flow_ctx = old_base_flow_ctx + v.scope_ctx.pop end end @@ -337,11 +372,11 @@ redef class AExpr # The variable accessed is any fun its_variable: nullable Variable do return null - # The variable type information if current boolean expression is true - readable private var _if_true_variable_ctx: nullable VariableContext + # The control flow information if current boolean expression is true + readable private var _if_true_flow_ctx: nullable FlowContext - # The variable type information if current boolean expression is false - readable private var _if_false_variable_ctx: nullable VariableContext + # The control flow information if current boolean expression is false + readable private var _if_false_flow_ctx: nullable FlowContext end redef class AVardeclExpr @@ -350,20 +385,23 @@ redef class AVardeclExpr redef fun after_typing(v) do - var va = new VarVariable(n_id.to_symbol, self) + var va = new VarVariable(n_id.to_symbol, n_id) _variable = va - v.variable_ctx.add(va) - if n_expr != null then v.variable_ctx.mark_is_set(va) + v.scope_ctx.add_variable(va) + var ne = n_expr + if ne != null then v.mark_is_set(va) if n_type != null then if not n_type.is_typed then return va.stype = n_type.stype - if n_expr != null then - v.check_conform_expr(n_expr.as(not null), va.stype) + if ne != null then + v.check_conform_expr(ne, va.stype) end + else if ne != null then + if not v.check_expr(ne) then return + va.stype = ne.stype else - if not v.check_expr(n_expr.as(not null)) then return - va.stype = n_expr.stype + va.stype = v.type_object.as_nullable end _is_typed = true end @@ -372,19 +410,15 @@ end redef class ABlockExpr redef fun accept_typing(v) do - var old_var_ctx = v.variable_ctx - v.variable_ctx = v.variable_ctx.sub(self) - for e in n_expr do - if v.variable_ctx.unreash and not v.variable_ctx.already_unreash then - v.variable_ctx.already_unreash = true - v.warning(e, "Warning: unreachable statement.") + if not v.flow_ctx.unreash then + v.enter_visit(e) + else if not v.flow_ctx.already_unreash then + v.flow_ctx.already_unreash = true + v.error(e, "Error: unreachable statement.") end - v.enter_visit(e) end - old_var_ctx.merge(v.variable_ctx) - v.variable_ctx = old_var_ctx _is_typed = true end end @@ -392,8 +426,14 @@ end redef class AReturnExpr redef fun after_typing(v) do - v.variable_ctx.unreash = true + v.mark_unreash(self) var t = v.local_property.signature.return_type + + if v.is_default_closure_definition then + v.error(self, "Error: 'return' invalid in default closure definitions. Use 'continue' or 'break'.") + return + end + var e = n_expr if e == null and t != null then v.error(self, "Error: Return without value in a function.") @@ -409,12 +449,12 @@ end redef class AContinueExpr redef fun after_typing(v) do - v.variable_ctx.unreash = true - var esc = compute_escapable_block(v.escapable_ctx) + v.mark_unreash(self) + var esc = compute_escapable_block(v.scope_ctx) if esc == null then return if esc.is_break_block then - v.error(self, "Error: 'continue' forbiden in break blocks.") + v.error(self, "Error: cannot 'continue', only 'break'.") return end @@ -433,10 +473,13 @@ end redef class ABreakExpr redef fun after_typing(v) do - v.variable_ctx.unreash = true - var esc = compute_escapable_block(v.escapable_ctx) + var old_flow_ctx = v.flow_ctx + v.mark_unreash(self) + var esc = compute_escapable_block(v.scope_ctx) if esc == null then return + esc.break_flow_contexts.add(old_flow_ctx) + var bl = esc.break_list if n_expr == null and bl != null then v.error(self, "Error: break with a value required in this block.") @@ -453,101 +496,164 @@ end redef class AAbortExpr redef fun after_typing(v) do - v.variable_ctx.unreash = true + v.mark_unreash(self) + _is_typed = true + end +end + +# An abstract control structure with feature escapable block +class AAbsControl + super AExpr + # The corresponding escapable block + readable var _escapable: nullable EscapableBlock + + # Enter and process a control structure + private fun process_control(v: TypingVisitor, escapable: EscapableBlock, n_label: nullable ALabel, is_loop: Bool) + do + # Register the escapable block + _escapable = escapable + v.scope_ctx.push_escapable(escapable, n_label) + + # Save an prepare the contextes + var old_flow_ctx = v.flow_ctx + var old_base_flow_ctx = v.base_flow_ctx + if is_loop then v.base_flow_ctx = v.flow_ctx + + # Do the main processing + process_control_inside(v) + + # Add the end of the block as an exit context + if not v.flow_ctx.unreash then + escapable.break_flow_contexts.add(v.flow_ctx) + end + + # Merge all exit contexts + if escapable.break_flow_contexts.is_empty then + v.flow_ctx = old_flow_ctx + v.mark_unreash(self) + else + v.flow_ctx = old_base_flow_ctx.merge(self, escapable.break_flow_contexts) + end + + if is_loop then v.base_flow_ctx = old_base_flow_ctx + v.scope_ctx.pop _is_typed = true end + + # What to do inside the control block? + private fun process_control_inside(v: TypingVisitor) is abstract +end + +redef class ADoExpr + super AAbsControl + redef fun accept_typing(v) + do + process_control(v, new BreakOnlyEscapableBlock(self), n_label, false) + end + + redef fun process_control_inside(v) + do + v.enter_visit_block(n_block) + end end redef class AIfExpr redef fun accept_typing(v) do - var old_var_ctx = v.variable_ctx v.enter_visit(n_expr) v.check_conform_expr(n_expr, v.type_bool) # Prepare 'then' context - v.use_if_true_variable_ctx(n_expr) + var old_flow_ctx = v.flow_ctx + v.use_if_true_flow_ctx(n_expr) # Process the 'then' - if n_then != null then - v.variable_ctx = v.variable_ctx.sub(n_then.as(not null)) - v.enter_visit(n_then) - end + v.enter_visit_block(n_then) # Remember what appened in the 'then' - var then_var_ctx = v.variable_ctx + var then_flow_ctx = v.flow_ctx # Prepare 'else' context - v.variable_ctx = old_var_ctx - v.use_if_false_variable_ctx(n_expr) + v.flow_ctx = old_flow_ctx + v.use_if_false_flow_ctx(n_expr) # Process the 'else' - if n_else != null then - v.variable_ctx = v.variable_ctx.sub(n_else.as(not null)) - v.enter_visit(n_else) - end + v.enter_visit_block(n_else) # Merge 'then' and 'else' contexts - old_var_ctx.merge2(then_var_ctx, v.variable_ctx, v.base_variable_ctx) - v.variable_ctx = old_var_ctx + v.flow_ctx = v.base_flow_ctx.merge_reash(self, then_flow_ctx, v.flow_ctx) _is_typed = true end end redef class AWhileExpr - # The corresponding escapable block - readable var _escapable: nullable EscapableBlock - + super AAbsControl redef fun accept_typing(v) do - var escapable = new EscapableBlock(self) - _escapable = escapable - v.escapable_ctx.push(escapable) - var old_var_ctx = v.variable_ctx - var old_base_var_ctx = v.base_variable_ctx - v.base_variable_ctx = v.variable_ctx - v.variable_ctx = v.variable_ctx.sub(self) + process_control(v, new EscapableBlock(self), n_label, true) + end + + redef fun process_control_inside(v) + do + var old_flow_ctx = v.flow_ctx # Process condition v.enter_visit(n_expr) v.check_conform_expr(n_expr, v.type_bool) + if n_expr isa ATrueExpr then + v.warning(self, "Warning: use 'loop' instead of 'while true do'.") + end + # Prepare inside context (assert cond) - v.use_if_true_variable_ctx(n_expr) + v.use_if_true_flow_ctx(n_expr) # Process inside - if n_block != null then - v.variable_ctx = v.variable_ctx.sub(n_block.as(not null)) - v.enter_visit(n_block) - end + v.enter_visit_block(n_block) - v.variable_ctx = old_var_ctx - v.base_variable_ctx = old_base_var_ctx - v.escapable_ctx.pop - _is_typed = true + # Compute outside context (assert !cond + all breaks) + v.flow_ctx = old_flow_ctx + v.use_if_false_flow_ctx(n_expr) + escapable.break_flow_contexts.add(v.flow_ctx) + end +end + +redef class ALoopExpr + super AAbsControl + redef fun accept_typing(v) + do + process_control(v, new EscapableBlock(self), n_label, true) + end + + redef fun process_control_inside(v) + do + # Process inside + v.enter_visit_block(n_block) + + # Never automatically reach after the loop + v.mark_unreash(self) end end redef class AForExpr + super AAbsControl var _variable: nullable AutoVariable redef fun variable do return _variable.as(not null) - # The corresponding escapable block - readable var _escapable: nullable EscapableBlock - redef fun accept_typing(v) do - var escapable = new EscapableBlock(self) - _escapable = escapable - v.escapable_ctx.push(escapable) + process_control(v, new EscapableBlock(self), n_label, true) + end + + redef fun process_control_inside(v) + do + v.scope_ctx.push(self) + var old_flow_ctx = v.flow_ctx - var old_var_ctx = v.variable_ctx - var old_base_var_ctx = v.base_variable_ctx - v.base_variable_ctx = v.variable_ctx - v.variable_ctx = v.variable_ctx.sub(self) - var va = new AutoVariable(n_id.to_symbol, self) + # Create the automatic variable + var va = new AutoVariable(n_id.to_symbol, n_id) _variable = va - v.variable_ctx.add(va) + v.scope_ctx.add_variable(va) # Process collection v.enter_visit(n_expr) @@ -563,22 +669,32 @@ redef class AForExpr if not n_expr.is_self then va_stype = va_stype.not_for_self va.stype = va_stype - # Body evaluation - if n_block != null then v.enter_visit(n_block) + # Process inside + v.enter_visit_block(n_block) - # pop context - v.variable_ctx = old_var_ctx - v.base_variable_ctx = old_base_var_ctx - v.escapable_ctx.pop - _is_typed = true + # end == begin of the loop + v.flow_ctx = old_flow_ctx + v.scope_ctx.pop end end redef class AAssertExpr - redef fun after_typing(v) + redef fun accept_typing(v) do + # Process condition + v.enter_visit(n_expr) v.check_conform_expr(n_expr, v.type_bool) - v.use_if_true_variable_ctx(n_expr) + + # Process optional 'else' part + if n_else != null then + var old_flow_ctx = v.flow_ctx + v.use_if_false_flow_ctx(n_expr) + v.enter_visit(n_else) + v.flow_ctx = old_flow_ctx + end + + # Prepare outside + v.use_if_true_flow_ctx(n_expr) _is_typed = true end end @@ -593,8 +709,8 @@ redef class AVarExpr redef fun after_typing(v) do - v.variable_ctx.check_is_set(self, variable) - _stype = v.variable_ctx.stype(variable) + v.flow_ctx.check_is_set(self, variable) + _stype = v.flow_ctx.stype(variable) _is_typed = _stype != null end end @@ -602,15 +718,15 @@ end redef class AVarAssignExpr redef fun after_typing(v) do - v.variable_ctx.mark_is_set(variable) - var t = v.variable_ctx.stype(variable) + v.mark_is_set(variable) # Check the base type - var btype = v.base_variable_ctx.stype(variable) - if not v.check_conform_expr(n_value, btype) then return + var btype = v.base_flow_ctx.stype(variable) + if not v.check_expr(n_value) then return + if btype != null and not v.check_conform_expr(n_value, btype) then return # Always cast - v.variable_ctx.stype(variable) = n_value.stype + v.flow_ctx = v.flow_ctx.sub_with(self, variable, n_value.stype) _is_typed = true end @@ -626,13 +742,17 @@ redef class AReassignFormExpr return null end var name = n_assign_op.method_name + if type_lvalue isa MMTypeNone then + v.error(self, "Error: Method '{name}' call on 'null'.") + return null + end var lc = type_lvalue.local_class if not lc.has_global_property_by_name(name) then v.error(self, "Error: Method '{name}' doesn't exists in {type_lvalue}.") return null end var prop = lc.select_method(name) - prop.global.check_visibility(v, self, v.module, false) + prop.global.check_visibility(v, self, v.mmmodule, false) var psig = prop.signature_for(type_lvalue) _assign_method = prop if not v.check_conform_expr(n_value, psig[0].not_for_self) then return null @@ -646,18 +766,19 @@ end redef class AVarReassignExpr redef fun after_typing(v) do - v.variable_ctx.check_is_set(self, variable) - v.variable_ctx.mark_is_set(variable) - var t = v.variable_ctx.stype(variable) + v.flow_ctx.check_is_set(self, variable) + v.mark_is_set(variable) + var t = v.flow_ctx.stype(variable) var t2 = do_rvalue_typing(v, t) if t2 == null then return # Check the base type - var btype = v.base_variable_ctx.stype(variable) - if not v.check_conform(n_value, t2, btype) then return + var btype = v.base_flow_ctx.stype(variable) + if not v.check_expr(n_value) then return + if btype != null and not v.check_conform(n_value, t2, btype) then return # Always cast - v.variable_ctx.stype(variable) = t2 + v.flow_ctx = v.flow_ctx.sub_with(self, variable, t2) _is_typed = true end @@ -682,7 +803,7 @@ redef class ASelfExpr redef fun after_typing(v) do _variable = v.self_var - _stype = v.variable_ctx.stype(variable) + _stype = v.flow_ctx.stype(variable) _is_typed = true end @@ -696,24 +817,30 @@ end redef class AIfexprExpr redef fun accept_typing(v) do - var old_var_ctx = v.variable_ctx + var old_flow_ctx = v.flow_ctx # Process condition v.enter_visit(n_expr) v.check_conform_expr(n_expr, v.type_bool) # Prepare 'then' context - v.use_if_true_variable_ctx(n_expr) + v.use_if_true_flow_ctx(n_expr) # Process 'then' - v.enter_visit(n_then) + v.enter_visit_block(n_then) + + # Remember what appened in the 'then' + var then_flow_ctx = v.flow_ctx # Prepare 'else' context - v.variable_ctx = old_var_ctx - v.use_if_false_variable_ctx(n_expr) + v.flow_ctx = old_flow_ctx + v.use_if_false_flow_ctx(n_expr) # Process 'else' - v.enter_visit(n_else) + v.enter_visit_block(n_else) + + # Merge 'then' and 'else' contexts + v.flow_ctx = v.base_flow_ctx.merge_reash(self, then_flow_ctx, v.flow_ctx) var stype = v.check_conform_multiexpr(null, [n_then, n_else]) if stype == null then return @@ -734,7 +861,7 @@ end redef class AOrExpr redef fun accept_typing(v) do - var old_var_ctx = v.variable_ctx + var old_flow_ctx = v.flow_ctx var stype = v.type_bool _stype = stype @@ -742,17 +869,17 @@ redef class AOrExpr v.enter_visit(n_expr) # Prepare right operand context - v.use_if_false_variable_ctx(n_expr) + v.use_if_false_flow_ctx(n_expr) # Process right operand v.enter_visit(n_expr2) - if n_expr2.if_false_variable_ctx != null then - _if_false_variable_ctx = n_expr2.if_false_variable_ctx + if n_expr2.if_false_flow_ctx != null then + _if_false_flow_ctx = n_expr2.if_false_flow_ctx else - _if_false_variable_ctx = v.variable_ctx + _if_false_flow_ctx = v.flow_ctx end - v.variable_ctx = old_var_ctx + v.flow_ctx = old_flow_ctx v.check_conform_expr(n_expr, stype) v.check_conform_expr(n_expr2, stype) @@ -764,24 +891,24 @@ end redef class AAndExpr redef fun accept_typing(v) do - var old_var_ctx = v.variable_ctx + var old_flow_ctx = v.flow_ctx var stype = v.type_bool # Process left operand v.enter_visit(n_expr) # Prepare right operand context - v.use_if_true_variable_ctx(n_expr) + v.use_if_true_flow_ctx(n_expr) # Process right operand v.enter_visit(n_expr2) - if n_expr2.if_true_variable_ctx != null then - _if_true_variable_ctx = n_expr2.if_true_variable_ctx + if n_expr2.if_true_flow_ctx != null then + _if_true_flow_ctx = n_expr2.if_true_flow_ctx else - _if_true_variable_ctx = v.variable_ctx + _if_true_flow_ctx = v.flow_ctx end - v.variable_ctx = old_var_ctx + v.flow_ctx = old_flow_ctx v.check_conform_expr(n_expr, stype) v.check_conform_expr(n_expr2, stype) @@ -796,14 +923,53 @@ redef class ANotExpr v.check_conform_expr(n_expr, v.type_bool) # Invert if_true/if_false information - _if_false_variable_ctx = n_expr._if_true_variable_ctx - _if_true_variable_ctx = n_expr._if_false_variable_ctx + _if_false_flow_ctx = n_expr._if_true_flow_ctx + _if_true_flow_ctx = n_expr._if_false_flow_ctx _stype = v.type_bool _is_typed = true end end +redef class AOrElseExpr + redef fun after_typing(v) + do + var old_flow_ctx = v.flow_ctx + + # Process left operand + v.enter_visit(n_expr) + v.check_expr(n_expr) + + # Consider the type of the left operand + var t = n_expr.stype + if not t.is_nullable then + v.warning(n_expr, "Warning: left operant of a 'or else' is not a nullable type.") + else + t = t.as_notnull + end + + # Prepare the else context : ie the first expression is null + var variable = n_expr.its_variable + if variable != null then + v.flow_ctx.sub_with(self, variable, v.type_none) + end + + # Process right operand + v.enter_visit(n_expr2) + v.check_expr(n_expr) + + # Restore the context + v.flow_ctx = old_flow_ctx + + # Merge the types + var stype = v.check_conform_multiexpr(t, [n_expr2]) + if stype == null then return + + _stype = stype + _is_typed = true + end +end + redef class AIntExpr redef fun after_typing(v) do @@ -841,8 +1007,10 @@ redef class ASuperstringExpr var _atype: nullable MMType redef fun after_typing(v) do + var otype = v.type_object var stype = v.type_string _stype = stype + for e in n_exprs do v.check_conform_expr(e, otype) var atype = v.type_array(stype) _atype = atype _is_typed = true @@ -892,6 +1060,7 @@ end redef class ASuperExpr redef readable var _init_in_superclass: nullable MMMethod + redef fun compute_raw_arguments do return n_args.to_a redef fun after_typing(v) do var precs: Array[MMLocalProperty] = v.local_property.prhe.direct_greaters @@ -919,7 +1088,7 @@ redef class ASuperExpr register_super_init_call(v, p) if n_args.length > 0 then var signature = get_signature(v, v.self_var.stype.as(not null), p, true) - _arguments = process_signature(v, signature, p.name, n_args.to_a) + process_signature(v, signature, p.name, compute_raw_arguments) end else v.error(self, "Error: No super method to call for {v.local_property}.") @@ -931,7 +1100,7 @@ redef class ASuperExpr var stype: nullable MMType = null for prop in precs do assert prop isa MMMethod - var t = prop.signature_for(v.self_var.stype.as(not null)).return_type.for_module(v.module).adapt_to(v.local_property.signature.recv) + var t = prop.signature_for(v.self_var.stype.as(not null)).return_type.for_module(v.mmmodule).adapt_to(v.local_property.signature.recv) stypes.add(t) if stype == null or stype < t then stype = t @@ -962,14 +1131,18 @@ redef class AAttrFormExpr if not v.check_expr(n_expr) then return var type_recv = n_expr.stype var name = n_id.to_symbol + if type_recv isa MMTypeNone then + v.error(self, "Error: Attribute '{name}' access on 'null'.") + return + end var lc = type_recv.local_class if not lc.has_global_property_by_name(name) then v.error(self, "Error: Attribute {name} doesn't exists in {type_recv}.") return end var prop = lc.select_attribute(name) - if v.module.visibility_for(prop.global.local_class.module) < 3 then - v.error(self, "Error: Attribute {name} from {prop.global.local_class.module} is invisible in {v.module}") + if v.mmmodule.visibility_for(prop.global.local_class.mmmodule) < 3 then + v.error(self, "Error: Attribute {name} from {prop.global.local_class.mmmodule} is invisible in {v.mmmodule}") end _prop = prop var at = prop.signature_for(type_recv).return_type @@ -1028,45 +1201,56 @@ redef class AAbsAbsSendExpr redef fun prop_signature do return _prop_signature.as(not null) var _prop_signature: nullable MMSignature - # The real arguments used (after star transformation) (once computed) - redef fun arguments do return _arguments.as(not null) - var _arguments: nullable Array[AExpr] + # Raw arguments used (without vararg transformation) + redef fun raw_arguments: Array[AExpr] + do + var res = _raw_arguments_cache + if res != null then + return res + else + res = compute_raw_arguments + if res == null then res = new Array[AExpr] + _raw_arguments_cache = res + return res + end + end + + var _raw_arguments_cache: nullable Array[AExpr] = null + + fun compute_raw_arguments: nullable Array[AExpr] + do + print "{location} no compute_raw_arguments" + return null + end # Check the conformity of a set of arguments `raw_args' to a signature. - private fun process_signature(v: TypingVisitor, psig: MMSignature, name: Symbol, raw_args: nullable Array[AExpr]): nullable Array[AExpr] + private fun process_signature(v: TypingVisitor, psig: MMSignature, name: Symbol, raw_args: nullable Array[AExpr]): Bool do var par_vararg = psig.vararg_rank var par_arity = psig.arity var raw_arity: Int if raw_args == null then raw_arity = 0 else raw_arity = raw_args.length if par_arity > raw_arity or (par_arity != raw_arity and par_vararg == -1) then - v.error(self, "Error: '{name}' arity missmatch.") - return null + v.error(self, "Error: arity missmatch; prototype is '{name}{psig}'.") + return false end var arg_idx = 0 - var args = new Array[AExpr] for par_idx in [0..par_arity[ do var a: AExpr var par_type = psig[par_idx] if par_idx == par_vararg then - var star = new Array[AExpr] for i in [0..(raw_arity-par_arity)] do a = raw_args[arg_idx] v.check_conform_expr(a, par_type) - star.add(a) arg_idx = arg_idx + 1 end - var aa = new AArrayExpr.init_aarrayexpr(star) - aa.do_typing(v, par_type) - a = aa else a = raw_args[arg_idx] v.check_conform_expr(a, par_type) arg_idx = arg_idx + 1 end - args.add(a) end - return args + return true end # Check the conformity of a set of defined closures @@ -1090,14 +1274,28 @@ redef class AAbsAbsSendExpr var break_list: nullable Array[ABreakExpr] = null if t != null then break_list = new Array[ABreakExpr] + # The n_label, is any in only set on the last decl + var n_label = if arity > 0 then cd[arity-1].n_label else null + # Process each closure definition for i in [0..arity[ do - var csi = cs[i] var cdi = cd[i] - var esc = new EscapableClosure(cdi, csi, break_list) - v.escapable_ctx.push(esc) - cdi.accept_typing2(v, esc) - v.escapable_ctx.pop + var cni = cdi.n_id.to_symbol + var csi = psig.closure_named(cni) + if csi != null then + var esc = new EscapableClosure(cdi, csi, break_list) + v.scope_ctx.push_escapable(esc, n_label) + cdi.accept_typing2(v, esc) + v.scope_ctx.pop + else if cs.length == 1 then + v.error(cdi.n_id, "Error: no closure named '!{cni}' in {name}; only closure is !{cs.first.name}.") + else + var a = new Array[String] + for c in cs do + a.add("!{c.name}") + end + v.error(cdi.n_id, "Error: no closure named '!{cni}' in {name}; only closures are {a.join(",")}.") + end end # Check break type conformity @@ -1119,28 +1317,35 @@ redef class AAbsSendExpr var prop = get_property(v, type_recv, is_implicit_self, name) if prop == null then return var sig = get_signature(v, type_recv, prop, recv_is_self) - var args = process_signature(v, sig, prop.name, raw_args) - if args == null then return + if not process_signature(v, sig, prop.name, raw_args) then return var rtype = process_closures(v, sig, prop.name, closure_defs) if rtype == null and sig.return_type != null then return _prop = prop _prop_signature = sig - _arguments = args _return_type = rtype end private fun get_property(v: TypingVisitor, type_recv: MMType, is_implicit_self: Bool, name: Symbol): nullable MMMethod do + if type_recv isa MMTypeNone then + if name == (once "==".to_symbol) or name == (once "!=".to_symbol) then + # Special case on != and == that are allowed for 'null' + type_recv = v.type_object.as_nullable + else + v.error(self, "Error: Method '{name}' call on 'null'.") + return null + end + end var lc = type_recv.local_class var prop: nullable MMMethod = null if lc.has_global_property_by_name(name) then prop = lc.select_method(name) if prop == null and v.local_property.global.is_init then - var props = type_recv.local_class.super_methods_named(name) + var props = lc.super_methods_named(name) if props.length > 1 then v.error(self, "Error: Ambigous method name '{name}' for {props.join(", ")}. Use explicit designation.") return null else if props.length == 1 then - var p = type_recv.local_class[props.first.global] + var p = lc[props.first.global] assert p isa MMMethod prop = p end @@ -1160,7 +1365,7 @@ redef class AAbsSendExpr # Get the signature for a local property and a receiver private fun get_signature(v: TypingVisitor, type_recv: MMType, prop: MMMethod, recv_is_self: Bool): MMSignature do - prop.global.check_visibility(v, self, v.module, recv_is_self) + prop.global.check_visibility(v, self, v.mmmodule, recv_is_self) var psig = prop.signature_for(type_recv) if not recv_is_self then psig = psig.not_for_self return psig @@ -1182,7 +1387,7 @@ redef class ASuperInitCall if parent != v.top_block and self != v.top_block then v.error(self, "Error: Constructor invocation {property} must not be in nested block.") end - var cla = v.module[property.global.intro.local_class.global] + var cla = v.mmmodule[property.global.intro.local_class.global] var prev_class: nullable MMLocalClass = null var esic = v.explicit_super_init_calls.as(not null) if not esic.is_empty then @@ -1196,12 +1401,11 @@ redef class ASuperInitCall else if cla == prev_class then v.error(self, "Error: Only one super constructor invocation of class {cla} is allowed.") else - var last_is_found = prev_class == null for c in order do if c == prev_class then - last_is_found = true + prev_class = null else if c == cla then - if not last_is_found then + if prev_class != null then v.error(self, "Error: Constructor of {c} must be invoked before constructor of {prev_class}") end esic.add(property) @@ -1214,6 +1418,7 @@ redef class ASuperInitCall end redef class ANewExpr + redef fun compute_raw_arguments do return n_args.to_a redef fun after_typing(v) do if not n_type.is_typed then return @@ -1229,7 +1434,7 @@ redef class ANewExpr name = n_id.to_symbol end - do_typing(v, t, false, false, name, n_args.to_a, null) + do_typing(v, t, false, false, name, raw_arguments, null) if _prop == null then return if not prop.global.is_init then @@ -1246,9 +1451,6 @@ redef class ASendExpr # Name of the invoked property fun name: Symbol is abstract - # Raw arguments used (withour star transformation) - fun raw_arguments: nullable Array[AExpr] is abstract - # Closure definitions redef fun closure_defs: nullable Array[AClosureDef] do return null @@ -1304,7 +1506,7 @@ redef class ASendReassignExpr v.check_conform(self, t2, n_value.stype) _read_prop = prop - var old_args = arguments + raw_args = raw_args.to_a raw_args.add(n_value) do_typing(v, n_expr.stype, n_expr.is_implicit_self, n_expr.is_self, "{name}=".to_symbol, raw_args, null) @@ -1316,13 +1518,12 @@ redef class ASendReassignExpr end end - _arguments = old_args # FIXME: What if star parameters do not match betwen the two methods? _is_typed = true end end redef class ABinopExpr - redef fun raw_arguments do return [n_expr2] + redef fun compute_raw_arguments do return [n_expr2] end redef class AEqExpr redef fun name do return once "==".to_symbol @@ -1336,7 +1537,11 @@ redef class AEqExpr end if n_expr.stype isa MMTypeNone then - try_to_isa(v, n_expr2) + if n_expr2.stype isa MMTypeNone then + v.warning(self, "Warning: comparaison between 2 null values.") + else + try_to_isa(v, n_expr2) + end else if n_expr2.stype isa MMTypeNone then try_to_isa(v, n_expr) end @@ -1345,8 +1550,9 @@ redef class AEqExpr private fun try_to_isa(v: TypingVisitor, n: AExpr) do var variable = n.its_variable - if variable != null then - _if_false_variable_ctx = v.variable_ctx.sub_with(self, variable, n.stype.as_notnull) + if variable != null and n.stype isa MMNullableType then + _if_false_flow_ctx = v.flow_ctx.sub_with(self, variable, n.stype.as_notnull) + _if_true_flow_ctx = v.flow_ctx.sub_with(self, variable, v.type_none) end end end @@ -1362,7 +1568,11 @@ redef class ANeExpr end if n_expr.stype isa MMTypeNone then - try_to_isa(v, n_expr2) + if n_expr2.stype isa MMTypeNone then + v.warning(self, "Warning: comparaison between 2 null values.") + else + try_to_isa(v, n_expr2) + end else if n_expr2.stype isa MMTypeNone then try_to_isa(v, n_expr) end @@ -1371,8 +1581,9 @@ redef class ANeExpr private fun try_to_isa(v: TypingVisitor, n: AExpr) do var variable = n.its_variable - if variable != null then - _if_true_variable_ctx = v.variable_ctx.sub_with(self, variable, n.stype.as_notnull) + if variable != null and n.stype isa MMNullableType then + _if_true_flow_ctx = v.flow_ctx.sub_with(self, variable, n.stype.as_notnull) + _if_false_flow_ctx = v.flow_ctx.sub_with(self, variable, v.type_none) end end end @@ -1382,12 +1593,18 @@ end redef class ALeExpr redef fun name do return once "<=".to_symbol end +redef class ALlExpr + redef fun name do return once "<<".to_symbol +end redef class AGtExpr redef fun name do return once ">".to_symbol end redef class AGeExpr redef fun name do return once ">=".to_symbol end +redef class AGgExpr + redef fun name do return once ">>".to_symbol +end redef class APlusExpr redef fun name do return once "+".to_symbol end @@ -1409,7 +1626,7 @@ end redef class AUminusExpr redef fun name do return once "unary -".to_symbol - redef fun raw_arguments do return null + redef fun compute_raw_arguments do return null end redef class ACallFormExpr @@ -1417,7 +1634,7 @@ redef class ACallFormExpr do if n_expr.is_implicit_self then var name = n_id.to_symbol - var variable = v.variable_ctx[name] + var variable = v.scope_ctx[name] if variable != null then var n: AExpr if variable isa ClosureVariable then @@ -1460,7 +1677,7 @@ redef class ACallExpr end redef fun name do return n_id.to_symbol - redef fun raw_arguments do return n_args.to_a + redef fun compute_raw_arguments do return n_args.to_a end redef class ACallAssignExpr @@ -1470,7 +1687,7 @@ redef class ACallAssignExpr end redef fun name do return (n_id.text + "=").to_symbol - redef fun raw_arguments do + redef fun compute_raw_arguments do var res = n_args.to_a res.add(n_value) return res @@ -1484,17 +1701,25 @@ redef class ACallReassignExpr end redef fun name do return n_id.to_symbol - redef fun raw_arguments do return n_args.to_a + redef fun compute_raw_arguments do return n_args.to_a end redef class ABraExpr redef fun name do return once "[]".to_symbol - redef fun raw_arguments do return n_args.to_a + redef fun compute_raw_arguments do return n_args.to_a + redef fun closure_defs + do + if n_closure_defs.is_empty then + return null + else + return n_closure_defs.to_a + end + end end redef class ABraAssignExpr redef fun name do return once "[]=".to_symbol - redef fun raw_arguments do + redef fun compute_raw_arguments do var res = n_args.to_a res.add(n_value) return res @@ -1503,35 +1728,45 @@ end redef class ABraReassignExpr redef fun name do return once "[]".to_symbol - redef fun raw_arguments do return n_args.to_a + redef fun compute_raw_arguments do return n_args.to_a end redef class AInitExpr redef fun name do return once "init".to_symbol - redef fun raw_arguments do return n_args.to_a + redef fun compute_raw_arguments do return n_args.to_a end redef class AClosureCallExpr var _variable: nullable ClosureVariable redef fun variable do return _variable.as(not null) + redef fun compute_raw_arguments do return n_args.to_a redef fun after_typing(v) do var va = variable - if va.closure.is_break then v.variable_ctx.unreash = true + if va.closure.is_break then v.mark_unreash(self) var sig = va.closure.signature - var args = process_signature(v, sig, n_id.to_symbol, n_args.to_a) + var s = process_signature(v, sig, n_id.to_symbol, compute_raw_arguments) if not n_closure_defs.is_empty then process_closures(v, sig, n_id.to_symbol, n_closure_defs.to_a) end - if args == null then return + if not s then return _prop_signature = sig - _arguments = args _stype = sig.return_type _is_typed = true end end +redef class AClosureId + fun to_symbol: Symbol is abstract +end +redef class ASimpleClosureId + redef fun to_symbol: Symbol do return n_id.to_symbol +end +redef class ABreakClosureId + redef fun to_symbol: Symbol do return n_kwbreak.to_symbol +end + redef class AClosureDef var _closure: nullable MMClosure redef fun closure do return _closure.as(not null) @@ -1551,42 +1786,43 @@ redef class AClosureDef _escapable = esc var sig = esc.closure.signature - if sig.arity != n_id.length then - v.error(self, "Error: {sig.arity} automatic variable names expected, {n_id.length} found.") + if sig.arity != n_ids.length then + v.error(self, "Error: {sig.arity} automatic variable names expected, {n_ids.length} found.") return end _closure = esc.closure - var old_var_ctx = v.variable_ctx - var old_base_var_ctx = v.base_variable_ctx - v.base_variable_ctx = v.variable_ctx - v.variable_ctx = v.variable_ctx.sub(self) + v.scope_ctx.push(self) + var old_flow_ctx = v.flow_ctx + var old_base_flow_ctx = v.base_flow_ctx + v.base_flow_ctx = v.flow_ctx variables = new Array[AutoVariable] - for i in [0..n_id.length[ do - var va = new AutoVariable(n_id[i].to_symbol, self) + for i in [0..n_ids.length[ do + var va = new AutoVariable(n_ids[i].to_symbol, n_ids[i]) variables.add(va) va.stype = sig[i] - v.variable_ctx.add(va) + v.scope_ctx.add_variable(va) end _accept_typing2 = true accept_typing(v) - if v.variable_ctx.unreash == false then + if v.flow_ctx.unreash == false then if closure.signature.return_type != null then v.error(self, "Control error: Reached end of block (a 'continue' with a value was expected).") - else if closure.is_break then - v.error(self, "Control error: Reached end of break block (a 'break' was expected).") + else if closure.is_break and esc.break_list != null then + v.error(self, "Control error: Reached end of break block (a 'break' with a value was expected).") end end - v.variable_ctx = old_var_ctx - v.base_variable_ctx = old_base_var_ctx + v.flow_ctx = old_flow_ctx + v.base_flow_ctx = old_base_flow_ctx + v.scope_ctx.pop end end class ATypeCheckExpr -special AExpr + super AExpr private fun check_expr_cast(v: TypingVisitor, n_expr: AExpr, n_type: AType) do if not v.check_expr(n_expr) then return @@ -1597,6 +1833,9 @@ special AExpr v.warning(self, "Warning: Expression is already a {ttype}.") else if etype < ttype then v.warning(self, "Warning: Expression is already a {ttype} since it is a {etype}.") + else if etype isa MMTypeNone then + # ttype is not nullable because of prevous test + v.warning(self, "Warning: Expression is null therefore cannot be a {ttype}.") else if etype.is_nullable and etype.as_notnull == ttype then if ttype isa MMTypeFormal and ttype.bound.is_nullable then # No warning in this case since with @@ -1614,14 +1853,14 @@ special AExpr end redef class AIsaExpr -special ATypeCheckExpr + super ATypeCheckExpr redef fun after_typing(v) do check_expr_cast(v, n_expr, n_type) if not n_type.is_typed then return var variable = n_expr.its_variable if variable != null then - _if_true_variable_ctx = v.variable_ctx.sub_with(self, variable, n_type.stype) + _if_true_flow_ctx = v.flow_ctx.sub_with(self, variable, n_type.stype) end _stype = v.type_bool _is_typed = true @@ -1629,7 +1868,7 @@ special ATypeCheckExpr end redef class AAsCastExpr -special ATypeCheckExpr + super ATypeCheckExpr redef fun after_typing(v) do check_expr_cast(v, n_expr, n_type)