src/modelize_class.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 # Analysis and verification of class definitions to instantiate model element
  18 module modelize_class
  19
  20 import modelbuilder
  21
  22 redef class ToolContext
  23         var modelize_class_phase: Phase = new ModelizeClassPhase(self, null)
  24 end
  25
  26 private class ModelizeClassPhase
  27         super Phase
  28
  29         redef fun process_nmodule(nmodule)
  30         do
  31                 toolcontext.modelbuilder.build_classes(nmodule)
  32         end
  33 end
  34
  35 redef class ModelBuilder
  36         # Visit the AST and create the MClass objects
  37         private fun build_a_mclass(nmodule: AModule, nclassdef: AClassdef)
  38         do
  39                 var mmodule = nmodule.mmodule.as(not null)
  40
  41                 var name: String
  42                 var nkind: nullable AClasskind
  43                 var mkind: MClassKind
  44                 var nvisibility: nullable AVisibility
  45                 var mvisibility: nullable MVisibility
  46                 var arity = 0
  47                 if nclassdef isa AStdClassdef then
  48                         name = nclassdef.n_id.text
  49                         nkind = nclassdef.n_classkind
  50                         mkind = nkind.mkind
  51                         nvisibility = nclassdef.n_visibility
  52                         mvisibility = nvisibility.mvisibility
  53                         arity = nclassdef.n_formaldefs.length
  54                         if mvisibility == protected_visibility then
  55                                 error(nvisibility, "Error: only properties can be protected.")
  56                                 return
  57                         end
  58                 else if nclassdef isa ATopClassdef then
  59                         name = "Object"
  60                         nkind = null
  61                         mkind = interface_kind
  62                         nvisibility = null
  63                         mvisibility = public_visibility
  64                 else if nclassdef isa AMainClassdef then
  65                         name = "Sys"
  66                         nkind = null
  67                         mkind = concrete_kind
  68                         nvisibility = null
  69                         mvisibility = public_visibility
  70                 else
  71                         abort
  72                 end
  73
  74                 var mclass = try_get_mclass_by_name(nclassdef, mmodule, name)
  75                 if mclass == null then
  76                         mclass = new MClass(mmodule, name, arity, mkind, mvisibility)
  77                         #print "new class {mclass}"
  78                 else if nclassdef isa AStdClassdef and nmodule.mclass2nclassdef.has_key(mclass) then
  79                         error(nclassdef, "Error: A class {name} is already defined at line {nmodule.mclass2nclassdef[mclass].location.line_start}.")
  80                         return
  81                 else if nclassdef isa AStdClassdef and nclassdef.n_kwredef == null then
  82                         error(nclassdef, "Redef error: {name} is an imported class. Add the redef keyword to refine it.")
  83                         return
  84                 else if mclass.arity != arity then
  85                         error(nclassdef, "Redef error: Formal parameter arity missmatch; got {arity}, expected {mclass.arity}.")
  86                         return
  87                 else if nkind != null and mkind != concrete_kind and mclass.kind != mkind then
  88                         error(nkind, "Error: refinement changed the kind from a {mclass.kind} to a {mkind}")
  89                 else if nvisibility != null and mvisibility != public_visibility and mclass.visibility != mvisibility then
  90                         error(nvisibility, "Error: refinement changed the visibility from a {mclass.visibility} to a {mvisibility}")
  91                 end
  92                 nclassdef.mclass = mclass
  93                 nmodule.mclass2nclassdef[mclass] = nclassdef
  94         end
  95
  96         # Visit the AST and create the MClassDef objects
  97         private fun build_a_mclassdef(nmodule: AModule, nclassdef: AClassdef)
  98         do
  99                 var mmodule = nmodule.mmodule.as(not null)
 100                 var objectclass = try_get_mclass_by_name(nmodule, mmodule, "Object")
 101                 var mclass = nclassdef.mclass
 102                 if mclass == null then return # Skip error
 103                 #var mclassdef = nclassdef.mclassdef.as(not null)
 104
 105                 var names = new Array[String]
 106                 var bounds = new Array[MType]
 107                 if nclassdef isa AStdClassdef and mclass.arity > 0 then
 108                         # Collect formal parameter names
 109                         for i in [0..mclass.arity[ do
 110                                 var nfd = nclassdef.n_formaldefs[i]
 111                                 var ptname = nfd.n_id.text
 112                                 if names.has(ptname) then
 113                                         error(nfd, "Error: A formal parameter type `{ptname}' already exists")
 114                                         return
 115                                 end
 116                                 names.add(ptname)
 117                         end
 118
 119                         # Revolve bound for formal parameter names
 120                         for i in [0..mclass.arity[ do
 121                                 var nfd = nclassdef.n_formaldefs[i]
 122                                 var nfdt = nfd.n_type
 123                                 if nfdt != null then
 124                                         var bound = resolve_mtype_unchecked(nclassdef, nfdt, false)
 125                                         if bound == null then return # Forward error
 126                                         if bound.need_anchor then
 127                                                 # No F-bounds!
 128                                                 error(nfd, "Error: Formal parameter type `{names[i]}' bounded with a formal parameter type")
 129                                         else
 130                                                 bounds.add(bound)
 131                                         end
 132                                 else if mclass.mclassdefs.is_empty then
 133                                         # No bound, then implicitely bound by nullable Object
 134                                         bounds.add(objectclass.mclass_type.as_nullable)
 135                                 else
 136                                         # Inherit the bound
 137                                         bounds.add(mclass.intro.bound_mtype.arguments[i])
 138                                 end
 139                         end
 140                 end
 141
 142                 var bound_mtype = mclass.get_mtype(bounds)
 143                 var mclassdef = new MClassDef(mmodule, bound_mtype, nclassdef.location, names)
 144                 nclassdef.mclassdef = mclassdef
 145                 self.mclassdef2nclassdef[mclassdef] = nclassdef
 146
 147                 if mclassdef.is_intro then
 148                         self.toolcontext.info("{mclassdef} introduces new {mclass.kind} {mclass.full_name}", 3)
 149                 else
 150                         self.toolcontext.info("{mclassdef} refine {mclass.kind} {mclass.full_name}", 3)
 151                 end
 152         end
 153
 154         # Visit the AST and set the super-types of the MClassdef objects
 155         private fun collect_a_mclassdef_inheritance(nmodule: AModule, nclassdef: AClassdef)
 156         do
 157                 var mmodule = nmodule.mmodule.as(not null)
 158                 var objectclass = try_get_mclass_by_name(nmodule, mmodule, "Object")
 159                 var mclass = nclassdef.mclass.as(not null)
 160                 var mclassdef = nclassdef.mclassdef.as(not null)
 161
 162                 var specobject = true
 163                 var supertypes = new Array[MClassType]
 164                 if nclassdef isa AStdClassdef then
 165                         for nsc in nclassdef.n_superclasses do
 166                                 specobject = false
 167                                 var ntype = nsc.n_type
 168                                 var mtype = resolve_mtype_unchecked(nclassdef, ntype, false)
 169                                 if mtype == null then continue # Skip because of error
 170                                 if not mtype isa MClassType then
 171                                         error(ntype, "Error: supertypes cannot be a formal type")
 172                                         return
 173                                 end
 174                                 supertypes.add mtype
 175                                 #print "new super : {mclass} < {mtype}"
 176                         end
 177                 end
 178                 if specobject and mclass.name != "Object" and objectclass != null and mclassdef.is_intro then
 179                         supertypes.add objectclass.mclass_type
 180                 end
 181
 182                 mclassdef.set_supertypes(supertypes)
 183                 if not supertypes.is_empty then self.toolcontext.info("{mclassdef} new super-types: {supertypes.join(", ")}", 3)
 184         end
 185
 186         # Check the validity of the specialization heirarchy
 187         private fun check_supertypes(nmodule: AModule, nclassdef: AClassdef)
 188         do
 189                 var mmodule = nmodule.mmodule.as(not null)
 190                 var objectclass = try_get_mclass_by_name(nmodule, mmodule, "Object")
 191                 var mclass = nclassdef.mclass.as(not null)
 192                 var mclassdef = nclassdef.mclassdef.as(not null)
 193
 194                 for s in mclassdef.supertypes do
 195                         if s.is_subtype(mmodule, mclassdef.bound_mtype, mclassdef.bound_mtype) then
 196                                 error(nclassdef, "Error: Inheritance loop for class {mclass} with type {s}")
 197                         end
 198                 end
 199         end
 200
 201         # Build the classes of the module `nmodule'.
 202         # REQUIRE: classes of imported modules are already build. (let `phase' do the job)
 203         private fun build_classes(nmodule: AModule)
 204         do
 205                 var errcount = toolcontext.error_count
 206                 # Force building recursively
 207                 if nmodule.build_classes_is_done then return
 208                 nmodule.build_classes_is_done = true
 209                 var mmodule = nmodule.mmodule.as(not null)
 210                 for imp in mmodule.in_importation.direct_greaters do
 211
 212                         build_classes(mmodule2nmodule[imp])
 213                 end
 214
 215                 if errcount != toolcontext.error_count then return
 216
 217                 # Create all classes
 218                 for nclassdef in nmodule.n_classdefs do
 219                         self.build_a_mclass(nmodule, nclassdef)
 220                 end
 221
 222                 if errcount != toolcontext.error_count then return
 223
 224                 # Create all classdefs
 225                 for nclassdef in nmodule.n_classdefs do
 226                         self.build_a_mclassdef(nmodule, nclassdef)
 227                 end
 228
 229                 if errcount != toolcontext.error_count then return
 230
 231                 # Create inheritance on all classdefs
 232                 for nclassdef in nmodule.n_classdefs do
 233                         self.collect_a_mclassdef_inheritance(nmodule, nclassdef)
 234                 end
 235
 236                 if errcount != toolcontext.error_count then return
 237
 238                 # Create the mclassdef hierarchy
 239                 for nclassdef in nmodule.n_classdefs do
 240                         var mclassdef = nclassdef.mclassdef.as(not null)
 241                         mclassdef.add_in_hierarchy
 242                 end
 243
 244                 if errcount != toolcontext.error_count then return
 245
 246                 # Check inheritance
 247                 for nclassdef in nmodule.n_classdefs do
 248                         self.check_supertypes(nmodule, nclassdef)
 249                 end
 250
 251                 if errcount != toolcontext.error_count then return
 252
 253                 # Check unchecked ntypes
 254                 for nclassdef in nmodule.n_classdefs do
 255                         if nclassdef isa AStdClassdef then
 256                                 # check bound of formal parameter
 257                                 for nfd in  nclassdef.n_formaldefs do
 258                                         var nfdt = nfd.n_type
 259                                         if nfdt != null and nfdt.mtype != null then
 260                                                 var bound = resolve_mtype(nclassdef, nfdt)
 261                                                 if bound == null then return # Forward error
 262                                         end
 263                                 end
 264                                 # check declared super types
 265                                 for nsc in nclassdef.n_superclasses do
 266                                         var ntype = nsc.n_type
 267                                         if ntype.mtype != null then
 268                                                 var mtype = resolve_mtype(nclassdef, ntype)
 269                                                 if mtype == null then return # Forward error
 270                                         end
 271                                 end
 272                         end
 273                 end
 274
 275                 if errcount != toolcontext.error_count then return
 276
 277                 # Check clash of ancestors
 278                 for nclassdef in nmodule.n_classdefs do
 279                         var mclassdef = nclassdef.mclassdef.as(not null)
 280                         var superclasses = new HashMap[MClass, MClassType]
 281                         for scd in mclassdef.in_hierarchy.greaters do
 282                                 for st in scd.supertypes do
 283                                         if not superclasses.has_key(st.mclass) then
 284                                                 superclasses[st.mclass] = st
 285                                         else if superclasses[st.mclass] != st then
 286                                                 var st1 = superclasses[st.mclass].resolve_for(mclassdef.mclass.mclass_type, mclassdef.bound_mtype, mmodule, false)
 287                                                 var st2 = st.resolve_for(mclassdef.mclass.mclass_type, mclassdef.bound_mtype, mmodule, false)
 288                                                 if st1 != st2 then
 289                                                         error(nclassdef, "Error: Incompatibles ancestors for {mclassdef.mclass}: {st1}, {st2}")
 290                                                 end
 291                                         end
 292                                 end
 293                         end
 294                 end
 295
 296                 # TODO: Check that the super-class is not intrusive
 297
 298                 # TODO: Check that the super-class is not already known (by transitivity)
 299         end
 300
 301         # Register the nclassdef associated to each mclassdef
 302         # FIXME: why not refine the MClassDef class with a nullable attribute?
 303         var mclassdef2nclassdef: HashMap[MClassDef, AClassdef] = new HashMap[MClassDef, AClassdef]
 304
 305         # Return the static type associated to the node `ntype'.
 306         # `classdef' is the context where the call is made (used to understand formal types)
 307         # The mmodule used as context is `nclassdef.mmodule'
 308         # In case of problem, an error is displayed on `ntype' and null is returned.
 309         # FIXME: the name "resolve_mtype" is awful
 310         fun resolve_mtype_unchecked(nclassdef: AClassdef, ntype: AType, with_virtual: Bool): nullable MType
 311         do
 312                 var name = ntype.n_id.text
 313                 var mclassdef = nclassdef.mclassdef
 314                 var mmodule = nclassdef.parent.as(AModule).mmodule.as(not null)
 315                 var res: MType
 316
 317                 # Check virtual type
 318                 if mclassdef != null and with_virtual then
 319                         var prop = try_get_mproperty_by_name(ntype, mclassdef, name).as(nullable MVirtualTypeProp)
 320                         if prop != null then
 321                                 if not ntype.n_types.is_empty then
 322                                         error(ntype, "Type error: formal type {name} cannot have formal parameters.")
 323                                 end
 324                                 res = prop.mvirtualtype
 325                                 if ntype.n_kwnullable != null then res = res.as_nullable
 326                                 ntype.mtype = res
 327                                 return res
 328                         end
 329                 end
 330
 331                 # Check parameter type
 332                 if mclassdef != null and mclassdef.parameter_names.has(name) then
 333                         if not ntype.n_types.is_empty then
 334                                 error(ntype, "Type error: formal type {name} cannot have formal parameters.")
 335                         end
 336                         for i in [0..mclassdef.parameter_names.length[ do
 337                                 if mclassdef.parameter_names[i] == name then
 338                                         res = mclassdef.mclass.mclass_type.arguments[i]
 339                                         if ntype.n_kwnullable != null then res = res.as_nullable
 340                                         ntype.mtype = res
 341                                         return res
 342                                 end
 343                         end
 344                         abort
 345                 end
 346
 347                 # Check class
 348                 var mclass = try_get_mclass_by_name(ntype, mmodule, name)
 349                 if mclass != null then
 350                         var arity = ntype.n_types.length
 351                         if arity != mclass.arity then
 352                                 if arity == 0 then
 353                                         error(ntype, "Type error: '{name}' is a generic class.")
 354                                 else if mclass.arity == 0 then
 355                                         error(ntype, "Type error: '{name}' is not a generic class.")
 356                                 else
 357                                         error(ntype, "Type error: '{name}' has {mclass.arity} parameters ({arity} are provided).")
 358                                 end
 359                                 return null
 360                         end
 361                         if arity == 0 then
 362                                 res = mclass.mclass_type
 363                                 if ntype.n_kwnullable != null then res = res.as_nullable
 364                                 ntype.mtype = res
 365                                 return res
 366                         else
 367                                 var mtypes = new Array[MType]
 368                                 for nt in ntype.n_types do
 369                                         var mt = resolve_mtype_unchecked(nclassdef, nt, with_virtual)
 370                                         if mt == null then return null # Forward error
 371                                         mtypes.add(mt)
 372                                 end
 373                                 res = mclass.get_mtype(mtypes)
 374                                 if ntype.n_kwnullable != null then res = res.as_nullable
 375                                 ntype.mtype = res
 376                                 return res
 377                         end
 378                 end
 379
 380                 # If everything fail, then give up :(
 381                 error(ntype, "Type error: class {name} not found in module {mmodule}.")
 382                 return null
 383         end
 384
 385         # Return the static type associated to the node `ntype'.
 386         # `classdef' is the context where the call is made (used to understand formal types)
 387         # The mmodule used as context is `nclassdef.mmodule'
 388         # In case of problem, an error is displayed on `ntype' and null is returned.
 389         # FIXME: the name "resolve_mtype" is awful
 390         fun resolve_mtype(nclassdef: AClassdef, ntype: AType): nullable MType
 391         do
 392                 var mtype = ntype.mtype
 393                 if mtype == null then mtype = resolve_mtype_unchecked(nclassdef, ntype, true)
 394                 if mtype == null then return null # Forward error
 395
 396                 if ntype.checked_mtype then return mtype
 397                 if mtype isa MGenericType then
 398                         var mmodule = nclassdef.parent.as(AModule).mmodule.as(not null)
 399                         var mclassdef = nclassdef.mclassdef
 400                         var mclass = mtype.mclass
 401                         for i in [0..mclass.arity[ do
 402                                 var bound = mclass.intro.bound_mtype.arguments[i]
 403                                 var nt = ntype.n_types[i]
 404                                 var mt = resolve_mtype(nclassdef, nt)
 405                                 if mt == null then return null # forward error
 406                                 if not mt.is_subtype(mmodule, mclassdef.bound_mtype, bound) then
 407                                         error(nt, "Type error: expected {bound}, got {mt}")
 408                                         return null
 409                                 end
 410                         end
 411                 end
 412                 ntype.checked_mtype = true
 413                 return mtype
 414         end
 415
 416 end
 417
 418 redef class AModule
 419         # Flag that indicate if the class building is already completed
 420         var build_classes_is_done: Bool = false
 421         # What is the AClassdef associated to a MClass?
 422         # Used to check multiple definition of a class.
 423         var mclass2nclassdef: Map[MClass, AClassdef] = new HashMap[MClass, AClassdef]
 424 end
 425
 426 redef class AClassdef
 427         # The associated MClass once build by a `ModelBuilder'
 428         var mclass: nullable MClass
 429         # The associated MClassDef once build by a `ModelBuilder'
 430         var mclassdef: nullable MClassDef
 431 end
 432
 433 redef class AClasskind
 434         # The class kind associated with the AST node class
 435         private fun mkind: MClassKind is abstract
 436 end
 437 redef class AConcreteClasskind
 438         redef fun mkind do return concrete_kind
 439 end
 440 redef class AAbstractClasskind
 441         redef fun mkind do return abstract_kind
 442 end
 443 redef class AInterfaceClasskind
 444         redef fun mkind do return interface_kind
 445 end
 446 redef class AEnumClasskind
 447         redef fun mkind do return enum_kind
 448 end
 449 redef class AExternClasskind
 450         redef fun mkind do return extern_kind
 451 end
 452
 453 redef class AType
 454         # The mtype associated to the node
 455         var mtype: nullable MType = null
 456
 457         # Is the mtype a valid one?
 458         var checked_mtype: Bool = false
 459 end