src/modelbuilder_base.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 # Load nit source files and build the associated model
  18 #
  19 # FIXME better doc
  20 #
  21 # FIXME split this module into submodules
  22 # FIXME add missing error checks
  23 module modelbuilder_base
  24
  25 import model
  26 import toolcontext
  27 import parser
  28
  29 private import more_collections
  30
  31 ###
  32
  33 redef class ToolContext
  34
  35         # The modelbuilder 1-to-1 associated with the toolcontext
  36         fun modelbuilder: ModelBuilder do return modelbuilder_real.as(not null)
  37
  38         private var modelbuilder_real: nullable ModelBuilder = null
  39
  40 end
  41
  42 # A model builder knows how to load nit source files and build the associated model
  43 class ModelBuilder
  44         # The model where new modules, classes and properties are added
  45         var model: Model
  46
  47         # The toolcontext used to control the interaction with the user (getting options and displaying messages)
  48         var toolcontext: ToolContext
  49
  50         # Instantiate a modelbuilder for a model and a toolcontext
  51         # Important, the options of the toolcontext must be correctly set (parse_option already called)
  52         init
  53         do
  54                 assert toolcontext.modelbuilder_real == null
  55                 toolcontext.modelbuilder_real = self
  56         end
  57
  58         # Return a class named `name` visible by the module `mmodule`.
  59         # Visibility in modules is correctly handled.
  60         # If no such a class exists, then null is returned.
  61         # If more than one class exists, then an error on `anode` is displayed and null is returned.
  62         # FIXME: add a way to handle class name conflict
  63         fun try_get_mclass_by_name(anode: ANode, mmodule: MModule, name: String): nullable MClass
  64         do
  65                 var classes = model.get_mclasses_by_name(name)
  66                 if classes == null then
  67                         return null
  68                 end
  69
  70                 var res: nullable MClass = null
  71                 for mclass in classes do
  72                         if not mmodule.in_importation <= mclass.intro_mmodule then continue
  73                         if not mmodule.is_visible(mclass.intro_mmodule, mclass.visibility) then continue
  74                         if res == null then
  75                                 res = mclass
  76                         else
  77                                 error(anode, "Ambigous class name '{name}'; conflict between {mclass.full_name} and {res.full_name}")
  78                                 return null
  79                         end
  80                 end
  81                 return res
  82         end
  83
  84         # Return a property named `name` on the type `mtype` visible in the module `mmodule`.
  85         # Visibility in modules is correctly handled.
  86         # Protected properties are returned (it is up to the caller to check and reject protected properties).
  87         # If no such a property exists, then null is returned.
  88         # If more than one property exists, then an error on `anode` is displayed and null is returned.
  89         # FIXME: add a way to handle property name conflict
  90         fun try_get_mproperty_by_name2(anode: ANode, mmodule: MModule, mtype: MType, name: String): nullable MProperty
  91         do
  92                 var props = self.model.get_mproperties_by_name(name)
  93                 if props == null then
  94                         return null
  95                 end
  96
  97                 var cache = self.try_get_mproperty_by_name2_cache[mmodule, mtype, name]
  98                 if cache != null then return cache
  99
 100                 var res: nullable MProperty = null
 101                 var ress: nullable Array[MProperty] = null
 102                 for mprop in props do
 103                         if not mtype.has_mproperty(mmodule, mprop) then continue
 104                         if not mmodule.is_visible(mprop.intro_mclassdef.mmodule, mprop.visibility) then continue
 105
 106                         # new-factories are invisible outside of the class
 107                         if mprop isa MMethod and mprop.is_new and (not mtype isa MClassType or mprop.intro_mclassdef.mclass != mtype.mclass) then
 108                                 continue
 109                         end
 110
 111                         if res == null then
 112                                 res = mprop
 113                                 continue
 114                         end
 115
 116                         # Two global properties?
 117                         # First, special case for init, keep the most specific ones
 118                         if res isa MMethod and mprop isa MMethod and res.is_init and mprop.is_init then
 119                                 var restype = res.intro_mclassdef.bound_mtype
 120                                 var mproptype = mprop.intro_mclassdef.bound_mtype
 121                                 if mproptype.is_subtype(mmodule, null, restype) then
 122                                         # found a most specific constructor, so keep it
 123                                         res = mprop
 124                                         continue
 125                                 end
 126                         end
 127
 128                         # Ok, just keep all prop in the ress table
 129                         if ress == null then
 130                                 ress = new Array[MProperty]
 131                                 ress.add(res)
 132                         end
 133                         ress.add(mprop)
 134                 end
 135
 136                 # There is conflict?
 137                 if ress != null and res isa MMethod and res.is_init then
 138                         # special case forinit again
 139                         var restype = res.intro_mclassdef.bound_mtype
 140                         var ress2 = new Array[MProperty]
 141                         for mprop in ress do
 142                                 var mproptype = mprop.intro_mclassdef.bound_mtype
 143                                 if not restype.is_subtype(mmodule, null, mproptype) then
 144                                         ress2.add(mprop)
 145                                 else if not mprop isa MMethod or not mprop.is_init then
 146                                         ress2.add(mprop)
 147                                 end
 148                         end
 149                         if ress2.is_empty then
 150                                 ress = null
 151                         else
 152                                 ress = ress2
 153                                 ress.add(res)
 154                         end
 155                 end
 156
 157                 if ress != null then
 158                         assert ress.length > 1
 159                         var s = new Array[String]
 160                         for mprop in ress do s.add mprop.full_name
 161                         self.error(anode, "Ambigous property name '{name}' for {mtype}; conflict between {s.join(" and ")}")
 162                 end
 163
 164                 self.try_get_mproperty_by_name2_cache[mmodule, mtype, name] = res
 165                 return res
 166         end
 167
 168         private var try_get_mproperty_by_name2_cache = new HashMap3[MModule, MType, String, nullable MProperty]
 169
 170
 171         # Alias for try_get_mproperty_by_name2(anode, mclassdef.mmodule, mclassdef.mtype, name)
 172         fun try_get_mproperty_by_name(anode: ANode, mclassdef: MClassDef, name: String): nullable MProperty
 173         do
 174                 return try_get_mproperty_by_name2(anode, mclassdef.mmodule, mclassdef.bound_mtype, name)
 175         end
 176
 177         # Helper function to display an error on a node.
 178         # Alias for `self.toolcontext.error(n.hot_location, text)`
 179         fun error(n: nullable ANode, text: String)
 180         do
 181                 var l = null
 182                 if n != null then l = n.hot_location
 183                 self.toolcontext.error(l, text)
 184         end
 185
 186         # Helper function to display a warning on a node.
 187         # Alias for: `self.toolcontext.warning(n.hot_location, text)`
 188         fun warning(n: nullable ANode, tag, text: String)
 189         do
 190                 var l = null
 191                 if n != null then l = n.hot_location
 192                 self.toolcontext.warning(l, tag, text)
 193         end
 194
 195         # Helper function to display an advice on a node.
 196         # Alias for: `self.toolcontext.advice(n.hot_location, text)`
 197         fun advice(n: nullable ANode, tag, text: String)
 198         do
 199                 var l = null
 200                 if n != null then l = n.hot_location
 201                 self.toolcontext.advice(l, tag, text)
 202         end
 203
 204         # Force to get the primitive method named `name` on the type `recv` or do a fatal error on `n`
 205         fun force_get_primitive_method(n: nullable ANode, name: String, recv: MClass, mmodule: MModule): MMethod
 206         do
 207                 var res = mmodule.try_get_primitive_method(name, recv)
 208                 if res == null then
 209                         var l = null
 210                         if n != null then l = n.hot_location
 211                         self.toolcontext.fatal_error(l, "Fatal Error: {recv} must have a property named {name}.")
 212                         abort
 213                 end
 214                 return res
 215         end
 216 end
 217
 218 redef class AVisibility
 219         # The visibility level associated with the AST node class
 220         fun mvisibility: MVisibility is abstract
 221 end
 222 redef class AIntrudeVisibility
 223         redef fun mvisibility do return intrude_visibility
 224 end
 225 redef class APublicVisibility
 226         redef fun mvisibility do return public_visibility
 227 end
 228 redef class AProtectedVisibility
 229         redef fun mvisibility do return protected_visibility
 230 end
 231 redef class APrivateVisibility
 232         redef fun mvisibility do return private_visibility
 233 end
 234
 235 redef class ADoc
 236         private var mdoc_cache: nullable MDoc
 237         fun to_mdoc: MDoc
 238         do
 239                 var res = mdoc_cache
 240                 if res != null then return res
 241                 res = new MDoc
 242                 for c in n_comment do
 243                         var text = c.text
 244                         if text.length < 2 then
 245                                 res.content.add ""
 246                                 continue
 247                         end
 248                         assert text.chars[0] == '#'
 249                         if text.chars[1] == ' ' then
 250                                 text = text.substring_from(2) # eat starting `#` and space
 251                         else
 252                                 text = text.substring_from(1) # eat atarting `#` only
 253                         end
 254                         if text.chars.last == '\n' then text = text.substring(0, text.length-1) # drop \n
 255                         res.content.add(text)
 256                 end
 257                 mdoc_cache = res
 258                 return res
 259         end
 260 end