Merge: Warn call on nullable receiver
[nit.git] / src / semantize / typing.nit
1 # This file is part of NIT ( http://www.nitlanguage.org ).
2 #
3 # Copyright 2012 Jean Privat <jean@pryen.org>
4 #
5 # Licensed under the Apache License, Version 2.0 (the "License");
6 # you may not use this file except in compliance with the License.
7 # You may obtain a copy of the License at
8 #
9 # http://www.apache.org/licenses/LICENSE-2.0
10 #
11 # Unless required by applicable law or agreed to in writing, software
12 # distributed under the License is distributed on an "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
16
17 # Intraprocedural resolution of static types and OO-services
18 # By OO-services we mean message sending, attribute access, instantiation, etc.
19 module typing
20
21 import modelize
22 import local_var_init
23
24 redef class ToolContext
25 var typing_phase: Phase = new TypingPhase(self, [flow_phase, modelize_property_phase, local_var_init_phase])
26 end
27
28 private class TypingPhase
29 super Phase
30 redef fun process_npropdef(npropdef) do npropdef.do_typing(toolcontext.modelbuilder)
31 end
32
33 private class TypeVisitor
34 var modelbuilder: ModelBuilder
35
36 # The module of the analysis
37 # Used to correctly query the model
38 var mmodule: MModule
39
40 # The static type of the receiver
41 # Mainly used for type tests and type resolutions
42 var anchor: nullable MClassType = null
43
44 # The analyzed mclassdef
45 var mclassdef: nullable MClassDef = null
46
47 # The analyzed property
48 var mpropdef: nullable MPropDef
49
50 var selfvariable = new Variable("self")
51
52 # Is `self` use restricted?
53 # * no explicit `self`
54 # * method called on the implicit self must be top-level
55 # Currently only used for `new` factory since there is no valid receiver inside
56 var is_toplevel_context = false
57
58 init
59 do
60 var mpropdef = self.mpropdef
61
62 if mpropdef != null then
63 self.mpropdef = mpropdef
64 var mclassdef = mpropdef.mclassdef
65 self.mclassdef = mclassdef
66 self.anchor = mclassdef.bound_mtype
67
68 var mclass = mclassdef.mclass
69
70 var selfvariable = new Variable("self")
71 self.selfvariable = selfvariable
72 selfvariable.declared_type = mclass.mclass_type
73
74 var mprop = mpropdef.mproperty
75 if mprop isa MMethod and mprop.is_new then
76 is_toplevel_context = true
77 end
78 end
79 end
80
81 fun anchor_to(mtype: MType): MType
82 do
83 var anchor = anchor
84 if anchor == null then
85 assert not mtype.need_anchor
86 return mtype
87 end
88 return mtype.anchor_to(mmodule, anchor)
89 end
90
91 fun is_subtype(sub, sup: MType): Bool
92 do
93 return sub.is_subtype(mmodule, anchor, sup)
94 end
95
96 fun resolve_for(mtype, subtype: MType, for_self: Bool): MType
97 do
98 #print "resolve_for {mtype} sub={subtype} forself={for_self} mmodule={mmodule} anchor={anchor}"
99 var res = mtype.resolve_for(subtype, anchor, mmodule, not for_self)
100 return res
101 end
102
103 # Check that `sub` is a subtype of `sup`.
104 # If `sub` is not a valid suptype, then display an error on `node` an return null.
105 # If `sub` is a safe subtype of `sup` then return `sub`.
106 # If `sub` is an unsafe subtype (ie an implicit cast is required), then return `sup`.
107 #
108 # The point of the return type is to determinate the usable type on an expression when `autocast` is true:
109 # If the suptype is safe, then the return type is the one on the expression typed by `sub`.
110 # Is the subtype is unsafe, then the return type is the one of an implicit cast on `sup`.
111 fun check_subtype(node: ANode, sub, sup: MType, autocast: Bool): nullable MType
112 do
113 if self.is_subtype(sub, sup) then return sub
114 if autocast and self.is_subtype(sub, self.anchor_to(sup)) then
115 # FIXME workaround to the current unsafe typing policy. To remove once fixed virtual types exists.
116 #node.debug("Unsafe typing: expected {sup}, got {sub}")
117 return sup
118 end
119 if sub.need_anchor then
120 var u = anchor_to(sub)
121 self.modelbuilder.error(node, "Type Error: expected `{sup}`, got `{sub}: {u}`.")
122 else
123 self.modelbuilder.error(node, "Type Error: expected `{sup}`, got `{sub}`.")
124 end
125 return null
126 end
127
128 # Visit an expression and do not care about the return value
129 fun visit_stmt(nexpr: nullable AExpr)
130 do
131 if nexpr == null then return
132 nexpr.accept_typing(self)
133 end
134
135 # Visit an expression and expects that it is not a statement
136 # Return the type of the expression
137 # Display an error and return null if:
138 # * the type cannot be determined or
139 # * `nexpr` is a statement
140 fun visit_expr(nexpr: AExpr): nullable MType
141 do
142 nexpr.accept_typing(self)
143 var mtype = nexpr.mtype
144 if mtype != null then return mtype
145 if not nexpr.is_typed then
146 if not self.modelbuilder.toolcontext.error_count > 0 then # check that there is really an error
147 if self.modelbuilder.toolcontext.verbose_level > 1 then
148 nexpr.debug("No return type but no error.")
149 end
150 end
151 return null # forward error
152 end
153 self.error(nexpr, "Error: expected an expression.")
154 return null
155 end
156
157 # Visit an expression and expect its static type is a least a `sup`
158 # Return the type of the expression or null if
159 # * the type cannot be determined or
160 # * `nexpr` is a statement or
161 # * `nexpr` is not a `sup`
162 fun visit_expr_subtype(nexpr: AExpr, sup: nullable MType): nullable MType
163 do
164 var sub = visit_expr(nexpr)
165 if sub == null then return null # Forward error
166
167 if sup == null then return null # Forward error
168
169 var res = check_subtype(nexpr, sub, sup, true)
170 if res != sub then
171 nexpr.implicit_cast_to = res
172 end
173 return res
174 end
175
176 # Visit an expression and expect its static type is a `Bool`
177 # Return the type of the expression or null if
178 # * the type cannot be determined or
179 # * `nexpr` is a statement or
180 # * `nexpr` is not a `Bool`
181 fun visit_expr_bool(nexpr: AExpr): nullable MType
182 do
183 return self.visit_expr_subtype(nexpr, self.type_bool(nexpr))
184 end
185
186
187 fun visit_expr_cast(node: ANode, nexpr: AExpr, ntype: AType): nullable MType
188 do
189 var sub = visit_expr(nexpr)
190 if sub == null then return null # Forward error
191
192 var sup = self.resolve_mtype(ntype)
193 if sup == null then return null # Forward error
194
195 if sup == sub then
196 self.modelbuilder.warning(node, "useless-type-test", "Warning: expression is already a `{sup}`.")
197 else if self.is_subtype(sub, sup) then
198 self.modelbuilder.warning(node, "useless-type-test", "Warning: expression is already a `{sup}` since it is a `{sub}`.")
199 end
200 return sup
201 end
202
203 # Can `mtype` be null (up to the current knowledge)?
204 fun can_be_null(mtype: MType): Bool
205 do
206 if mtype isa MNullableType or mtype isa MNullType then return true
207 if mtype isa MFormalType then
208 var x = anchor_to(mtype)
209 if x isa MNullableType or x isa MNullType then return true
210 end
211 return false
212 end
213
214 # Check that `mtype` can be null (up to the current knowledge).
215 #
216 # If not then display a `useless-null-test` warning on node and return false.
217 # Else return true.
218 fun check_can_be_null(anode: ANode, mtype: MType): Bool
219 do
220 if can_be_null(mtype) then return true
221
222 if mtype isa MFormalType then
223 var res = anchor_to(mtype)
224 modelbuilder.warning(anode, "useless-null-test", "Warning: expression is not null, since it is a `{mtype}: {res}`.")
225 else
226 modelbuilder.warning(anode, "useless-null-test", "Warning: expression is not null, since it is a `{mtype}`.")
227 end
228 return false
229 end
230
231 # Special verification on != and == for null
232 # Return true
233 fun null_test(anode: ABinopExpr)
234 do
235 var mtype = anode.n_expr.mtype
236 var mtype2 = anode.n_expr2.mtype
237
238 if mtype == null or mtype2 == null then return
239
240 if not mtype2 isa MNullType then return
241
242 # Check of useless null
243 if not check_can_be_null(anode.n_expr, mtype) then return
244
245 if mtype isa MNullType then
246 # Because of type adaptation, we cannot just stop here
247 # so return use `null` as a bottom type that will be merged easily (cf) `merge_types`
248 mtype = null
249 else
250 mtype = mtype.as_notnull
251 end
252
253 # Check for type adaptation
254 var variable = anode.n_expr.its_variable
255 if variable == null then return
256
257 # One is null (mtype2 see above) the other is not null
258 if anode isa AEqExpr then
259 anode.after_flow_context.when_true.set_var(self, variable, mtype2)
260 anode.after_flow_context.when_false.set_var(self, variable, mtype)
261 else if anode isa ANeExpr then
262 anode.after_flow_context.when_false.set_var(self, variable, mtype2)
263 anode.after_flow_context.when_true.set_var(self, variable, mtype)
264 else
265 abort
266 end
267 end
268
269 fun try_get_mproperty_by_name2(anode: ANode, mtype: MType, name: String): nullable MProperty
270 do
271 return self.modelbuilder.try_get_mproperty_by_name2(anode, mmodule, mtype, name)
272 end
273
274 fun resolve_mtype(node: AType): nullable MType
275 do
276 return self.modelbuilder.resolve_mtype(mmodule, mclassdef, node)
277 end
278
279 fun try_get_mclass(node: ANode, name: String): nullable MClass
280 do
281 var mclass = modelbuilder.try_get_mclass_by_name(node, mmodule, name)
282 return mclass
283 end
284
285 fun get_mclass(node: ANode, name: String): nullable MClass
286 do
287 var mclass = modelbuilder.get_mclass_by_name(node, mmodule, name)
288 return mclass
289 end
290
291 fun type_bool(node: ANode): nullable MType
292 do
293 var mclass = self.get_mclass(node, "Bool")
294 if mclass == null then return null
295 return mclass.mclass_type
296 end
297
298 fun get_method(node: ANode, recvtype: MType, name: String, recv_is_self: Bool): nullable CallSite
299 do
300 var unsafe_type = self.anchor_to(recvtype)
301
302 #debug("recv: {recvtype} (aka {unsafe_type})")
303 if recvtype isa MNullType then
304 var objclass = get_mclass(node, "Object")
305 if objclass == null then return null # Forward error
306 unsafe_type = objclass.mclass_type
307 end
308
309 var mproperty = self.try_get_mproperty_by_name2(node, unsafe_type, name)
310 if name == "new" and mproperty == null then
311 name = "init"
312 mproperty = self.try_get_mproperty_by_name2(node, unsafe_type, name)
313 end
314
315 if mproperty == null then
316 if recv_is_self then
317 self.modelbuilder.error(node, "Error: method or variable `{name}` unknown in `{recvtype}`.")
318 else if recvtype.need_anchor then
319 self.modelbuilder.error(node, "Error: method `{name}` does not exists in `{recvtype}: {unsafe_type}`.")
320 else
321 self.modelbuilder.error(node, "Error: method `{name}` does not exists in `{recvtype}`.")
322 end
323 return null
324 end
325
326 assert mproperty isa MMethod
327
328 # `null` only accepts some methods of object.
329 if recvtype isa MNullType and not mproperty.is_null_safe then
330 self.error(node, "Error: method `{name}` called on `null`.")
331 return null
332 else if unsafe_type isa MNullableType and not mproperty.is_null_safe then
333 modelbuilder.advice(node, "call-on-nullable", "Warning: method call on a nullable receiver `{recvtype}`.")
334 end
335
336 if is_toplevel_context and recv_is_self and not mproperty.is_toplevel then
337 error(node, "Error: `{name}` is not a top-level method, thus need a receiver.")
338 end
339 if not recv_is_self and mproperty.is_toplevel then
340 error(node, "Error: cannot call `{name}`, a top-level method, with a receiver.")
341 end
342
343 if mproperty.visibility == protected_visibility and not recv_is_self and self.mmodule.visibility_for(mproperty.intro_mclassdef.mmodule) < intrude_visibility and not modelbuilder.toolcontext.opt_ignore_visibility.value then
344 self.modelbuilder.error(node, "Error: method `{name}` is protected and can only accessed by `self`.")
345 return null
346 end
347
348 var info = mproperty.deprecation
349 if info != null and self.mpropdef.mproperty.deprecation == null then
350 var mdoc = info.mdoc
351 if mdoc != null then
352 self.modelbuilder.warning(node, "deprecated-method", "Deprecation Warning: method `{name}` is deprecated: {mdoc.content.first}")
353 else
354 self.modelbuilder.warning(node, "deprecated-method", "Deprecation Warning: method `{name}` is deprecated.")
355 end
356 end
357
358 var propdefs = mproperty.lookup_definitions(self.mmodule, unsafe_type)
359 var mpropdef
360 if propdefs.length == 0 then
361 self.modelbuilder.error(node, "Type Error: no definition found for property `{name}` in `{unsafe_type}`.")
362 return null
363 else if propdefs.length == 1 then
364 mpropdef = propdefs.first
365 else
366 self.modelbuilder.warning(node, "property-conflict", "Warning: conflicting property definitions for property `{name}` in `{unsafe_type}`: {propdefs.join(" ")}")
367 mpropdef = mproperty.intro
368 end
369
370
371 var msignature = mpropdef.new_msignature or else mpropdef.msignature
372 if msignature == null then return null # skip error
373 msignature = resolve_for(msignature, recvtype, recv_is_self).as(MSignature)
374
375 var erasure_cast = false
376 var rettype = mpropdef.msignature.return_mtype
377 if not recv_is_self and rettype != null then
378 rettype = rettype.undecorate
379 if rettype isa MParameterType then
380 var erased_rettype = msignature.return_mtype
381 assert erased_rettype != null
382 #node.debug("Erasure cast: Really a {rettype} but unsafely a {erased_rettype}")
383 erasure_cast = true
384 end
385 end
386
387 var callsite = new CallSite(node, recvtype, mmodule, anchor, recv_is_self, mproperty, mpropdef, msignature, erasure_cast)
388 return callsite
389 end
390
391 fun try_get_method(node: ANode, recvtype: MType, name: String, recv_is_self: Bool): nullable CallSite
392 do
393 var unsafe_type = self.anchor_to(recvtype)
394 var mproperty = self.try_get_mproperty_by_name2(node, unsafe_type, name)
395 if mproperty == null then return null
396 return get_method(node, recvtype, name, recv_is_self)
397 end
398
399
400 # Visit the expressions of args and check their conformity with the corresponding type in signature
401 # The point of this method is to handle varargs correctly
402 # Note: The signature must be correctly adapted
403 fun check_signature(node: ANode, args: Array[AExpr], mproperty: MProperty, msignature: MSignature): nullable SignatureMap
404 do
405 var vararg_rank = msignature.vararg_rank
406 if vararg_rank >= 0 then
407 if args.length < msignature.arity then
408 modelbuilder.error(node, "Error: expected at least {msignature.arity} argument(s) for `{mproperty}{msignature}`; got {args.length}. See introduction at `{mproperty.full_name}`.")
409 return null
410 end
411 else if args.length != msignature.arity then
412 if msignature.arity == msignature.min_arity then
413 modelbuilder.error(node, "Error: expected {msignature.arity} argument(s) for `{mproperty}{msignature}`; got {args.length}. See introduction at `{mproperty.full_name}`.")
414 return null
415 end
416 if args.length > msignature.arity then
417 modelbuilder.error(node, "Error: expected at most {msignature.arity} argument(s) for `{mproperty}{msignature}`; got {args.length}. See introduction at `{mproperty.full_name}`.")
418 return null
419 end
420 if args.length < msignature.min_arity then
421 modelbuilder.error(node, "Error: expected at least {msignature.min_arity} argument(s) for `{mproperty}{msignature}`; got {args.length}. See introduction at `{mproperty.full_name}`.")
422 return null
423 end
424 end
425
426 #debug("CALL {unsafe_type}.{msignature}")
427
428 # Associate each parameter to a position in the arguments
429 var map = new SignatureMap
430
431 var setted = args.length - msignature.min_arity
432
433 # First, handle named arguments
434 for i in [0..args.length[ do
435 var e = args[i]
436 if not e isa ANamedargExpr then continue
437 var name = e.n_id.text
438 var param = msignature.mparameter_by_name(name)
439 if param == null then
440 modelbuilder.error(e.n_id, "Error: no parameter `{name}` for `{mproperty}{msignature}`.")
441 return null
442 end
443 if not param.is_default then
444 modelbuilder.error(e, "Error: parameter `{name}` is not optional for `{mproperty}{msignature}`.")
445 return null
446 end
447 var idx = msignature.mparameters.index_of(param)
448 var prev = map.map.get_or_null(idx)
449 if prev != null then
450 modelbuilder.error(e, "Error: parameter `{name}` already associated with argument #{prev} for `{mproperty}{msignature}`.")
451 return null
452 end
453 map.map[idx] = i
454 setted -= 1
455 e.mtype = self.visit_expr_subtype(e.n_expr, param.mtype)
456 end
457
458 # Second, associate remaining parameters
459 var vararg_decl = args.length - msignature.arity
460 var j = 0
461 for i in [0..msignature.arity[ do
462 # Skip parameters associated by name
463 if map.map.has_key(i) then continue
464
465 var param = msignature.mparameters[i]
466 if param.is_default then
467 if setted > 0 then
468 setted -= 1
469 else
470 continue
471 end
472 end
473
474 # Search the next free argument: skip named arguments since they are already associated
475 while args[j] isa ANamedargExpr do j += 1
476 var arg = args[j]
477 map.map[i] = j
478 j += 1
479
480 if i == vararg_rank then
481 j += vararg_decl
482 continue # skip the vararg
483 end
484
485 var paramtype = param.mtype
486 self.visit_expr_subtype(arg, paramtype)
487 end
488
489 # Third, check varargs
490 if vararg_rank >= 0 then
491 var paramtype = msignature.mparameters[vararg_rank].mtype
492 var first = args[vararg_rank]
493 if vararg_decl == 0 then
494 var mclass = get_mclass(node, "Array")
495 if mclass == null then return null # Forward error
496 var array_mtype = mclass.get_mtype([paramtype])
497 if first isa AVarargExpr then
498 self.visit_expr_subtype(first.n_expr, array_mtype)
499 first.mtype = first.n_expr.mtype
500 else
501 # only one vararg, maybe `...` was forgot, so be gentle!
502 var t = visit_expr(first)
503 if t == null then return null # Forward error
504 if not is_subtype(t, paramtype) and is_subtype(t, array_mtype) then
505 # Not acceptable but could be a `...`
506 error(first, "Type Error: expected `{paramtype}`, got `{t}`. Is an ellipsis `...` missing on the argument?")
507 return null
508 end
509 # Standard valid vararg, finish the job
510 map.vararg_decl = 1
511 self.visit_expr_subtype(first, paramtype)
512 end
513 else
514 map.vararg_decl = vararg_decl + 1
515 for i in [vararg_rank..vararg_rank+vararg_decl] do
516 self.visit_expr_subtype(args[i], paramtype)
517 end
518 end
519 end
520
521 return map
522 end
523
524 fun error(node: ANode, message: String)
525 do
526 self.modelbuilder.toolcontext.error(node.hot_location, message)
527 end
528
529 fun get_variable(node: AExpr, variable: Variable): nullable MType
530 do
531 if not variable.is_adapted then return variable.declared_type
532
533 var flow = node.after_flow_context
534 if flow == null then return null # skip error
535
536 if flow.vars.has_key(variable) then
537 return flow.vars[variable]
538 else
539 #node.debug("*** START Collected for {variable}")
540 var mtypes = flow.collect_types(variable)
541 #node.debug("**** END Collected for {variable}")
542 if mtypes.length == 0 then
543 return variable.declared_type
544 else if mtypes.length == 1 then
545 return mtypes.first
546 else
547 var res = merge_types(node,mtypes)
548 if res == null then res = variable.declared_type
549 return res
550 end
551 end
552 end
553
554 # Some variables where type-adapted during the visit
555 var dirty = false
556
557 # Some loops had been visited during the visit
558 var has_loop = false
559
560 fun set_variable(node: AExpr, variable: Variable, mtype: nullable MType)
561 do
562 var flow = node.after_flow_context
563 assert flow != null
564
565 flow.set_var(self, variable, mtype)
566 end
567
568 fun merge_types(node: ANode, col: Array[nullable MType]): nullable MType
569 do
570 if col.length == 1 then return col.first
571 for t1 in col do
572 if t1 == null then continue # return null
573 var found = true
574 for t2 in col do
575 if t2 == null then continue # return null
576 if can_be_null(t2) and not can_be_null(t1) then
577 t1 = t1.as_nullable
578 end
579 if not is_subtype(t2, t1) then found = false
580 end
581 if found then
582 #print "merge {col.join(" ")} -> {t1}"
583 return t1
584 end
585 end
586 #self.modelbuilder.warning(node, "Type Error: {col.length} conflicting types: <{col.join(", ")}>")
587 return null
588 end
589 end
590
591 # Mapping between parameters and arguments in a call.
592 #
593 # Parameters and arguments are not stored in the class but referenced by their position (starting from 0)
594 #
595 # The point of this class is to help engine and other things to map arguments in the AST to parameters of the model.
596 class SignatureMap
597 # Associate a parameter to an argument
598 var map = new ArrayMap[Int, Int]
599
600 # The length of the vararg sequence
601 # 0 if no vararg or if reverse vararg (cf `AVarargExpr`)
602 var vararg_decl: Int = 0
603 end
604
605 # A specific method call site with its associated informations.
606 class CallSite
607 # The associated node for location
608 var node: ANode
609
610 # The static type of the receiver (possibly unresolved)
611 var recv: MType
612
613 # The module where the callsite is present
614 var mmodule: MModule
615
616 # The anchor to use with `recv` or `msignature`
617 var anchor: nullable MClassType
618
619 # Is the receiver self?
620 # If "for_self", virtual types of the signature are kept
621 # If "not_for_self", virtual type are erased
622 var recv_is_self: Bool
623
624 # The designated method
625 var mproperty: MMethod
626
627 # The statically designated method definition
628 # The most specif one, it is.
629 var mpropdef: MMethodDef
630
631 # The resolved signature for the receiver
632 var msignature: MSignature
633
634 # Is a implicit cast required on erasure typing policy?
635 var erasure_cast: Bool
636
637 # The mapping used on the call to associate arguments to parameters
638 # If null then no specific association is required.
639 var signaturemap: nullable SignatureMap = null
640
641 private fun check_signature(v: TypeVisitor, args: Array[AExpr]): Bool
642 do
643 var map = v.check_signature(self.node, args, self.mproperty, self.msignature)
644 signaturemap = map
645 return map == null
646 end
647 end
648
649 redef class Variable
650 # The declared type of the variable
651 var declared_type: nullable MType
652
653 # Was the variable type-adapted?
654 # This is used to speedup type retrieval while it remains `false`
655 private var is_adapted = false
656 end
657
658 redef class FlowContext
659 # Store changes of types because of type evolution
660 private var vars = new HashMap[Variable, nullable MType]
661
662 # Adapt the variable to a static type
663 # Warning1: do not modify vars directly.
664 # Warning2: sub-flow may have cached a unadapted variable
665 private fun set_var(v: TypeVisitor, variable: Variable, mtype: nullable MType)
666 do
667 if variable.declared_type == mtype and not variable.is_adapted then return
668 if vars.has_key(variable) and vars[variable] == mtype then return
669 self.vars[variable] = mtype
670 v.dirty = true
671 variable.is_adapted = true
672 #node.debug "set {variable} to {mtype or else "X"}"
673 end
674
675 # Look in the flow and previous flow and collect all first reachable type adaptation of a local variable
676 private fun collect_types(variable: Variable): Array[nullable MType]
677 do
678 #node.debug "flow for {variable}"
679 var res = new Array[nullable MType]
680
681 var todo = [self]
682 var seen = new HashSet[FlowContext]
683 while not todo.is_empty do
684 var f = todo.pop
685 if f.is_unreachable then continue
686 if seen.has(f) then continue
687 seen.add f
688
689 if f.vars.has_key(variable) then
690 # Found something. Collect it and do not process further on this path
691 res.add f.vars[variable]
692 #f.node.debug "process {variable}: got {f.vars[variable] or else "X"}"
693 else
694 todo.add_all f.previous
695 todo.add_all f.loops
696 if f.previous.is_empty then
697 # Root flowcontext mean a parameter or something related
698 res.add variable.declared_type
699 #f.node.debug "root process {variable}: got {variable.declared_type or else "X"}"
700 end
701 end
702 end
703 #self.node.debug "##### end flow for {variable}: {res.join(" ")}"
704 return res
705 end
706 end
707
708 redef class APropdef
709 # The entry point of the whole typing analysis
710 fun do_typing(modelbuilder: ModelBuilder)
711 do
712 end
713
714 # The variable associated to the receiver (if any)
715 var selfvariable: nullable Variable
716 end
717
718 redef class AMethPropdef
719 redef fun do_typing(modelbuilder: ModelBuilder)
720 do
721 var nblock = self.n_block
722 if nblock == null then return
723
724 var mpropdef = self.mpropdef
725 if mpropdef == null then return # skip error
726
727 var v = new TypeVisitor(modelbuilder, mpropdef.mclassdef.mmodule, mpropdef)
728 self.selfvariable = v.selfvariable
729
730 var mmethoddef = self.mpropdef.as(not null)
731 var msignature = mmethoddef.msignature
732 if msignature == null then return # skip error
733 for i in [0..msignature.arity[ do
734 var mtype = msignature.mparameters[i].mtype
735 if msignature.vararg_rank == i then
736 var arrayclass = v.get_mclass(self.n_signature.n_params[i], "Array")
737 if arrayclass == null then return # Skip error
738 mtype = arrayclass.get_mtype([mtype])
739 end
740 var variable = self.n_signature.n_params[i].variable
741 assert variable != null
742 variable.declared_type = mtype
743 end
744
745 loop
746 v.dirty = false
747 v.visit_stmt(nblock)
748 if not v.has_loop or not v.dirty then break
749 end
750
751 if not nblock.after_flow_context.is_unreachable and msignature.return_mtype != null then
752 # We reach the end of the function without having a return, it is bad
753 v.error(self, "Error: reached end of function; expected `return` with a value.")
754 end
755 end
756 end
757
758 redef class AAttrPropdef
759 redef fun do_typing(modelbuilder: ModelBuilder)
760 do
761 if not has_value then return
762
763 var mpropdef = self.mpropdef
764 if mpropdef == null then return # skip error
765
766 var v = new TypeVisitor(modelbuilder, mpropdef.mclassdef.mmodule, mpropdef)
767 self.selfvariable = v.selfvariable
768
769 var nexpr = self.n_expr
770 if nexpr != null then
771 var mtype = self.mpropdef.static_mtype
772 v.visit_expr_subtype(nexpr, mtype)
773 end
774 var nblock = self.n_block
775 if nblock != null then
776 v.visit_stmt(nblock)
777 if not nblock.after_flow_context.is_unreachable then
778 # We reach the end of the init without having a return, it is bad
779 v.error(self, "Error: reached end of block; expected `return`.")
780 end
781 end
782 end
783 end
784
785 ###
786
787 redef class AExpr
788 # The static type of the expression.
789 # null if self is a statement or in case of error
790 var mtype: nullable MType = null
791
792 # Is the statement correctly typed?
793 # Used to distinguish errors and statements when `mtype == null`
794 var is_typed: Bool = false
795
796 # If required, the following implicit cast `.as(XXX)`
797 # Such a cast may by required after evaluating the expression when
798 # a unsafe operation is detected (silently accepted by the Nit language).
799 # The attribute is computed by `check_subtype`
800 var implicit_cast_to: nullable MType = null
801
802 # Return the variable read (if any)
803 # Used to perform adaptive typing
804 fun its_variable: nullable Variable do return null
805
806 private fun accept_typing(v: TypeVisitor)
807 do
808 v.error(self, "no implemented accept_typing for {self.class_name}")
809 end
810
811 # Is non-null if `self` is a leaf of a comprehension array construction.
812 # In this case, the enclosing literal array node is designated.
813 # The result of the evaluation of `self` must be
814 # stored inside the designated array (there is an implicit `push`)
815 var comprehension: nullable AArrayExpr = null
816 end
817
818 redef class ABlockExpr
819 redef fun accept_typing(v)
820 do
821 for e in self.n_expr do v.visit_stmt(e)
822 self.is_typed = true
823 end
824
825 # The type of a blockexpr is the one of the last expression (or null if empty)
826 redef fun mtype
827 do
828 if self.n_expr.is_empty then return null
829 return self.n_expr.last.mtype
830 end
831 end
832
833 redef class AVardeclExpr
834 redef fun accept_typing(v)
835 do
836 var variable = self.variable
837 if variable == null then return # Skip error
838
839 var ntype = self.n_type
840 var mtype: nullable MType
841 if ntype == null then
842 mtype = null
843 else
844 mtype = v.resolve_mtype(ntype)
845 if mtype == null then return # Skip error
846 end
847
848 var nexpr = self.n_expr
849 if nexpr != null then
850 if mtype != null then
851 var etype = v.visit_expr_subtype(nexpr, mtype)
852 if etype == mtype then
853 assert ntype != null
854 v.modelbuilder.advice(ntype, "useless-type", "Warning: useless type definition for variable `{variable.name}`")
855 end
856 else
857 mtype = v.visit_expr(nexpr)
858 if mtype == null then return # Skip error
859 end
860 end
861
862 var decltype = mtype
863 if mtype == null or mtype isa MNullType then
864 var objclass = v.get_mclass(self, "Object")
865 if objclass == null then return # skip error
866 decltype = objclass.mclass_type.as_nullable
867 if mtype == null then mtype = decltype
868 end
869
870 variable.declared_type = decltype
871 v.set_variable(self, variable, mtype)
872
873 #debug("var {variable}: {mtype}")
874
875 self.mtype = mtype
876 self.is_typed = true
877 end
878 end
879
880 redef class AVarExpr
881 redef fun its_variable do return self.variable
882 redef fun accept_typing(v)
883 do
884 var variable = self.variable
885 if variable == null then return # Skip error
886
887 var mtype = v.get_variable(self, variable)
888 if mtype != null then
889 #debug("{variable} is {mtype}")
890 else
891 #debug("{variable} is untyped")
892 end
893
894 self.mtype = mtype
895 end
896 end
897
898 redef class AVarAssignExpr
899 redef fun accept_typing(v)
900 do
901 var variable = self.variable
902 assert variable != null
903
904 var mtype = v.visit_expr_subtype(n_value, variable.declared_type)
905
906 v.set_variable(self, variable, mtype)
907
908 self.is_typed = true
909 end
910 end
911
912 redef class AReassignFormExpr
913 # The method designed by the reassign operator.
914 var reassign_callsite: nullable CallSite
915
916 var read_type: nullable MType = null
917
918 # Determine the `reassign_property`
919 # `readtype` is the type of the reading of the left value.
920 # `writetype` is the type of the writing of the left value.
921 # (Because of `ACallReassignExpr`, both can be different.
922 # Return the static type of the value to store.
923 private fun resolve_reassignment(v: TypeVisitor, readtype, writetype: MType): nullable MType
924 do
925 var reassign_name = self.n_assign_op.operator
926
927 self.read_type = readtype
928
929 var callsite = v.get_method(self.n_assign_op, readtype, reassign_name, false)
930 if callsite == null then return null # Skip error
931 self.reassign_callsite = callsite
932
933 var msignature = callsite.msignature
934 var rettype = msignature.return_mtype
935 assert msignature.arity == 1 and rettype != null
936
937 var value_type = v.visit_expr_subtype(self.n_value, msignature.mparameters.first.mtype)
938 if value_type == null then return null # Skip error
939
940 v.check_subtype(self, rettype, writetype, false)
941 return rettype
942 end
943 end
944
945 redef class AVarReassignExpr
946 redef fun accept_typing(v)
947 do
948 var variable = self.variable
949 assert variable != null
950
951 var readtype = v.get_variable(self, variable)
952 if readtype == null then return
953
954 read_type = readtype
955
956 var writetype = variable.declared_type
957 if writetype == null then return
958
959 var rettype = self.resolve_reassignment(v, readtype, writetype)
960
961 v.set_variable(self, variable, rettype)
962
963 self.is_typed = true
964 end
965 end
966
967
968 redef class AContinueExpr
969 redef fun accept_typing(v)
970 do
971 var nexpr = self.n_expr
972 if nexpr != null then
973 v.visit_expr(nexpr)
974 end
975 self.is_typed = true
976 end
977 end
978
979 redef class ABreakExpr
980 redef fun accept_typing(v)
981 do
982 var nexpr = self.n_expr
983 if nexpr != null then
984 v.visit_expr(nexpr)
985 end
986 self.is_typed = true
987 end
988 end
989
990 redef class AReturnExpr
991 redef fun accept_typing(v)
992 do
993 var nexpr = self.n_expr
994 var ret_type
995 var mpropdef = v.mpropdef
996 if mpropdef isa MMethodDef then
997 ret_type = mpropdef.msignature.return_mtype
998 else if mpropdef isa MAttributeDef then
999 ret_type = mpropdef.static_mtype
1000 else
1001 abort
1002 end
1003 if nexpr != null then
1004 if ret_type != null then
1005 v.visit_expr_subtype(nexpr, ret_type)
1006 else
1007 v.visit_expr(nexpr)
1008 v.error(nexpr, "Error: `return` with value in a procedure.")
1009 end
1010 else if ret_type != null then
1011 v.error(self, "Error: `return` without value in a function.")
1012 end
1013 self.is_typed = true
1014 end
1015 end
1016
1017 redef class AAbortExpr
1018 redef fun accept_typing(v)
1019 do
1020 self.is_typed = true
1021 end
1022 end
1023
1024 redef class AIfExpr
1025 redef fun accept_typing(v)
1026 do
1027 v.visit_expr_bool(n_expr)
1028
1029 v.visit_stmt(n_then)
1030 v.visit_stmt(n_else)
1031
1032 self.is_typed = true
1033
1034 if n_then != null and n_else == null then
1035 self.mtype = n_then.mtype
1036 end
1037 end
1038 end
1039
1040 redef class AIfexprExpr
1041 redef fun accept_typing(v)
1042 do
1043 v.visit_expr_bool(n_expr)
1044
1045 var t1 = v.visit_expr(n_then)
1046 var t2 = v.visit_expr(n_else)
1047
1048 if t1 == null or t2 == null then
1049 return # Skip error
1050 end
1051
1052 var t = v.merge_types(self, [t1, t2])
1053 if t == null then
1054 v.error(self, "Type Error: ambiguous type `{t1}` vs `{t2}`.")
1055 end
1056 self.mtype = t
1057 end
1058 end
1059
1060 redef class ADoExpr
1061 redef fun accept_typing(v)
1062 do
1063 v.visit_stmt(n_block)
1064 self.is_typed = true
1065 end
1066 end
1067
1068 redef class AWhileExpr
1069 redef fun accept_typing(v)
1070 do
1071 v.has_loop = true
1072 v.visit_expr_bool(n_expr)
1073 v.visit_stmt(n_block)
1074 self.is_typed = true
1075 end
1076 end
1077
1078 redef class ALoopExpr
1079 redef fun accept_typing(v)
1080 do
1081 v.has_loop = true
1082 v.visit_stmt(n_block)
1083 self.is_typed = true
1084 end
1085 end
1086
1087 redef class AForExpr
1088 var coltype: nullable MClassType
1089
1090 var method_iterator: nullable CallSite
1091 var method_is_ok: nullable CallSite
1092 var method_item: nullable CallSite
1093 var method_next: nullable CallSite
1094 var method_key: nullable CallSite
1095 var method_finish: nullable CallSite
1096
1097 var method_lt: nullable CallSite
1098 var method_successor: nullable CallSite
1099
1100 private fun do_type_iterator(v: TypeVisitor, mtype: MType)
1101 do
1102 if mtype isa MNullType then
1103 v.error(self, "Type Error: `for` cannot iterate over `null`.")
1104 return
1105 end
1106
1107 # get obj class
1108 var objcla = v.get_mclass(self, "Object")
1109 if objcla == null then return
1110
1111 # check iterator method
1112 var itdef = v.get_method(self, mtype, "iterator", n_expr isa ASelfExpr)
1113 if itdef == null then
1114 v.error(self, "Type Error: `for` expects a type providing an `iterator` method, got `{mtype}`.")
1115 return
1116 end
1117 self.method_iterator = itdef
1118
1119 # check that iterator return something
1120 var ittype = itdef.msignature.return_mtype
1121 if ittype == null then
1122 v.error(self, "Type Error: `for` expects the method `iterator` to return an `Iterator` or `MapIterator` type.")
1123 return
1124 end
1125
1126 # get iterator type
1127 var colit_cla = v.try_get_mclass(self, "Iterator")
1128 var mapit_cla = v.try_get_mclass(self, "MapIterator")
1129 var is_col = false
1130 var is_map = false
1131
1132 if colit_cla != null and v.is_subtype(ittype, colit_cla.get_mtype([objcla.mclass_type.as_nullable])) then
1133 # Iterator
1134 var coltype = ittype.supertype_to(v.mmodule, v.anchor, colit_cla)
1135 var variables = self.variables
1136 if variables.length != 1 then
1137 v.error(self, "Type Error: `for` expects only one variable when using `Iterator`.")
1138 else
1139 variables.first.declared_type = coltype.arguments.first
1140 end
1141 is_col = true
1142 end
1143
1144 if mapit_cla != null and v.is_subtype(ittype, mapit_cla.get_mtype([objcla.mclass_type.as_nullable, objcla.mclass_type.as_nullable])) then
1145 # Map Iterator
1146 var coltype = ittype.supertype_to(v.mmodule, v.anchor, mapit_cla)
1147 var variables = self.variables
1148 if variables.length != 2 then
1149 v.error(self, "Type Error: `for` expects two variables when using `MapIterator`.")
1150 else
1151 variables[0].declared_type = coltype.arguments[0]
1152 variables[1].declared_type = coltype.arguments[1]
1153 end
1154 is_map = true
1155 end
1156
1157 if not is_col and not is_map then
1158 v.error(self, "Type Error: `for` expects the method `iterator` to return an `Iterator` or `MapIterator` type.")
1159 return
1160 end
1161
1162 # anchor formal and virtual types
1163 if mtype.need_anchor then mtype = v.anchor_to(mtype)
1164
1165 mtype = mtype.undecorate
1166 self.coltype = mtype.as(MClassType)
1167
1168 # get methods is_ok, next, item
1169 var ikdef = v.get_method(self, ittype, "is_ok", false)
1170 if ikdef == null then
1171 v.error(self, "Type Error: `for` expects a method `is_ok` in type `{ittype}`.")
1172 return
1173 end
1174 self.method_is_ok = ikdef
1175
1176 var itemdef = v.get_method(self, ittype, "item", false)
1177 if itemdef == null then
1178 v.error(self, "Type Error: `for` expects a method `item` in type `{ittype}`.")
1179 return
1180 end
1181 self.method_item = itemdef
1182
1183 var nextdef = v.get_method(self, ittype, "next", false)
1184 if nextdef == null then
1185 v.error(self, "Type Error: `for` expects a method `next` in type {ittype}.")
1186 return
1187 end
1188 self.method_next = nextdef
1189
1190 self.method_finish = v.try_get_method(self, ittype, "finish", false)
1191
1192 if is_map then
1193 var keydef = v.get_method(self, ittype, "key", false)
1194 if keydef == null then
1195 v.error(self, "Type Error: `for` expects a method `key` in type `{ittype}`.")
1196 return
1197 end
1198 self.method_key = keydef
1199 end
1200
1201 if self.variables.length == 1 and n_expr isa ARangeExpr then
1202 var variable = variables.first
1203 var vtype = variable.declared_type.as(not null)
1204
1205 if n_expr isa AOrangeExpr then
1206 self.method_lt = v.get_method(self, vtype, "<", false)
1207 else
1208 self.method_lt = v.get_method(self, vtype, "<=", false)
1209 end
1210
1211 self.method_successor = v.get_method(self, vtype, "successor", false)
1212 end
1213 end
1214
1215 redef fun accept_typing(v)
1216 do
1217 v.has_loop = true
1218 var mtype = v.visit_expr(n_expr)
1219 if mtype == null then return
1220
1221 self.do_type_iterator(v, mtype)
1222
1223 v.visit_stmt(n_block)
1224
1225 self.mtype = n_block.mtype
1226 self.is_typed = true
1227 end
1228 end
1229
1230 redef class AWithExpr
1231 var method_start: nullable CallSite
1232 var method_finish: nullable CallSite
1233
1234 redef fun accept_typing(v: TypeVisitor)
1235 do
1236 var mtype = v.visit_expr(n_expr)
1237 if mtype == null then return
1238
1239 method_start = v.get_method(self, mtype, "start", n_expr isa ASelfExpr)
1240 method_finish = v.get_method(self, mtype, "finish", n_expr isa ASelfExpr)
1241
1242 v.visit_stmt(n_block)
1243 self.mtype = n_block.mtype
1244 self.is_typed = true
1245 end
1246 end
1247
1248 redef class AAssertExpr
1249 redef fun accept_typing(v)
1250 do
1251 v.visit_expr_bool(n_expr)
1252
1253 v.visit_stmt(n_else)
1254 self.is_typed = true
1255 end
1256 end
1257
1258 redef class AOrExpr
1259 redef fun accept_typing(v)
1260 do
1261 v.visit_expr_bool(n_expr)
1262 v.visit_expr_bool(n_expr2)
1263 self.mtype = v.type_bool(self)
1264 end
1265 end
1266
1267 redef class AImpliesExpr
1268 redef fun accept_typing(v)
1269 do
1270 v.visit_expr_bool(n_expr)
1271 v.visit_expr_bool(n_expr2)
1272 self.mtype = v.type_bool(self)
1273 end
1274 end
1275
1276 redef class AAndExpr
1277 redef fun accept_typing(v)
1278 do
1279 v.visit_expr_bool(n_expr)
1280 v.visit_expr_bool(n_expr2)
1281 self.mtype = v.type_bool(self)
1282 end
1283 end
1284
1285
1286 redef class ANotExpr
1287 redef fun accept_typing(v)
1288 do
1289 v.visit_expr_bool(n_expr)
1290 self.mtype = v.type_bool(self)
1291 end
1292 end
1293
1294 redef class AOrElseExpr
1295 redef fun accept_typing(v)
1296 do
1297 var t1 = v.visit_expr(n_expr)
1298 var t2 = v.visit_expr(n_expr2)
1299
1300 if t1 == null or t2 == null then
1301 return # Skip error
1302 end
1303
1304 if t1 isa MNullType then
1305 v.error(n_expr, "Type Error: `or else` on `null`.")
1306 else if v.check_can_be_null(n_expr, t1) then
1307 t1 = t1.as_notnull
1308 end
1309
1310 var t = v.merge_types(self, [t1, t2])
1311 if t == null then
1312 var c = v.get_mclass(self, "Object")
1313 if c == null then return # forward error
1314 t = c.mclass_type
1315 if v.can_be_null(t2) then
1316 t = t.as_nullable
1317 end
1318 #v.error(self, "Type Error: ambiguous type {t1} vs {t2}")
1319 end
1320 self.mtype = t
1321 end
1322 end
1323
1324 redef class ATrueExpr
1325 redef fun accept_typing(v)
1326 do
1327 self.mtype = v.type_bool(self)
1328 end
1329 end
1330
1331 redef class AFalseExpr
1332 redef fun accept_typing(v)
1333 do
1334 self.mtype = v.type_bool(self)
1335 end
1336 end
1337
1338 redef class AIntExpr
1339 redef fun accept_typing(v)
1340 do
1341 var mclass = v.get_mclass(self, "Int")
1342 if mclass == null then return # Forward error
1343 self.mtype = mclass.mclass_type
1344 end
1345 end
1346
1347 redef class AByteExpr
1348 redef fun accept_typing(v)
1349 do
1350 var mclass = v.get_mclass(self, "Byte")
1351 if mclass == null then return # Forward error
1352 self.mtype = mclass.mclass_type
1353 end
1354 end
1355
1356 redef class AFloatExpr
1357 redef fun accept_typing(v)
1358 do
1359 var mclass = v.get_mclass(self, "Float")
1360 if mclass == null then return # Forward error
1361 self.mtype = mclass.mclass_type
1362 end
1363 end
1364
1365 redef class ACharExpr
1366 redef fun accept_typing(v)
1367 do
1368 var mclass = v.get_mclass(self, "Char")
1369 if mclass == null then return # Forward error
1370 self.mtype = mclass.mclass_type
1371 end
1372 end
1373
1374 redef class AStringFormExpr
1375 redef fun accept_typing(v)
1376 do
1377 var mclass = v.get_mclass(self, "String")
1378 if mclass == null then return # Forward error
1379 self.mtype = mclass.mclass_type
1380 end
1381 end
1382
1383 redef class ASuperstringExpr
1384 redef fun accept_typing(v)
1385 do
1386 var mclass = v.get_mclass(self, "String")
1387 if mclass == null then return # Forward error
1388 self.mtype = mclass.mclass_type
1389 var objclass = v.get_mclass(self, "Object")
1390 if objclass == null then return # Forward error
1391 var objtype = objclass.mclass_type
1392 for nexpr in self.n_exprs do
1393 v.visit_expr_subtype(nexpr, objtype)
1394 end
1395 end
1396 end
1397
1398 redef class AArrayExpr
1399 # The `with_capacity` method on Array
1400 var with_capacity_callsite: nullable CallSite
1401
1402 # The `push` method on arrays
1403 var push_callsite: nullable CallSite
1404
1405 # The element of each type
1406 var element_mtype: nullable MType
1407
1408 # Set that `self` is a part of comprehension array `na`
1409 # If `self` is a `for`, or a `if`, then `set_comprehension` is recursively applied.
1410 private fun set_comprehension(n: nullable AExpr)
1411 do
1412 if n == null then
1413 return
1414 else if n isa AForExpr then
1415 set_comprehension(n.n_block)
1416 else if n isa AIfExpr then
1417 set_comprehension(n.n_then)
1418 set_comprehension(n.n_else)
1419 else
1420 # is a leave
1421 n.comprehension = self
1422 end
1423 end
1424 redef fun accept_typing(v)
1425 do
1426 var mtype: nullable MType = null
1427 var ntype = self.n_type
1428 if ntype != null then
1429 mtype = v.resolve_mtype(ntype)
1430 if mtype == null then return # Skip error
1431 end
1432 var mtypes = new Array[nullable MType]
1433 var useless = false
1434 for e in self.n_exprs do
1435 var t = v.visit_expr(e)
1436 if t == null then
1437 return # Skip error
1438 end
1439 set_comprehension(e)
1440 if mtype != null then
1441 if v.check_subtype(e, t, mtype, false) == null then return # Forward error
1442 if t == mtype then useless = true
1443 else
1444 mtypes.add(t)
1445 end
1446 end
1447 if mtype == null then
1448 # Ensure monotony for type adaptation on loops
1449 if self.element_mtype != null then mtypes.add self.element_mtype
1450 mtype = v.merge_types(self, mtypes)
1451 end
1452 if mtype == null or mtype isa MNullType then
1453 v.error(self, "Type Error: ambiguous array type {mtypes.join(" ")}")
1454 return
1455 end
1456 if useless then
1457 assert ntype != null
1458 v.modelbuilder.warning(ntype, "useless-type", "Warning: useless type declaration `{mtype}` in literal Array since it can be inferred from the elements type.")
1459 end
1460
1461 self.element_mtype = mtype
1462
1463 var mclass = v.get_mclass(self, "Array")
1464 if mclass == null then return # Forward error
1465 var array_mtype = mclass.get_mtype([mtype])
1466
1467 with_capacity_callsite = v.get_method(self, array_mtype, "with_capacity", false)
1468 push_callsite = v.get_method(self, array_mtype, "push", false)
1469
1470 self.mtype = array_mtype
1471 end
1472 end
1473
1474 redef class ARangeExpr
1475 var init_callsite: nullable CallSite
1476
1477 redef fun accept_typing(v)
1478 do
1479 var discrete_class = v.get_mclass(self, "Discrete")
1480 if discrete_class == null then return # Forward error
1481 var discrete_type = discrete_class.intro.bound_mtype
1482 var t1 = v.visit_expr_subtype(self.n_expr, discrete_type)
1483 var t2 = v.visit_expr_subtype(self.n_expr2, discrete_type)
1484 if t1 == null or t2 == null then return
1485 var mclass = v.get_mclass(self, "Range")
1486 if mclass == null then return # Forward error
1487 var mtype
1488 if v.is_subtype(t1, t2) then
1489 mtype = mclass.get_mtype([t2])
1490 else if v.is_subtype(t2, t1) then
1491 mtype = mclass.get_mtype([t1])
1492 else
1493 v.error(self, "Type Error: cannot create range: `{t1}` vs `{t2}`.")
1494 return
1495 end
1496
1497 self.mtype = mtype
1498
1499 # get the constructor
1500 var callsite
1501 if self isa ACrangeExpr then
1502 callsite = v.get_method(self, mtype, "init", false)
1503 else if self isa AOrangeExpr then
1504 callsite = v.get_method(self, mtype, "without_last", false)
1505 else
1506 abort
1507 end
1508 init_callsite = callsite
1509 end
1510 end
1511
1512 redef class ANullExpr
1513 redef fun accept_typing(v)
1514 do
1515 self.mtype = v.mmodule.model.null_type
1516 end
1517 end
1518
1519 redef class AIsaExpr
1520 # The static type to cast to.
1521 # (different from the static type of the expression that is `Bool`).
1522 var cast_type: nullable MType
1523 redef fun accept_typing(v)
1524 do
1525 var mtype = v.visit_expr_cast(self, self.n_expr, self.n_type)
1526 self.cast_type = mtype
1527
1528 var variable = self.n_expr.its_variable
1529 if variable != null then
1530 #var orig = self.n_expr.mtype
1531 #var from = if orig != null then orig.to_s else "invalid"
1532 #var to = if mtype != null then mtype.to_s else "invalid"
1533 #debug("adapt {variable}: {from} -> {to}")
1534 self.after_flow_context.when_true.set_var(v, variable, mtype)
1535 end
1536
1537 self.mtype = v.type_bool(self)
1538 end
1539 end
1540
1541 redef class AAsCastExpr
1542 redef fun accept_typing(v)
1543 do
1544 self.mtype = v.visit_expr_cast(self, self.n_expr, self.n_type)
1545 end
1546 end
1547
1548 redef class AAsNotnullExpr
1549 redef fun accept_typing(v)
1550 do
1551 var mtype = v.visit_expr(self.n_expr)
1552 if mtype == null then return # Forward error
1553
1554 if mtype isa MNullType then
1555 v.error(self, "Type Error: `as(not null)` on `null`.")
1556 return
1557 end
1558
1559 if v.check_can_be_null(n_expr, mtype) then
1560 mtype = mtype.as_notnull
1561 end
1562
1563 self.mtype = mtype
1564 end
1565 end
1566
1567 redef class AParExpr
1568 redef fun accept_typing(v)
1569 do
1570 self.mtype = v.visit_expr(self.n_expr)
1571 end
1572 end
1573
1574 redef class AOnceExpr
1575 redef fun accept_typing(v)
1576 do
1577 self.mtype = v.visit_expr(self.n_expr)
1578 end
1579 end
1580
1581 redef class ASelfExpr
1582 redef var its_variable: nullable Variable
1583 redef fun accept_typing(v)
1584 do
1585 if v.is_toplevel_context and not self isa AImplicitSelfExpr then
1586 v.error(self, "Error: `self` cannot be used in top-level method.")
1587 end
1588 var variable = v.selfvariable
1589 self.its_variable = variable
1590 self.mtype = v.get_variable(self, variable)
1591 end
1592 end
1593
1594 redef class AImplicitSelfExpr
1595 # Is the implicit receiver `sys`?
1596 #
1597 # By default, the implicit receiver is `self`.
1598 # But when there is not method for `self`, `sys` is used as a fall-back.
1599 # Is this case this flag is set to `true`.
1600 var is_sys = false
1601 end
1602
1603 ## MESSAGE SENDING AND PROPERTY
1604
1605 redef class ASendExpr
1606 # The property invoked by the send.
1607 var callsite: nullable CallSite
1608
1609 redef fun accept_typing(v)
1610 do
1611 var nrecv = self.n_expr
1612 var recvtype = v.visit_expr(nrecv)
1613 var name = self.property_name
1614 var node = self.property_node
1615
1616 if recvtype == null then return # Forward error
1617
1618 var callsite = null
1619 var unsafe_type = v.anchor_to(recvtype)
1620 var mproperty = v.try_get_mproperty_by_name2(node, unsafe_type, name)
1621 if mproperty == null and nrecv isa AImplicitSelfExpr then
1622 # Special fall-back search in `sys` when noting found in the implicit receiver.
1623 var sysclass = v.try_get_mclass(node, "Sys")
1624 if sysclass != null then
1625 var systype = sysclass.mclass_type
1626 mproperty = v.try_get_mproperty_by_name2(node, systype, name)
1627 if mproperty != null then
1628 callsite = v.get_method(node, systype, name, false)
1629 if callsite == null then return # Forward error
1630 # Update information, we are looking at `sys` now, not `self`
1631 nrecv.is_sys = true
1632 nrecv.its_variable = null
1633 nrecv.mtype = systype
1634 recvtype = systype
1635 end
1636 end
1637 end
1638 if callsite == null then
1639 # If still nothing, just exit
1640 callsite = v.get_method(node, recvtype, name, nrecv isa ASelfExpr)
1641 if callsite == null then return
1642 end
1643
1644 self.callsite = callsite
1645 var msignature = callsite.msignature
1646
1647 var args = compute_raw_arguments
1648
1649 callsite.check_signature(v, args)
1650
1651 if callsite.mproperty.is_init then
1652 var vmpropdef = v.mpropdef
1653 if not (vmpropdef isa MMethodDef and vmpropdef.mproperty.is_init) then
1654 v.error(node, "Error: an `init` can only be called from another `init`.")
1655 end
1656 if vmpropdef isa MMethodDef and vmpropdef.mproperty.is_root_init and not callsite.mproperty.is_root_init then
1657 v.error(node, "Error: `{vmpropdef}` cannot call a factory `{callsite.mproperty}`.")
1658 end
1659 end
1660
1661 var ret = msignature.return_mtype
1662 if ret != null then
1663 self.mtype = ret
1664 else
1665 self.is_typed = true
1666 end
1667 end
1668
1669 # The name of the property
1670 # Each subclass simply provide the correct name.
1671 private fun property_name: String is abstract
1672
1673 # The node identifying the name (id, operator, etc) for messages.
1674 #
1675 # Is `self` by default
1676 private fun property_node: ANode do return self
1677
1678 # An array of all arguments (excluding self)
1679 fun raw_arguments: Array[AExpr] do return compute_raw_arguments
1680
1681 private fun compute_raw_arguments: Array[AExpr] is abstract
1682 end
1683
1684 redef class ABinopExpr
1685 redef fun compute_raw_arguments do return [n_expr2]
1686 redef fun property_name do return operator
1687 redef fun property_node do return n_op
1688 end
1689 redef class AEqExpr
1690 redef fun accept_typing(v)
1691 do
1692 super
1693 v.null_test(self)
1694 end
1695 end
1696 redef class ANeExpr
1697 redef fun accept_typing(v)
1698 do
1699 super
1700 v.null_test(self)
1701 end
1702 end
1703
1704 redef class AUnaryopExpr
1705 redef fun property_name do return "unary {operator}"
1706 redef fun compute_raw_arguments do return new Array[AExpr]
1707 end
1708
1709
1710 redef class ACallExpr
1711 redef fun property_name do return n_id.text
1712 redef fun property_node do return n_id
1713 redef fun compute_raw_arguments do return n_args.to_a
1714 end
1715
1716 redef class ACallAssignExpr
1717 redef fun property_name do return n_id.text + "="
1718 redef fun property_node do return n_id
1719 redef fun compute_raw_arguments
1720 do
1721 var res = n_args.to_a
1722 res.add(n_value)
1723 return res
1724 end
1725 end
1726
1727 redef class ABraExpr
1728 redef fun property_name do return "[]"
1729 redef fun compute_raw_arguments do return n_args.to_a
1730 end
1731
1732 redef class ABraAssignExpr
1733 redef fun property_name do return "[]="
1734 redef fun compute_raw_arguments
1735 do
1736 var res = n_args.to_a
1737 res.add(n_value)
1738 return res
1739 end
1740 end
1741
1742 redef class ASendReassignFormExpr
1743 # The property invoked for the writing
1744 var write_callsite: nullable CallSite
1745
1746 redef fun accept_typing(v)
1747 do
1748 var recvtype = v.visit_expr(self.n_expr)
1749 var name = self.property_name
1750 var node = self.property_node
1751
1752 if recvtype == null then return # Forward error
1753
1754 var for_self = self.n_expr isa ASelfExpr
1755 var callsite = v.get_method(node, recvtype, name, for_self)
1756
1757 if callsite == null then return
1758 self.callsite = callsite
1759
1760 var args = compute_raw_arguments
1761
1762 callsite.check_signature(v, args)
1763
1764 var readtype = callsite.msignature.return_mtype
1765 if readtype == null then
1766 v.error(node, "Error: `{name}` is not a function.")
1767 return
1768 end
1769
1770 var wcallsite = v.get_method(node, recvtype, name + "=", self.n_expr isa ASelfExpr)
1771 if wcallsite == null then return
1772 self.write_callsite = wcallsite
1773
1774 var wtype = self.resolve_reassignment(v, readtype, wcallsite.msignature.mparameters.last.mtype)
1775 if wtype == null then return
1776
1777 args = args.to_a # duplicate so raw_arguments keeps only the getter args
1778 args.add(self.n_value)
1779 wcallsite.check_signature(v, args)
1780
1781 self.is_typed = true
1782 end
1783 end
1784
1785 redef class ACallReassignExpr
1786 redef fun property_name do return n_id.text
1787 redef fun property_node do return n_id
1788 redef fun compute_raw_arguments do return n_args.to_a
1789 end
1790
1791 redef class ABraReassignExpr
1792 redef fun property_name do return "[]"
1793 redef fun compute_raw_arguments do return n_args.to_a
1794 end
1795
1796 redef class AInitExpr
1797 redef fun property_name do return "init"
1798 redef fun property_node do return n_kwinit
1799 redef fun compute_raw_arguments do return n_args.to_a
1800 end
1801
1802 redef class AExprs
1803 fun to_a: Array[AExpr] do return self.n_exprs.to_a
1804 end
1805
1806 ###
1807
1808 redef class ASuperExpr
1809 # The method to call if the super is in fact a 'super init call'
1810 # Note: if the super is a normal call-next-method, then this attribute is null
1811 var callsite: nullable CallSite
1812
1813 # The method to call is the super is a standard `call-next-method` super-call
1814 # Note: if the super is a special super-init-call, then this attribute is null
1815 var mpropdef: nullable MMethodDef
1816
1817 redef fun accept_typing(v)
1818 do
1819 var anchor = v.anchor
1820 assert anchor != null
1821 var recvtype = v.get_variable(self, v.selfvariable)
1822 assert recvtype != null
1823 var mproperty = v.mpropdef.mproperty
1824 if not mproperty isa MMethod then
1825 v.error(self, "Error: `super` only usable in a `method`.")
1826 return
1827 end
1828 var superprops = mproperty.lookup_super_definitions(v.mmodule, anchor)
1829 if superprops.length == 0 then
1830 if mproperty.is_init and v.mpropdef.is_intro then
1831 process_superinit(v)
1832 return
1833 end
1834 v.error(self, "Error: no super method to call for `{mproperty}`.")
1835 return
1836 end
1837 # FIXME: covariance of return type in linear extension?
1838 var superprop = superprops.first
1839
1840 var msignature = superprop.msignature.as(not null)
1841 msignature = v.resolve_for(msignature, recvtype, true).as(MSignature)
1842 var args = self.n_args.to_a
1843 if args.length > 0 then
1844 signaturemap = v.check_signature(self, args, mproperty, msignature)
1845 end
1846 self.mtype = msignature.return_mtype
1847 self.is_typed = true
1848 v.mpropdef.has_supercall = true
1849 mpropdef = v.mpropdef.as(MMethodDef)
1850 end
1851
1852 # The mapping used on the call to associate arguments to parameters.
1853 # If null then no specific association is required.
1854 var signaturemap: nullable SignatureMap
1855
1856 private fun process_superinit(v: TypeVisitor)
1857 do
1858 var anchor = v.anchor
1859 assert anchor != null
1860 var recvtype = v.get_variable(self, v.selfvariable)
1861 assert recvtype != null
1862 var mpropdef = v.mpropdef
1863 assert mpropdef isa MMethodDef
1864 var mproperty = mpropdef.mproperty
1865 var superprop: nullable MMethodDef = null
1866 for msupertype in mpropdef.mclassdef.supertypes do
1867 msupertype = msupertype.anchor_to(v.mmodule, anchor)
1868 var errcount = v.modelbuilder.toolcontext.error_count
1869 var candidate = v.try_get_mproperty_by_name2(self, msupertype, mproperty.name).as(nullable MMethod)
1870 if candidate == null then
1871 if v.modelbuilder.toolcontext.error_count > errcount then return # Forward error
1872 continue # Try next super-class
1873 end
1874 if superprop != null and candidate.is_root_init then
1875 continue
1876 end
1877 if superprop != null and superprop.mproperty != candidate and not superprop.mproperty.is_root_init then
1878 v.error(self, "Error: conflicting super constructor to call for `{mproperty}`: `{candidate.full_name}`, `{superprop.mproperty.full_name}`")
1879 return
1880 end
1881 var candidatedefs = candidate.lookup_definitions(v.mmodule, anchor)
1882 if superprop != null and superprop.mproperty == candidate then
1883 if superprop == candidatedefs.first then continue
1884 candidatedefs.add(superprop)
1885 end
1886 if candidatedefs.length > 1 then
1887 v.error(self, "Error: conflicting property definitions for property `{mproperty}` in `{recvtype}`: {candidatedefs.join(", ")}")
1888 return
1889 end
1890 superprop = candidatedefs.first
1891 end
1892 if superprop == null then
1893 v.error(self, "Error: no super method to call for `{mproperty}`.")
1894 return
1895 end
1896
1897 var msignature = superprop.new_msignature or else superprop.msignature.as(not null)
1898 msignature = v.resolve_for(msignature, recvtype, true).as(MSignature)
1899
1900 var callsite = new CallSite(self, recvtype, v.mmodule, v.anchor, true, superprop.mproperty, superprop, msignature, false)
1901 self.callsite = callsite
1902
1903 var args = self.n_args.to_a
1904 if args.length > 0 then
1905 callsite.check_signature(v, args)
1906 else
1907 # Check there is at least enough parameters
1908 if mpropdef.msignature.arity < msignature.arity then
1909 v.error(self, "Error: not enough implicit arguments to pass. Got `{mpropdef.msignature.arity}`, expected at least `{msignature.arity}`. Signature is `{msignature}`.")
1910 return
1911 end
1912 # Check that each needed parameter is conform
1913 var i = 0
1914 for sp in msignature.mparameters do
1915 var p = mpropdef.msignature.mparameters[i]
1916 if not v.is_subtype(p.mtype, sp.mtype) then
1917 v.error(self, "Type Error: expected argument #{i} of type `{sp.mtype}`, got implicit argument `{p.name}` of type `{p.mtype}`. Signature is {msignature}")
1918 return
1919 end
1920 i += 1
1921 end
1922 end
1923
1924 self.is_typed = true
1925 end
1926 end
1927
1928 ####
1929
1930 redef class ANewExpr
1931 # The constructor invoked by the new.
1932 var callsite: nullable CallSite
1933
1934 # The designated type
1935 var recvtype: nullable MClassType
1936
1937 redef fun accept_typing(v)
1938 do
1939 var recvtype = v.resolve_mtype(self.n_type)
1940 if recvtype == null then return
1941
1942 if not recvtype isa MClassType then
1943 if recvtype isa MNullableType then
1944 v.error(self, "Type Error: cannot instantiate the nullable type `{recvtype}`.")
1945 return
1946 else if recvtype isa MFormalType then
1947 v.error(self, "Type Error: cannot instantiate the formal type `{recvtype}`.")
1948 return
1949 else
1950 v.error(self, "Type Error: cannot instantiate the type `{recvtype}`.")
1951 return
1952 end
1953 end
1954
1955 self.recvtype = recvtype
1956 var kind = recvtype.mclass.kind
1957
1958 var name: String
1959 var nid = self.n_id
1960 var node: ANode
1961 if nid != null then
1962 name = nid.text
1963 node = nid
1964 else
1965 name = "new"
1966 node = self.n_kwnew
1967 end
1968 if name == "intern" then
1969 if kind != concrete_kind then
1970 v.error(self, "Type Error: cannot instantiate {kind} {recvtype}.")
1971 return
1972 end
1973 if n_args.n_exprs.not_empty then
1974 v.error(n_args, "Type Error: the intern constructor expects no arguments.")
1975 return
1976 end
1977 # Our job is done
1978 self.mtype = recvtype
1979 return
1980 end
1981
1982 var callsite = v.get_method(node, recvtype, name, false)
1983 if callsite == null then return
1984
1985 if not callsite.mproperty.is_new then
1986 if kind != concrete_kind then
1987 v.error(self, "Type Error: cannot instantiate {kind} `{recvtype}`.")
1988 return
1989 end
1990 self.mtype = recvtype
1991 else
1992 self.mtype = callsite.msignature.return_mtype
1993 assert self.mtype != null
1994 end
1995
1996 self.callsite = callsite
1997
1998 if not callsite.mproperty.is_init_for(recvtype.mclass) then
1999 v.error(self, "Error: `{name}` is not a constructor.")
2000 return
2001 end
2002
2003 var args = n_args.to_a
2004 callsite.check_signature(v, args)
2005 end
2006 end
2007
2008 ####
2009
2010 redef class AAttrFormExpr
2011 # The attribute accessed.
2012 var mproperty: nullable MAttribute
2013
2014 # The static type of the attribute.
2015 var attr_type: nullable MType
2016
2017 # Resolve the attribute accessed.
2018 private fun resolve_property(v: TypeVisitor)
2019 do
2020 var recvtype = v.visit_expr(self.n_expr)
2021 if recvtype == null then return # Skip error
2022 var node = self.n_id
2023 var name = node.text
2024 if recvtype isa MNullType then
2025 v.error(node, "Error: attribute `{name}` access on `null`.")
2026 return
2027 end
2028
2029 var unsafe_type = v.anchor_to(recvtype)
2030 var mproperty = v.try_get_mproperty_by_name2(node, unsafe_type, name)
2031 if mproperty == null then
2032 v.modelbuilder.error(node, "Error: attribute `{name}` does not exist in `{recvtype}`.")
2033 return
2034 end
2035 assert mproperty isa MAttribute
2036 self.mproperty = mproperty
2037
2038 var mpropdefs = mproperty.lookup_definitions(v.mmodule, unsafe_type)
2039 assert mpropdefs.length == 1
2040 var mpropdef = mpropdefs.first
2041 var attr_type = mpropdef.static_mtype
2042 if attr_type == null then return # skip error
2043 attr_type = v.resolve_for(attr_type, recvtype, self.n_expr isa ASelfExpr)
2044 self.attr_type = attr_type
2045 end
2046 end
2047
2048 redef class AAttrExpr
2049 redef fun accept_typing(v)
2050 do
2051 self.resolve_property(v)
2052 self.mtype = self.attr_type
2053 end
2054 end
2055
2056
2057 redef class AAttrAssignExpr
2058 redef fun accept_typing(v)
2059 do
2060 self.resolve_property(v)
2061 var mtype = self.attr_type
2062
2063 v.visit_expr_subtype(self.n_value, mtype)
2064 self.is_typed = true
2065 end
2066 end
2067
2068 redef class AAttrReassignExpr
2069 redef fun accept_typing(v)
2070 do
2071 self.resolve_property(v)
2072 var mtype = self.attr_type
2073 if mtype == null then return # Skip error
2074
2075 self.resolve_reassignment(v, mtype, mtype)
2076
2077 self.is_typed = true
2078 end
2079 end
2080
2081 redef class AIssetAttrExpr
2082 redef fun accept_typing(v)
2083 do
2084 self.resolve_property(v)
2085 var mtype = self.attr_type
2086 if mtype == null then return # Skip error
2087
2088 var recvtype = self.n_expr.mtype.as(not null)
2089 var bound = v.resolve_for(mtype, recvtype, false)
2090 if bound isa MNullableType then
2091 v.error(n_id, "Type Error: `isset` on a nullable attribute.")
2092 end
2093 self.mtype = v.type_bool(self)
2094 end
2095 end
2096
2097 redef class AVarargExpr
2098 redef fun accept_typing(v)
2099 do
2100 # This kind of pseudo-expression can be only processed trough a signature
2101 # See `check_signature`
2102 # Other cases are a syntax error.
2103 v.error(self, "Syntax Error: unexpected `...`.")
2104 end
2105 end
2106
2107 ###
2108
2109 redef class ADebugTypeExpr
2110 redef fun accept_typing(v)
2111 do
2112 var expr = v.visit_expr(self.n_expr)
2113 if expr == null then return
2114 var unsafe = v.anchor_to(expr)
2115 var ntype = self.n_type
2116 var mtype = v.resolve_mtype(ntype)
2117 if mtype != null and mtype != expr then
2118 var umtype = v.anchor_to(mtype)
2119 v.modelbuilder.warning(self, "debug", "Found type {expr} (-> {unsafe}), expected {mtype} (-> {umtype})")
2120 end
2121 self.is_typed = true
2122 end
2123 end