src/syntax/syntax_base.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2008 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 # Common syntax structures for syntax analysis of NIT AST.
  18 package syntax_base
  19
  20 import parser
  21 import mmloader
  22
  23 # Concrete NIT source module
  24 class MMSrcModule
  25 special MMModule
  26         # The related AST node
  27         readable attr _node: AModule
  28
  29         # Concrete NIT source local classs by name
  30         readable attr _src_local_classes: Map[Symbol, MMSrcLocalClass]
  31
  32         init(c: MMContext, source: AModule, dir: MMDirectory, name: Symbol, filename: String)
  33         do
  34                 super(name, dir, c, filename)
  35                 _node = source
  36                 _src_local_classes = new HashMap[Symbol, MMSrcLocalClass]
  37         end
  38 end
  39
  40 redef class MMGlobalClass
  41         # Check that a module can access a class
  42         meth check_visibility(v: AbsSyntaxVisitor, n: PNode, cm: MMSrcModule): Bool do
  43                 var pm = intro.module
  44                 assert pm isa MMSrcModule
  45                 var vpm = cm.visibility_for(pm)
  46                 if vpm == 3 then
  47                         return true
  48                 else if vpm == 0 then
  49                         v.error(n, "Visibility error: Class {self} comes from the hidden module {cm}.") # TODO: should not occur
  50                         return false
  51                 else if visibility_level >= 3 then
  52                         v.error(n, "Visibility error: Class {self} is private.")
  53                         return false
  54                 end
  55                 return true
  56         end
  57 end
  58
  59 # Concrete NIT source local classes
  60 class MMSrcLocalClass
  61 special MMConcreteClass
  62         # The related AST nodes
  63         readable attr _nodes: Array[PClassdef]
  64
  65         # Concrete NIT source generic formal parameter by name
  66         readable attr _formal_dict: Map[Symbol, MMTypeFormalParameter] = new HashMap[Symbol, MMTypeFormalParameter]
  67
  68         # Concrete NIT source properties by name
  69         readable attr _src_local_properties: Map[Symbol, MMLocalProperty]
  70
  71         init(mod: MMSrcModule, n: Symbol, cla: PClassdef, a: Int)
  72         do
  73                 super(mod, n, a)
  74                 _nodes = [cla]
  75                 _src_local_properties = new HashMap[Symbol, MMLocalProperty]
  76         end
  77 end
  78
  79 redef class MMGlobalProperty
  80         # Check that a module can access a property
  81         meth 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)
  85                 if vpm == 3 then
  86                         return true
  87                 else if vpm == 0 then
  88                         # TODO: should not occurs
  89                         v.error(n, "Visibility error: Property {self} comes from the hidden module {cm}.")
  90                         return false
  91                 else if visibility_level >= 3 then
  92                         v.error(n, "Visibility error: Property {self} is private.")
  93                         return false
  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.")
  96                         return false
  97                 end
  98                 return true
  99         end
 100 end
 101
 102 redef class MMLocalProperty
 103         # The attached node (if any)
 104         meth node: nullable PNode do return null
 105
 106         # Is the concrete method defined as init
 107         meth is_init: Bool do return false
 108 end
 109
 110 # Concrete NIT source attribute
 111 class MMSrcAttribute
 112 special MMAttribute
 113         redef readable attr _node: AAttrPropdef
 114         init(name: Symbol, cla: MMLocalClass, n: AAttrPropdef)
 115         do
 116                 super(name, cla)
 117                 _node = n
 118         end
 119 end
 120
 121 # Concrete NIT source method
 122 class MMSrcMethod
 123 special MMMethod
 124 end
 125
 126 # Concrete NIT source method for an automatic accesor
 127 class MMAttrImplementationMethod
 128 special MMSrcMethod
 129         redef readable attr _node: AAttrPropdef
 130         init(name: Symbol, cla: MMLocalClass, n: AAttrPropdef)
 131         do
 132                 super(name, cla)
 133                 _node = n
 134         end
 135 end
 136
 137 # Concrete NIT source method for an automatic read accesor
 138 class MMReadImplementationMethod
 139 special MMAttrImplementationMethod
 140         init(name: Symbol, cla: MMLocalClass, n: AAttrPropdef)
 141         do
 142                 super(name, cla, n)
 143         end
 144 end
 145
 146 # Concrete NIT source method for an automatic write accesor
 147 class MMWriteImplementationMethod
 148 special MMAttrImplementationMethod
 149         init(name: Symbol, cla: MMLocalClass, n: AAttrPropdef)
 150         do
 151                 super(name, cla, n)
 152         end
 153 end
 154
 155 # Concrete NIT source method for an explicit method
 156 class MMMethSrcMethod
 157 special MMSrcMethod
 158         redef meth is_init do return _node isa AConcreteInitPropdef
 159         redef readable attr _node: nullable AMethPropdef
 160         init(name: Symbol, cla: MMLocalClass, n: nullable AMethPropdef)
 161         do
 162                 super(name, cla)
 163                 _node = n
 164         end
 165 end
 166
 167 # Concrete NIT source virtual type
 168 class MMSrcTypeProperty
 169 special MMLocalProperty
 170 special MMTypeProperty
 171         redef readable attr _node: ATypePropdef
 172         init(name: Symbol, cla: MMLocalClass, n: ATypePropdef)
 173         do
 174                 super(name, cla)
 175                 _node = n
 176         end
 177 end
 178
 179 # Concrete NIT implicit constructor
 180 class MMImplicitInit
 181 special MMMethSrcMethod
 182         redef meth is_init do return true
 183         readable attr _unassigned_attributes: Array[MMSrcAttribute]
 184         readable attr _super_inits: Array[MMLocalProperty]
 185         init(cla: MMLocalClass, unassigned_attributes: Array[MMSrcAttribute], super_inits: Array[MMLocalProperty])
 186         do
 187                 super(once "init".to_symbol, cla, null)
 188                 _unassigned_attributes = unassigned_attributes
 189                 _super_inits = super_inits
 190         end
 191 end
 192
 193 # Local variables
 194 abstract class Variable
 195         # Name of the variable
 196         readable attr _name: Symbol
 197
 198         # Declaration AST node
 199         readable attr _decl: nullable PNode
 200
 201         # Static type
 202         readable writable attr _stype: nullable MMType
 203
 204         redef meth to_s do return _name.to_s
 205
 206         meth kind: String is abstract
 207
 208         init(n: Symbol, d: nullable PNode)
 209         do
 210                 _name = n
 211                 _decl = d
 212         end
 213 end
 214
 215 # Variable declared with 'var'
 216 class VarVariable
 217 special Variable
 218         redef meth kind do return once "variable"
 219         init(n: Symbol, d: PNode) do super
 220 end
 221
 222 # Parameter of method (declared in signature)
 223 class ParamVariable
 224 special Variable
 225         redef meth kind do return once "parameter"
 226         init(n: Symbol, d: nullable PNode) do super
 227 end
 228
 229 # Automatic variable (like in the 'for' statement)
 230 class AutoVariable
 231 special Variable
 232         redef meth kind do return once "automatic variable"
 233         init(n: Symbol, d: PNode) do super
 234 end
 235
 236 # False variable corresponding to closures declared in signatures
 237 # Lives in the same namespace than variables
 238 class ClosureVariable
 239 special Variable
 240         redef meth kind do return once "closure"
 241
 242         # The signature of the closure
 243         readable attr _closure: MMClosure
 244
 245         init(n: Symbol, d: PNode, c: MMClosure)
 246         do
 247                 super(n, d)
 248                 _closure = c
 249         end
 250 end
 251
 252 ###############################################################################
 253
 254 # Visitor used during the syntax analysis
 255 class AbsSyntaxVisitor
 256 special Visitor
 257         # The root type Object
 258         meth type_object: MMType
 259         do
 260                 return _module.class_by_name(once ("Object".to_symbol)).get_type
 261         end
 262
 263         # The primitive type Bool
 264         meth type_bool: MMType
 265         do
 266                 return _module.class_by_name(once ("Bool".to_symbol)).get_type
 267         end
 268
 269         # The primitive type Int
 270         meth type_int: MMType
 271         do
 272                 return _module.class_by_name(once ("Int".to_symbol)).get_type
 273         end
 274
 275         # The primitive type Float
 276         meth type_float: MMType
 277         do
 278                 return _module.class_by_name(once ("Float".to_symbol)).get_type
 279         end
 280
 281         # The primitive type Char
 282         meth type_char: MMType
 283         do
 284                 return _module.class_by_name(once ("Char".to_symbol)).get_type
 285         end
 286
 287         # The primitive type String
 288         meth type_string: MMType
 289         do
 290                 return _module.class_by_name(once ("String".to_symbol)).get_type
 291         end
 292
 293         # The primitive type Collection[nullable Object]
 294         meth type_collection: MMType
 295         do
 296                 return _module.class_by_name(once ("Collection".to_symbol)).get_instantiate_type([type_object.as_nullable])
 297         end
 298
 299         # The primitive type Array[?]
 300         meth type_array(stype: MMType): MMType
 301         do
 302                 return _module.class_by_name(once ("Array".to_symbol)).get_instantiate_type([stype])
 303         end
 304
 305         # The primitive type Discrete
 306         meth type_discrete: MMType
 307         do
 308                 return _module.class_by_name(once ("Discrete".to_symbol)).get_type
 309         end
 310
 311         # The primitive type Range[?]
 312         meth type_range(stype: MMType): MMType
 313         do
 314                 return _module.class_by_name(once ("Range".to_symbol)).get_instantiate_type([stype])
 315         end
 316
 317         # The primitive type of null
 318         meth type_none: MMType
 319         do
 320                 return _module.type_none
 321         end
 322
 323         # The current module
 324         readable attr _module: MMSrcModule
 325
 326         # The current class
 327         meth local_class: MMSrcLocalClass do return _local_class.as(not null)
 328         writable attr _local_class: nullable MMSrcLocalClass
 329
 330         # The current property
 331         meth local_property: MMLocalProperty do return _local_property.as(not null)
 332         writable attr _local_property: nullable MMLocalProperty
 333
 334         # The current tool configuration/status
 335         readable attr _tc: ToolContext
 336
 337         # Display an error for a given syntax node
 338         meth error(n: nullable PNode, s: String)
 339         do
 340                 _tc.error("{locate(n)}: {s}")
 341         end
 342
 343         # Display a warning for a given syntax node
 344         meth warning(n: nullable PNode, s: String)
 345         do
 346                 _tc.warning("{locate(n)}: {s}")
 347         end
 348
 349         #
 350         meth locate(n: nullable PNode): String
 351         do
 352                 if n != null then return n.locate
 353                 return _module.filename
 354         end
 355
 356         # Check conformity and display error
 357         meth check_conform(n: PNode, subtype: nullable MMType, stype: nullable MMType): Bool
 358         do
 359                 if stype == null or subtype == null then
 360                         return false
 361                 end
 362                 if subtype < stype  then
 363                         return true
 364                 end
 365                 # Do not enforce nullable subtype rules yet
 366                 if subtype isa MMTypeNone or subtype.as_notnull < stype.as_notnull then
 367                         warning(n, "Nullable type warning: expected {stype}, got {subtype}")
 368                         return true
 369                 end
 370                 error(n, "Type error: expected {stype}, got {subtype}")
 371                 return false
 372         end
 373
 374         # Check that an expression has a static type and that
 375         # Display an error and return false if n is a statement
 376         # Require that the static type of n is known
 377         meth check_expr(n: PExpr): Bool
 378         do
 379                 if not n.is_typed then
 380                         if tc.error_count == 0 then
 381                                 print("{n.locate} not typed but not error")
 382                                 abort
 383                         end
 384                         # An error occured in a sub node,
 385                         # sillently cascade fail
 386                         return false
 387                 else if n.is_statement then
 388                         error(n, "Type error: expected expression.")
 389                         return false
 390                 end
 391                 return true
 392         end
 393
 394         # Combine check_conform and check_expr
 395         meth check_conform_expr(n: PExpr, stype: nullable MMType): Bool
 396         do
 397                 if stype == null then return false
 398                 if check_expr(n) then return check_conform(n, n.stype, stype) else return false
 399         end
 400
 401         # Check conformance between multiple expressions and a static type
 402         # Conformance is granted if among them there is a most general type
 403         # Return the most general type if a conformance is found
 404         # Display an error and return null if no conformance is found
 405         # The only allowed combinaison is with the nullable marker
 406         # @param stype is a possible additional type (without node)
 407         # Examples:
 408         #   Int, Int, Object => return Object
 409         #   Int, Float => display error, return null
 410         #   nullable Int, Object => return nullable Object
 411         meth check_conform_multiexpr(stype: nullable MMType, nodes: Collection[PExpr]): nullable MMType
 412         do
 413                 var node: nullable PExpr = null # candidate node
 414                 for n in nodes do
 415                         if not check_expr(n) then return null
 416                         var ntype = n.stype
 417                         if stype != null and stype.is_nullable != ntype.is_nullable then
 418                                 # nullable combinaison: if one of them is nulable, considers that both are
 419                                 stype = stype.as_nullable
 420                                 ntype = ntype.as_nullable
 421                         end
 422                         if stype == null or stype < ntype then
 423                                 stype = ntype
 424                                 node = n
 425                         end
 426                 end
 427                 for n in nodes do
 428                         if not n.stype < stype.as(not null) then
 429                                 if node == null then
 430                                         error(n, "Type error: no most general type. Got {n.stype} and {stype}.")
 431                                 else
 432                                         error(n, "Type error: no most general type. Got {n.stype} and {stype} at {node.locate}.")
 433                                 end
 434                                 return null
 435                         end
 436                 end
 437                 return stype
 438         end
 439
 440         protected init(tc: ToolContext, module: MMSrcModule)
 441         do
 442                 _tc = tc
 443                 _module = module
 444         end
 445 end
 446
 447 ###############################################################################
 448
 449 redef class PNode
 450         protected meth accept_abs_syntax_visitor(v: AbsSyntaxVisitor) do visit_all(v)
 451 end
 452
 453 redef class Token
 454         attr _symbol_cache: nullable Symbol
 455
 456         # Symbol associated with the text
 457         # Lazily computed
 458         meth to_symbol: Symbol
 459         do
 460                 var s = _symbol_cache
 461                 if s == null then
 462                         s = text.to_symbol
 463                         _symbol_cache = s
 464                 end
 465                 return s
 466         end
 467 end
 468
 469 redef class PClassdef
 470         # Associated class (MM entity)
 471         meth local_class: MMSrcLocalClass is abstract
 472 end
 473
 474 redef class AAttrPropdef
 475         # Associated attribute (MM entity)
 476         meth prop: MMSrcAttribute is abstract
 477
 478         # Associated read accessor (MM entity)
 479         meth readmethod: nullable MMSrcMethod is abstract
 480
 481         # Associated write accessor (MM entity)
 482         meth writemethod: nullable MMSrcMethod is abstract
 483 end
 484
 485 redef class AMethPropdef
 486         # Associated method (MM entity)
 487         meth method: MMMethSrcMethod is abstract
 488
 489         # Associated 'self' variable
 490         meth self_var: ParamVariable is abstract
 491 end
 492
 493 redef class ATypePropdef
 494         # Associated formal type (MM entity)
 495         meth prop: MMSrcTypeProperty is abstract
 496 end
 497
 498 redef class PParam
 499         # Position in the signature
 500         meth position: Int is abstract
 501
 502         # Associated local variable
 503         meth variable: ParamVariable is abstract
 504 end
 505
 506 redef class PClosureDecl
 507         # Associated closure variable
 508         meth variable: ClosureVariable is abstract
 509 end
 510
 511 redef class PType
 512         # Retrieve the local class corresponding to the type.
 513         # Display an error and return null if there is no class
 514         # Display an error and return null if the type is not class based (formal one)
 515         meth get_local_class(v: AbsSyntaxVisitor): nullable MMLocalClass is abstract
 516
 517         # Retrieve corresponding static type.
 518         # Display an error and return null if there is a problem
 519         meth get_stype(v: AbsSyntaxVisitor): nullable MMType is abstract
 520
 521         # Retrieve corresponding static type.
 522         # Display an error and return null if there is a problem
 523         # But do not performs any subtype check.
 524         # get_unchecked_stype should be called to check that the static type is fully valid
 525         meth get_unchecked_stype(v: AbsSyntaxVisitor): nullable MMType is abstract
 526
 527         # Check that a static definition type is conform with regard to formal types
 528         # Useful with get_unchecked_stype
 529         # Remember that conformance check need that ancestors are totaly computed
 530         meth check_conform(v: AbsSyntaxVisitor) is abstract
 531 end
 532
 533 redef class AType
 534         attr _stype_cache: nullable MMType = null
 535         attr _stype_cached: Bool = false
 536
 537         redef meth get_local_class(v)
 538         do
 539                 var name = n_id.to_symbol
 540                 var mod = v.module
 541                 var cla = v.local_class
 542
 543                 if cla.formal_dict.has_key(name) or cla.has_global_property_by_name(name) then
 544                         v.error(n_id, "Type error: {name} is a formal type")
 545                         _stype_cached = true
 546                         return null
 547                 end
 548
 549                 if not mod.has_global_class_named(name) then
 550                         v.error(n_id, "Type error: class {name} not found in module {mod}.")
 551                         _stype_cached = true
 552                         return null
 553                 end
 554
 555                 var local_class = mod.class_by_name(name)
 556                 local_class.global.check_visibility(v, self, mod)
 557                 return local_class
 558         end
 559
 560         redef meth get_unchecked_stype(v)
 561         do
 562                 if _stype_cached then return _stype_cache
 563                 _stype_cached = true
 564
 565                 var name = n_id.to_symbol
 566                 var mod = v.module
 567                 var cla = v.local_class
 568                 var t: nullable MMType
 569
 570                 if cla.formal_dict.has_key(name) then
 571                         if n_types.length > 0 then
 572                                 v.error(self, "Type error: formal type {name} cannot have formal parameters.")
 573                                 return null
 574                         end
 575                         t = cla.formal_dict[name]
 576                         if n_kwnullable != null then t = t.as_nullable
 577                         _stype_cache = t
 578                         return t
 579                 end
 580
 581                 if cla.has_global_property_by_name(name) then
 582                         if n_types.length > 0 then
 583                                 v.error(self, "Type error: formal type {name} cannot have formal parameters.")
 584                                 return null
 585                         end
 586                         t = cla.get_type.local_class.select_virtual_type(name).stype_for(cla.get_type)
 587                         if t == null then
 588                                 v.error(self, "Type error: circular definition in formal type {name}.")
 589                                 return null
 590                         end
 591                         if n_kwnullable != null then t = t.as_nullable
 592                         _stype_cache = t
 593                         return t
 594                 end
 595
 596                 var local_class = get_local_class(v)
 597                 if local_class == null then return null
 598
 599                 var arity = n_types.length
 600                 if local_class.arity != arity then
 601                         v.error(self, "Type error: '{local_class}' has {local_class.arity} parameters which differs from the {arity} params.")
 602                         return null
 603                 end
 604
 605                 if arity > 0 then
 606                         var tab = new Array[MMType]
 607                         for p in n_types do
 608                                 var t2 = p.get_unchecked_stype(v)
 609                                 if t2 == null then return null
 610                                 tab.add(t2)
 611                         end
 612                         t = local_class.get_instantiate_type(tab)
 613                 else
 614                         t = local_class.get_type
 615                 end
 616                 if n_kwnullable != null then t = t.as_nullable
 617                 _stype_cache = t
 618                 return t
 619         end
 620
 621         redef meth get_stype(v)
 622         do
 623                 var t = get_unchecked_stype(v)
 624                 if t == null then return null
 625                 if not t.is_valid then return null
 626                 check_conform(v)
 627                 return t
 628         end
 629
 630         redef meth check_conform(v)
 631         do
 632                 var st = get_unchecked_stype(v)
 633                 if st == null then return
 634                 var local_class = st.local_class
 635                 var arity = n_types.length
 636                 if arity > 0 then
 637                         for i in [0..arity[ do
 638                                 var p = n_types[i]
 639                                 var pt = p.get_stype(v)
 640                                 var b = local_class.get_formal(i)
 641                                 if not b.is_valid then return
 642                                 var bt = b.bound
 643                                 bt = bt.adapt_to(st) # We need to abapt because of F-genericity
 644                                 v.check_conform(p, pt, bt)
 645                         end
 646                 end
 647         end
 648 end
 649
 650 redef class PExpr
 651         # Is the expression node correcly typed
 652         # Return false if typed was not yet computed or
 653         # if an error occured during the typing computation
 654         meth is_typed: Bool is abstract
 655
 656         # Is the expression node a statement? (ie has no return value)
 657         # require: is_typed
 658         meth is_statement: Bool is abstract
 659
 660         # The static type of the expression
 661         # require: is_typed and not is_statement
 662         meth stype: MMType is abstract
 663 end
 664
 665 redef class AVardeclExpr
 666         # Assiociated local variable
 667         meth variable: VarVariable is abstract
 668         #readable writable attr _variable: nullable VarVariable
 669 end
 670
 671 redef class AForExpr
 672         # Associated automatic local variable
 673         meth variable: AutoVariable is abstract
 674         #readable writable attr _variable: nullable AutoVariable
 675 end
 676
 677 redef class ASelfExpr
 678         # Associated local variable
 679         meth variable: ParamVariable is abstract
 680         #readable writable attr _variable: nullable ParamVariable
 681 end
 682
 683 redef class AVarFormExpr
 684         # Associated local variable
 685         meth variable: Variable is abstract
 686         #readable writable attr _variable: nullable Variable
 687 end
 688
 689 redef class AClosureCallExpr
 690         # Associated closure variable
 691         meth variable: ClosureVariable is abstract
 692         #readable writable attr _variable: nullable ClosureVariable
 693 end
 694
 695 redef class PClosureDef
 696         # Associated closure
 697         #readable writable attr _closure: nullable MMClosure
 698         meth closure: MMClosure is abstract
 699
 700         # Automatic variables
 701         readable writable attr _variables: nullable Array[AutoVariable]
 702 end