1 # This file is part of NIT ( http://www.nitlanguage.org ).
3 # Copyright 2008 Jean Privat <jean@pryen.org>
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
9 # http://www.apache.org/licenses/LICENSE-2.0
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.
17 # Common syntax structures for syntax analysis of NIT AST.
23 # Concrete NIT source module
26 # The related AST node
27 readable var _node
: AModule
29 # Concrete NIT source local classs by name
30 readable var _src_local_classes
: Map[Symbol, MMSrcLocalClass]
32 init(c
: MMContext, source
: AModule, dir
: MMDirectory, name
: Symbol, filename
: String)
34 super(name
, dir
, c
, filename
)
36 _src_local_classes
= new HashMap[Symbol, MMSrcLocalClass]
40 redef class MMGlobalClass
41 # Check that a module can access a class
42 fun check_visibility
(v
: AbsSyntaxVisitor, n
: PNode, cm
: MMSrcModule): Bool do
44 assert pm
isa MMSrcModule
45 var vpm
= cm
.visibility_for
(pm
)
49 v
.error
(n
, "Visibility error: Class {self} comes from the hidden module {cm}.") # TODO: should not occur
51 else if visibility_level
>= 3 then
52 v
.error
(n
, "Visibility error: Class {self} is private.")
59 # Concrete NIT source local classes
61 special MMConcreteClass
62 # The related AST nodes
63 readable var _nodes
: Array[PClassdef]
65 # Concrete NIT source generic formal parameter by name
66 readable var _formal_dict
: Map[Symbol, MMTypeFormalParameter] = new HashMap[Symbol, MMTypeFormalParameter]
68 # Concrete NIT source properties by name
69 readable var _src_local_properties
: Map[Symbol, MMLocalProperty]
71 init(mod
: MMSrcModule, n
: Symbol, cla
: PClassdef, a
: Int)
75 _src_local_properties
= new HashMap[Symbol, MMLocalProperty]
79 redef class MMGlobalProperty
80 # Check that a module can access a property
81 fun check_visibility
(v
: AbsSyntaxVisitor, n
: PNode, cm
: MMSrcModule, allows_protected
: Bool): Bool do
82 var pm
= local_class
.module
83 assert pm
isa MMSrcModule
84 var vpm
= cm
.visibility_for
(pm
)
88 # TODO: should not occurs
89 v
.error
(n
, "Visibility error: Property {self} comes from the hidden module {cm}.")
91 else if visibility_level
>= 3 then
92 v
.error
(n
, "Visibility error: Property {self} is private.")
94 else if visibility_level
>= 2 and not allows_protected
then
95 v
.error
(n
, "Visibility error: Property {self} is protected and can only acceded by self.")
102 redef class MMLocalProperty
103 # The attached node (if any)
104 fun node
: nullable PNode do return null
106 # Is the concrete method defined as init
107 fun is_init
: Bool do return false
110 # Concrete NIT source attribute
113 redef readable var _node
: AAttrPropdef
114 init(name
: Symbol, cla
: MMLocalClass, n
: AAttrPropdef)
121 # Concrete NIT source method
126 # Concrete NIT source method for an automatic accesor
127 class MMAttrImplementationMethod
129 redef readable var _node
: AAttrPropdef
130 init(name
: Symbol, cla
: MMLocalClass, n
: AAttrPropdef)
137 # Concrete NIT source method for an automatic read accesor
138 class MMReadImplementationMethod
139 special MMAttrImplementationMethod
140 init(name
: Symbol, cla
: MMLocalClass, n
: AAttrPropdef)
146 # Concrete NIT source method for an automatic write accesor
147 class MMWriteImplementationMethod
148 special MMAttrImplementationMethod
149 init(name
: Symbol, cla
: MMLocalClass, n
: AAttrPropdef)
155 # Concrete NIT source method for an explicit method
156 class MMMethSrcMethod
158 redef fun is_init
do return _node
isa AConcreteInitPropdef
159 redef readable var _node
: nullable AMethPropdef
160 init(name
: Symbol, cla
: MMLocalClass, n
: nullable AMethPropdef)
167 # Concrete NIT source virtual type
168 class MMSrcTypeProperty
169 special MMLocalProperty
170 special MMTypeProperty
171 redef readable var _node
: ATypePropdef
172 init(name
: Symbol, cla
: MMLocalClass, n
: ATypePropdef)
179 # Concrete NIT implicit constructor
181 special MMMethSrcMethod
182 redef fun is_init
do return true
183 readable var _unassigned_attributes
: Array[MMSrcAttribute]
184 readable var _super_inits
: Array[MMLocalProperty]
185 init(cla
: MMLocalClass, unassigned_attributes
: Array[MMSrcAttribute], super_inits
: Array[MMLocalProperty])
187 super(once
"init".to_symbol
, cla
, null)
188 _unassigned_attributes
= unassigned_attributes
189 _super_inits
= super_inits
194 abstract class Variable
195 # Name of the variable
196 readable var _name
: Symbol
198 # Declaration AST node
199 readable var _decl
: nullable PNode
202 readable writable var _stype
: nullable MMType
204 redef fun to_s
do return _name
.to_s
206 fun kind
: String is abstract
208 init(n
: Symbol, d
: nullable PNode)
215 # Variable declared with 'var'
218 redef fun kind
do return once
"variable"
219 init(n
: Symbol, d
: PNode) do super
222 # Parameter of method (declared in signature)
225 redef fun kind
do return once
"parameter"
226 init(n
: Symbol, d
: nullable PNode) do super
229 # Automatic variable (like in the 'for' statement)
232 redef fun kind
do return once
"automatic variable"
233 init(n
: Symbol, d
: PNode) do super
236 # False variable corresponding to closures declared in signatures
237 # Lives in the same namespace than variables
238 class ClosureVariable
240 redef fun kind
do return once
"closure"
242 # The signature of the closure
243 readable var _closure
: MMClosure
245 init(n
: Symbol, d
: PNode, c
: MMClosure)
252 ###############################################################################
254 # Visitor used during the syntax analysis
255 class AbsSyntaxVisitor
257 # The root type Object
258 fun type_object
: MMType
260 return _module
.class_by_name
(once
("Object".to_symbol
)).get_type
263 # The primitive type Bool
264 fun type_bool
: MMType
266 return _module
.class_by_name
(once
("Bool".to_symbol
)).get_type
269 # The primitive type Int
272 return _module
.class_by_name
(once
("Int".to_symbol
)).get_type
275 # The primitive type Float
276 fun type_float
: MMType
278 return _module
.class_by_name
(once
("Float".to_symbol
)).get_type
281 # The primitive type Char
282 fun type_char
: MMType
284 return _module
.class_by_name
(once
("Char".to_symbol
)).get_type
287 # The primitive type String
288 fun type_string
: MMType
290 return _module
.class_by_name
(once
("String".to_symbol
)).get_type
293 # The primitive type Collection[nullable Object]
294 fun type_collection
: MMType
296 return _module
.class_by_name
(once
("Collection".to_symbol
)).get_instantiate_type
([type_object
.as_nullable
])
299 # The primitive type Array[?]
300 fun type_array
(stype
: MMType): MMType
302 return _module
.class_by_name
(once
("Array".to_symbol
)).get_instantiate_type
([stype
])
305 # The primitive type Discrete
306 fun type_discrete
: MMType
308 return _module
.class_by_name
(once
("Discrete".to_symbol
)).get_type
311 # The primitive type Range[?]
312 fun type_range
(stype
: MMType): MMType
314 return _module
.class_by_name
(once
("Range".to_symbol
)).get_instantiate_type
([stype
])
317 # The primitive type of null
318 fun type_none
: MMType
320 return _module
.type_none
324 readable var _module
: MMSrcModule
327 fun local_class
: MMSrcLocalClass do return _local_class
.as(not null)
328 writable var _local_class
: nullable MMSrcLocalClass
330 # The current property
331 fun local_property
: MMLocalProperty do return _local_property
.as(not null)
332 writable var _local_property
: nullable MMLocalProperty
334 # The current tool configuration/status
335 readable var _tc
: ToolContext
337 # Display an error for a given syntax node
338 fun error
(n
: nullable PNode, s
: String)
340 _tc
.error
("{locate(n)}: {s}")
343 # Display a warning for a given syntax node
344 fun warning
(n
: nullable PNode, s
: String)
346 _tc
.warning
("{locate(n)}: {s}")
350 fun locate
(n
: nullable PNode): String
352 if n
!= null then return n
.locate
353 return _module
.filename
356 # Check conformity and display error
357 fun check_conform
(n
: PNode, subtype
: nullable MMType, stype
: nullable MMType): Bool
359 if stype
== null or subtype
== null then
362 if subtype
< stype
then
365 error
(n
, "Type error: expected {stype}, got {subtype}")
369 # Check that an expression has a static type and that
370 # Display an error and return false if n is a statement
371 # Require that the static type of n is known
372 fun check_expr
(n
: PExpr): Bool
374 if not n
.is_typed
then
375 if tc
.error_count
== 0 then
376 print
("{n.locate} not typed but not error")
379 # An error occured in a sub node,
380 # sillently cascade fail
382 else if n
.is_statement
then
383 error
(n
, "Type error: expected expression.")
389 # Combine check_conform and check_expr
390 fun check_conform_expr
(n
: PExpr, stype
: nullable MMType): Bool
392 if stype
== null then return false
393 if check_expr
(n
) then return check_conform
(n
, n
.stype
, stype
) else return false
396 # Check conformance between multiple expressions and a static type
397 # Conformance is granted if among them there is a most general type
398 # Return the most general type if a conformance is found
399 # Display an error and return null if no conformance is found
400 # The only allowed combinaison is with the nullable marker
401 # @param stype is a possible additional type (without node)
403 # Int, Int, Object => return Object
404 # Int, Float => display error, return null
405 # nullable Int, Object => return nullable Object
406 fun check_conform_multiexpr
(stype
: nullable MMType, nodes
: Collection[PExpr]): nullable MMType
408 var node
: nullable PExpr = null # candidate node
410 if not check_expr
(n
) then return null
412 if stype
!= null and stype
.is_nullable
!= ntype
.is_nullable
then
413 # nullable combinaison: if one of them is nulable, considers that both are
414 stype
= stype
.as_nullable
415 ntype
= ntype
.as_nullable
417 if stype
== null or stype
< ntype
then
423 if not n
.stype
< stype
.as(not null) then
425 error
(n
, "Type error: no most general type. Got {n.stype} and {stype}.")
427 error
(n
, "Type error: no most general type. Got {n.stype} and {stype} at {node.locate}.")
435 protected init(tc
: ToolContext, module: MMSrcModule)
442 ###############################################################################
445 protected fun accept_abs_syntax_visitor
(v
: AbsSyntaxVisitor) do visit_all
(v
)
449 var _symbol_cache
: nullable Symbol
451 # Symbol associated with the text
453 fun to_symbol
: Symbol
455 var s
= _symbol_cache
464 redef class PClassdef
465 # Associated class (MM entity)
466 fun local_class
: MMSrcLocalClass is abstract
469 redef class AAttrPropdef
470 # Associated attribute (MM entity)
471 fun prop
: MMSrcAttribute is abstract
473 # Associated read accessor (MM entity)
474 fun readmethod
: nullable MMSrcMethod is abstract
476 # Associated write accessor (MM entity)
477 fun writemethod
: nullable MMSrcMethod is abstract
480 redef class AMethPropdef
481 # Associated method (MM entity)
482 fun method
: MMMethSrcMethod is abstract
484 # Associated 'self' variable
485 fun self_var
: ParamVariable is abstract
488 redef class ATypePropdef
489 # Associated formal type (MM entity)
490 fun prop
: MMSrcTypeProperty is abstract
494 # Position in the signature
495 fun position
: Int is abstract
497 # Associated local variable
498 fun variable
: ParamVariable is abstract
501 redef class PClosureDecl
502 # Associated closure variable
503 fun variable
: ClosureVariable is abstract
507 # Retrieve the local class corresponding to the type.
508 # Display an error and return null if there is no class
509 # Display an error and return null if the type is not class based (formal one)
510 fun get_local_class
(v
: AbsSyntaxVisitor): nullable MMLocalClass is abstract
512 # Retrieve corresponding static type.
513 # Display an error and return null if there is a problem
514 fun get_stype
(v
: AbsSyntaxVisitor): nullable MMType is abstract
516 # Retrieve corresponding static type.
517 # Display an error and return null if there is a problem
518 # But do not performs any subtype check.
519 # get_unchecked_stype should be called to check that the static type is fully valid
520 fun get_unchecked_stype
(v
: AbsSyntaxVisitor): nullable MMType is abstract
522 # Check that a static definition type is conform with regard to formal types
523 # Useful with get_unchecked_stype
524 # Remember that conformance check need that ancestors are totaly computed
525 fun check_conform
(v
: AbsSyntaxVisitor) is abstract
529 var _stype_cache
: nullable MMType = null
530 var _stype_cached
: Bool = false
532 redef fun get_local_class
(v
)
534 var name
= n_id
.to_symbol
536 var cla
= v
.local_class
538 if cla
.formal_dict
.has_key
(name
) or cla
.has_global_property_by_name
(name
) then
539 v
.error
(n_id
, "Type error: {name} is a formal type")
544 if not mod
.has_global_class_named
(name
) then
545 v
.error
(n_id
, "Type error: class {name} not found in module {mod}.")
550 var local_class
= mod
.class_by_name
(name
)
551 local_class
.global
.check_visibility
(v
, self, mod
)
555 redef fun get_unchecked_stype
(v
)
557 if _stype_cached
then return _stype_cache
560 var name
= n_id
.to_symbol
562 var cla
= v
.local_class
563 var t
: nullable MMType
565 if cla
.formal_dict
.has_key
(name
) then
566 if n_types
.length
> 0 then
567 v
.error
(self, "Type error: formal type {name} cannot have formal parameters.")
570 t
= cla
.formal_dict
[name
]
571 if n_kwnullable
!= null then t
= t
.as_nullable
576 if cla
.has_global_property_by_name
(name
) then
577 if n_types
.length
> 0 then
578 v
.error
(self, "Type error: formal type {name} cannot have formal parameters.")
581 t
= cla
.get_type
.local_class
.select_virtual_type
(name
).stype_for
(cla
.get_type
)
583 v
.error
(self, "Type error: circular definition in formal type {name}.")
586 if n_kwnullable
!= null then t
= t
.as_nullable
591 var local_class
= get_local_class
(v
)
592 if local_class
== null then return null
594 var arity
= n_types
.length
595 if local_class
.arity
!= arity
then
596 v
.error
(self, "Type error: '{local_class}' has {local_class.arity} parameters which differs from the {arity} params.")
601 var tab
= new Array[MMType]
603 var t2
= p
.get_unchecked_stype
(v
)
604 if t2
== null then return null
607 t
= local_class
.get_instantiate_type
(tab
)
609 t
= local_class
.get_type
611 if n_kwnullable
!= null then t
= t
.as_nullable
616 redef fun get_stype
(v
)
618 var t
= get_unchecked_stype
(v
)
619 if t
== null then return null
620 if not t
.is_valid
then return null
625 redef fun check_conform
(v
)
627 var st
= get_unchecked_stype
(v
)
628 if st
== null then return
629 var local_class
= st
.local_class
630 var arity
= n_types
.length
632 for i
in [0..arity
[ do
634 var pt
= p
.get_stype
(v
)
635 var b
= local_class
.get_formal
(i
)
636 if not b
.is_valid
then return
638 bt
= bt
.adapt_to
(st
) # We need to abapt because of F-genericity
639 v
.check_conform
(p
, pt
, bt
)
646 # Is the expression node correcly typed
647 # Return false if typed was not yet computed or
648 # if an error occured during the typing computation
649 fun is_typed
: Bool is abstract
651 # Is the expression node a statement? (ie has no return value)
653 fun is_statement
: Bool is abstract
655 # The static type of the expression
656 # require: is_typed and not is_statement
657 fun stype
: MMType is abstract
660 redef class AVardeclExpr
661 # Assiociated local variable
662 fun variable
: VarVariable is abstract
663 #readable writable var _variable: nullable VarVariable
667 # Associated automatic local variable
668 fun variable
: AutoVariable is abstract
669 #readable writable var _variable: nullable AutoVariable
672 redef class ASelfExpr
673 # Associated local variable
674 fun variable
: ParamVariable is abstract
675 #readable writable var _variable: nullable ParamVariable
678 redef class AVarFormExpr
679 # Associated local variable
680 fun variable
: Variable is abstract
681 #readable writable var _variable: nullable Variable
684 redef class AClosureCallExpr
685 # Associated closure variable
686 fun variable
: ClosureVariable is abstract
687 #readable writable var _variable: nullable ClosureVariable
690 redef class PClosureDef
692 #readable writable var _closure: nullable MMClosure
693 fun closure
: MMClosure is abstract
695 # Automatic variables
696 readable writable var _variables
: nullable Array[AutoVariable]