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)
  33         do
  34                 super(name, dir, c)
  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 writable attr _formal_dict: Map[Symbol, MMTypeFormalParameter]
  67
  68         # Concrete NIT source properties by name
  69         readable attr _src_local_properties: Map[Symbol, MMConcreteProperty]
  70
  71         init(n: Symbol, cla: PClassdef, a: Int)
  72         do
  73                 super(n, a)
  74                 _nodes = [cla]
  75                 _src_local_properties = new HashMap[Symbol, MMConcreteProperty]
  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 MMConcreteProperty
 103         # The attached node (if any)
 104         meth node: PNode do return null
 105 end
 106
 107 # Concrete NIT source attribute
 108 class MMSrcAttribute
 109 special MMConcreteProperty
 110 special MMAttribute
 111         redef readable attr _node: AAttrPropdef
 112         init(name: Symbol, cla: MMLocalClass, n: AAttrPropdef)
 113         do
 114                 super(name, cla, self)
 115                 _node = n
 116         end
 117 end
 118
 119 # Concrete NIT source method
 120 class MMSrcMethod
 121 special MMConcreteProperty
 122 special MMMethod
 123 end
 124
 125 # Concrete NIT source method for an automatic accesor
 126 class MMAttrImplementationMethod
 127 special MMSrcMethod
 128         redef readable attr _node: AAttrPropdef
 129 end
 130
 131 # Concrete NIT source method for an automatic read accesor
 132 class MMReadImplementationMethod
 133 special MMAttrImplementationMethod
 134
 135         init(name: Symbol, cla: MMLocalClass, n: AAttrPropdef)
 136         do
 137                 super(name, cla, self)
 138                 _node = n
 139         end
 140 end
 141
 142 # Concrete NIT source method for an automatic write accesor
 143 class MMWriteImplementationMethod
 144 special MMAttrImplementationMethod
 145
 146         init(name: Symbol, cla: MMLocalClass, n: AAttrPropdef)
 147         do
 148                 super(name, cla, self)
 149                 _node = n
 150         end
 151 end
 152
 153 # Concrete NIT source method for an explicit method
 154 class MMMethSrcMethod
 155 special MMSrcMethod
 156         redef readable attr _node: AMethPropdef
 157         init(name: Symbol, cla: MMLocalClass, n: AMethPropdef)
 158         do
 159                 super(name, cla, self)
 160                 _node = n
 161         end
 162 end
 163
 164 # Concrete NIT source virtual type
 165 class MMSrcTypeProperty
 166 special MMConcreteProperty
 167 special MMTypeProperty
 168         redef readable attr _node: ATypePropdef
 169         init(name: Symbol, cla: MMLocalClass, n: ATypePropdef)
 170         do
 171                 super(name, cla, self)
 172                 _node = n
 173         end
 174 end
 175
 176
 177 # Local variable and method parameter
 178 class Variable
 179         # Name of the variable
 180         readable attr _name: Symbol
 181
 182         # Declaration AST node
 183         readable attr _decl: PNode
 184
 185         # Static type
 186         readable writable attr _stype: MMType
 187
 188         redef meth to_s do return _name.to_s
 189
 190         init(n: Symbol, d: PNode)
 191         do
 192                 assert n != null
 193                 assert d != null
 194                 _name = n
 195                 _decl = d
 196         end
 197 end
 198
 199 ###############################################################################
 200
 201 # Visitor used during the syntax analysis
 202 class AbsSyntaxVisitor
 203 special Visitor
 204         # The primitive type Bool
 205         meth type_bool: MMType
 206         do
 207                 return _module.class_by_name(once ("Bool".to_symbol)).get_type
 208         end
 209
 210         # The primitive type Int
 211         meth type_int: MMType
 212         do
 213                 return _module.class_by_name(once ("Int".to_symbol)).get_type
 214         end
 215
 216         # The primitive type Float
 217         meth type_float: MMType
 218         do
 219                 return _module.class_by_name(once ("Float".to_symbol)).get_type
 220         end
 221
 222         # The primitive type Char
 223         meth type_char: MMType
 224         do
 225                 return _module.class_by_name(once ("Char".to_symbol)).get_type
 226         end
 227
 228         # The primitive type String
 229         meth type_string: MMType
 230         do
 231                 return _module.class_by_name(once ("String".to_symbol)).get_type
 232         end
 233
 234         # The primitive type Collection[Object]
 235         meth type_collection: MMType
 236         do
 237                 return _module.class_by_name(once ("Collection".to_symbol)).get_type
 238         end
 239
 240         # The primitive type Array[?]
 241         meth type_array(stype: MMType): MMType
 242         do
 243                 return _module.class_by_name(once ("Array".to_symbol)).get_instantiate_type([stype])
 244         end
 245
 246         # The primitive type Discrete
 247         meth type_discrete: MMType
 248         do
 249                 return _module.class_by_name(once ("Discrete".to_symbol)).get_type
 250         end
 251
 252         # The primitive type Range[?]
 253         meth type_range(stype: MMType): MMType
 254         do
 255                 return _module.class_by_name(once ("Range".to_symbol)).get_instantiate_type([stype])
 256         end
 257
 258         # The primitive type of null
 259         meth type_none: MMType
 260         do
 261                 return _module.type_none
 262         end
 263
 264         # The current module
 265         readable writable attr _module: MMSrcModule
 266
 267         # The current class
 268         readable writable attr _local_class: MMSrcLocalClass
 269
 270         # The current property
 271         readable writable attr _local_property: MMConcreteProperty
 272
 273         # The current tool configuration/status
 274         readable attr _tc: ToolContext
 275
 276         # Display an error for a given syntax node
 277         meth error(n: PNode, s: String)
 278         do
 279                 _tc.error("{n.locate}: {s}")
 280         end
 281
 282         # Display a warning for a given syntax node
 283         meth warning(n: PNode, s: String)
 284         do
 285                 _tc.warning("{n.locate}: {s}")
 286         end
 287
 288         # Check conformity and display error
 289         meth check_conform(n: PNode, subtype: MMType, stype: MMType): Bool
 290         do
 291                 if stype == null or subtype == null then
 292                         return false
 293                 end
 294                 if subtype < stype then
 295                         return true
 296                 end
 297                 error(n, "Type error: expected {stype}, got {subtype}")
 298                 return false
 299         end
 300
 301
 302         protected init(tc: ToolContext, module: MMSrcModule)
 303         do
 304                 _tc = tc
 305                 _module = module
 306         end
 307 end
 308
 309 ###############################################################################
 310
 311 redef class PNode
 312         protected meth accept_abs_syntax_visitor(v: AbsSyntaxVisitor) do visit_all(v)
 313 end
 314
 315 redef class Token
 316         attr _symbol: Symbol
 317
 318         # Symbol associated with the text
 319         # Lazily computed
 320         meth to_symbol: Symbol
 321         do
 322                 var s = _symbol
 323                 if s == null then
 324                         s = text.to_symbol
 325                         _symbol = s
 326                 end
 327                 return s
 328         end
 329 end
 330
 331 redef class PClassdef
 332         # Associated class (MM entity)
 333         meth local_class: MMSrcLocalClass is abstract
 334 end
 335
 336 redef class AAttrPropdef
 337         # Associated attribute (MM entity)
 338         meth prop: MMSrcAttribute is abstract
 339
 340         # Associated read accessor (MM entity)
 341         meth readmethod: MMSrcMethod is abstract
 342
 343         # Associated write accessor (MM entity)
 344         meth writemethod: MMSrcMethod is abstract
 345 end
 346
 347 redef class AMethPropdef
 348         # Associated method (MM entity)
 349         meth method: MMMethSrcMethod is abstract
 350 end
 351
 352 redef class ATypePropdef
 353         # Associated formal type (MM entity)
 354         meth prop: MMSrcTypeProperty is abstract
 355 end
 356
 357 redef class PParam
 358         # Position in the signature
 359         meth position: Int is abstract
 360
 361         # Associated local variable
 362         meth variable: Variable is abstract
 363 end
 364
 365 redef class PType
 366         # Retrieve the local class corresponding to the type.
 367         # Display an error and return null if there is no class
 368         # Display an error and return null if the type is not class based (formal one)
 369         meth get_local_class(v: AbsSyntaxVisitor): MMLocalClass is abstract
 370
 371         # Retrieve corresponding static type.
 372         # Display an error and return null if there is a problem
 373         meth get_stype(v: AbsSyntaxVisitor): MMType is abstract
 374
 375         # Retrieve corresponding static type.
 376         # Display an error and return null if there is a problem
 377         # But do not performs any subtype check.
 378         # get_unchecked_stype should be called to check that the static type is fully valid
 379         meth get_unchecked_stype(v: AbsSyntaxVisitor): MMType is abstract
 380
 381         # Check that a static definition type is conform with regard to formal types
 382         # Useful with get_unchecked_stype
 383         # Remember that conformance check need that ancestors are totaly computed
 384         meth check_conform(v: AbsSyntaxVisitor) is abstract
 385 end
 386
 387 redef class AType
 388         attr _stype_cache: MMType
 389         attr _stype_cached: Bool
 390
 391         redef meth get_local_class(v)
 392         do
 393                 var name = n_id.to_symbol
 394                 var mod = v.module
 395                 var cla = v.local_class
 396
 397                 if (cla.formal_dict != null and cla.formal_dict.has_key(name)) or (cla.global_properties != null and cla.has_global_property_by_name(name)) then
 398                         v.error(n_id, "Type error: {name} is a formal type")
 399                         _stype_cached = true
 400                         return null
 401                 end
 402
 403                 if not mod.has_global_class_named(name) then
 404                         v.error(n_id, "Type error: class {name} not found in module {mod}.")
 405                         _stype_cached = true
 406                         return null
 407                 end
 408
 409                 var local_class = mod.class_by_name(name)
 410                 local_class.global.check_visibility(v, self, mod)
 411                 return local_class
 412         end
 413
 414         redef meth get_unchecked_stype(v)
 415         do
 416                 if _stype_cached then return _stype_cache
 417                 _stype_cached = true
 418
 419                 var name = n_id.to_symbol
 420                 var mod = v.module
 421                 var cla = v.local_class
 422
 423                 if cla.formal_dict.has_key(name) then
 424                         if n_types.length > 0 then
 425                                 v.error(self, "Type error: formal type {name} cannot have formal parameters.")
 426                                 return null
 427                         end
 428                         var formal = cla.formal_dict[name]
 429                         _stype_cache = formal
 430                         return formal
 431                 end
 432
 433                 if cla.global_properties != null and cla.has_global_property_by_name(name) then
 434                         if n_types.length > 0 then
 435                                 v.error(self, "Type error: formal type {name} cannot have formal parameters.")
 436                                 return null
 437                         end
 438                         var t = cla.get_type.select_virtual_type(name).stype
 439                         if t == null then
 440                                 v.error(self, "Type error: circular definition in formal type {name}.")
 441                                 return null
 442                         end
 443                         _stype_cache = t
 444                         return t
 445                 end
 446
 447                 var local_class = get_local_class(v)
 448                 if local_class == null then return null
 449
 450                 var arity = n_types.length
 451                 if local_class.arity != arity then
 452                         v.error(self, "Type error: '{local_class}' has {local_class.arity} parameters which differs from the {arity} params.")
 453                         return null
 454                 end
 455
 456                 if arity > 0 then
 457                         var tab = new Array[MMType]
 458                         for p in n_types do
 459                                 tab.add(p.get_unchecked_stype(v))
 460                         end
 461                         var t = local_class.get_instantiate_type(tab)
 462                         _stype_cache = t
 463                         return t
 464                 else
 465                         var t = local_class.get_type
 466                         _stype_cache = t
 467                         return t
 468                 end
 469         end
 470
 471         redef meth get_stype(v)
 472         do
 473                 var t = get_unchecked_stype(v)
 474                 if t != null then check_conform(v)
 475                 return t
 476         end
 477
 478         redef meth check_conform(v)
 479         do
 480                 var st = get_unchecked_stype(v)
 481                 if st == null then return
 482                 var local_class = st.local_class
 483                 var arity = n_types.length
 484                 if arity > 0 then
 485                         for i in [0..arity[ do
 486                                 var p = n_types[i]
 487                                 var pt = p.get_stype(v)
 488                                 var bt = local_class.get_formal(i).bound
 489                                 if bt == null then return
 490                                 bt = bt.adapt_to(st) # We need to abapt because of F-genericity
 491                                 v.check_conform(p, pt, bt)
 492                         end
 493                 end
 494         end
 495 end
 496
 497 redef class PExpr
 498         # Static type
 499         # Is null for statement and for erronus expression
 500         meth stype: MMType is abstract
 501 end
 502
 503 redef class AVardeclExpr
 504         # Assiociated local variable
 505         readable writable attr _variable: Variable
 506 end
 507
 508 redef class AForVardeclExpr
 509         # Associated automatic local variable
 510         readable writable attr _variable: Variable
 511 end
 512
 513 redef class AVarFormExpr
 514         # Associated local variable
 515         readable writable attr _variable: Variable
 516 end
 517