contrib/jwrapper/src/model.nit

   1 # This file is part of NIT (http://www.nitlanguage.org).
   2 #
   3 # Copyright 2014 Frédéric Vachon <fredvac@gmail.com>
   4 # Copyright 2015 Alexis Laferrière <alexis.laf@xymus.net>
   5 #
   6 # Licensed under the Apache License, Version 2.0 (the "License");
   7 # you may not use this file except in compliance with the License.
   8 # You may obtain a copy of the License at
   9 #
  10 #     http://www.apache.org/licenses/LICENSE-2.0
  11 #
  12 # Unless required by applicable law or agreed to in writing, software
  13 # distributed under the License is distributed on an "AS IS" BASIS,
  14 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 # See the License for the specific language governing permissions and
  16 # limitations under the License.
  17
  18 # Contains the java and nit type representation used to convert java to nit code
  19 module model
  20
  21 import more_collections
  22
  23 import jtype_converter
  24
  25 class JavaType
  26         private var converter: JavaTypeConverter
  27         var identifier = new Array[String]
  28         var generic_params: nullable Array[JavaType] = null
  29         var is_void = false
  30
  31         # Has some generic type to be resolved (T extends foo => T is resolved to foo)
  32         var has_unresolved_types = false
  33
  34         # Dimension of primitive array: `int[][]` is 2d
  35         var array_dimension = 0
  36
  37         fun is_primitive_array: Bool do return array_dimension > 0
  38
  39         fun has_generic_params: Bool do return not generic_params == null
  40         fun full_id: String do return identifier.join(".")
  41         fun id: String do return identifier.last.replace("$", "")
  42
  43         init(converter: JavaTypeConverter) do self.converter = converter
  44
  45         fun return_cast: String do return converter.cast_as_return(self.id)
  46
  47         fun param_cast: String
  48         do
  49                 if self.has_generic_params then
  50                         return converter.cast_as_param(self.generic_params[0].id)
  51                 end
  52
  53                 return converter.cast_as_param(self.id)
  54         end
  55
  56         fun to_nit_type: NitType
  57         do
  58                 var nit_type: NitType
  59                 var type_id = null
  60
  61                 if not is_primitive_array then
  62                         type_id = converter.to_nit_type(self.id)
  63                 end
  64
  65                 if type_id == null then
  66                         nit_type = self.extern_name
  67                         nit_type.is_complete = false
  68                 else
  69                         nit_type = new NitType(type_id)
  70                 end
  71
  72                 if not self.has_generic_params then return nit_type
  73
  74                 nit_type.generic_params = new Array[NitType]
  75
  76                 for param in generic_params do
  77                         var nit_param = param.to_nit_type
  78
  79                         nit_type.generic_params.add(nit_param)
  80
  81                         if not nit_param.is_complete then nit_type.is_complete = false
  82                 end
  83
  84                 return nit_type
  85         end
  86
  87         fun is_collection: Bool do return is_primitive_array or collections_list.has(self.id)
  88
  89         fun is_wrapped: Bool do return find_extern_class != null
  90
  91         fun extern_name: NitType
  92         do
  93                 if is_wrapped then return new NitType.with_module(find_extern_class.as(not null).first, find_extern_class.as(not null).second)
  94
  95                 var name
  96                 if is_primitive_array then
  97                         # Primitive arrays have a special naming convention
  98                         name = "Java" + extern_class_name.join.capitalized + "Array"
  99                 else
 100                         name = "Java" + extern_class_name.join
 101                 end
 102
 103                 name = name.replace("-", "_")
 104
 105                 var nit_type = new NitType(name)
 106                 nit_type.is_complete = false
 107                 return nit_type
 108         end
 109
 110         fun to_cast(jtype: String, is_param: Bool): String
 111         do
 112                 if is_param then
 113                         return converter.cast_as_param(jtype)
 114                 end
 115
 116                 return converter.cast_as_return(jtype)
 117         end
 118
 119         redef fun to_s
 120         do
 121                 var id = self.full_id
 122
 123                 if self.is_primitive_array then
 124                         id += "[]" * array_dimension
 125                 else if self.has_generic_params then
 126                         var params = [for param in generic_params do param.to_s]
 127                         id += "<{params.join(", ")}>"
 128                 end
 129
 130                 return id
 131         end
 132
 133         # To fully qualified package name
 134         # Cuts the primitive array `[]`
 135         fun to_package_name: String
 136         do
 137                 var str = self.to_s
 138                 var len = str.length
 139
 140                 return str.substring(0, len - (2*array_dimension))
 141         end
 142
 143         fun resolve_types(conversion_map: HashMap[String, Array[String]])
 144         do
 145                 if identifier.length == 1 then
 146                         var resolved_id = conversion_map.get_or_null(self.id)
 147                         if resolved_id != null then self.identifier = new Array[String].from(resolved_id)
 148                 end
 149
 150                 if self.has_generic_params then
 151                         for params in generic_params do params.resolve_types(conversion_map)
 152                 end
 153         end
 154
 155         private fun extern_class_name: Array[String]
 156         do
 157                 var class_name = new Array[String]
 158                 class_name.add(self.id)
 159
 160                 if not self.has_generic_params then return class_name
 161
 162                 class_name.add "Of"
 163
 164                 for param in generic_params do class_name.add_all param.extern_class_name
 165
 166                 return class_name
 167         end
 168
 169         # Search inside `lib/android` directory for already wrapped classes
 170         # If found, contains the class identifier and the Nit Module name
 171         var find_extern_class: nullable Couple[String, NitModule] is lazy do
 172
 173                 var regex = "extern class [a-zA-Z1-9]\\\+[ ]\\\+in[ ]\\\+\"Java\"[ ]*`\{[ ]*" + self.to_s + "\\\+[ ]*`\}"
 174                 var nit_dir = "NIT_DIR".environ
 175                 if nit_dir.is_empty then return null
 176
 177                 var grep = new ProcessReader("grep", "-r", regex, nit_dir/"lib/android/", nit_dir/"lib/java/")
 178                 var to_eat = ["private", "extern", "class"]
 179
 180                 var output = grep.read_line
 181
 182                 var output_class = output.substring_from(output.index_of(':') + 1)
 183                 var tokens = output_class.split(" ")
 184
 185                 var nclass_name = ""
 186
 187                 for token in tokens do
 188                         if to_eat.has(token) then continue
 189                         nclass_name = token
 190                         break
 191                 end
 192
 193                 if nclass_name == "" then return null
 194
 195                 var str = output.substring(0, output.search(".nit").from)
 196                 str = str.substring_from(str.last_index_of('/') + 1)
 197                 var mod = new NitModule(str)
 198
 199                 return new Couple[String, NitModule](nclass_name, mod)
 200         end
 201
 202         # Comparison based on fully qualified named and generic params
 203         # Ignores primitive array so `a.b.c[][] == a.b.c`
 204         redef fun ==(other)
 205         do
 206                 if other isa JavaType then
 207                         return self.repr == other.repr
 208                 end
 209                 return false
 210         end
 211
 212         redef fun hash do return self.repr.hash
 213
 214         private fun repr: String
 215         do
 216                 var id = self.full_id
 217
 218                 if self.has_generic_params then
 219                         var gen_list = new Array[String]
 220
 221                         for param in generic_params do
 222                                 gen_list.add(param.to_s)
 223                         end
 224
 225                         id += "<{gen_list.join(", ")}>"
 226                 end
 227
 228                 return id
 229         end
 230
 231         var collections_list: Array[String] is lazy do return ["List", "ArrayList", "LinkedList", "Vector", "Set", "SortedSet", "HashSet", "TreeSet", "LinkedHashSet", "Map", "SortedMap", "HashMap", "TreeMap", "Hashtable", "LinkedHashMap"]
 232         var iterable: Array[String] is lazy do return ["ArrayList", "Set", "HashSet", "LinkedHashSet", "LinkedList", "Stack", "TreeSet", "Vector"]
 233         var maps: Array[String] is lazy do return ["Map", "SortedMap", "HashMap", "TreeMap", "Hashtable", "LinkedHashMap"]
 234 end
 235
 236 class NitType
 237         var identifier: String
 238         var arg_id: String
 239         var generic_params: nullable Array[NitType] = null
 240
 241         # If this NitType was found in `lib/android`, contains the module name to import
 242         var mod: nullable NitModule
 243
 244         # Returns `true` if all types have been successfully converted to Nit type
 245         var is_complete: Bool = true
 246
 247         fun has_generic_params: Bool do return not generic_params == null
 248
 249         fun id: String do return identifier
 250
 251         init (id: String)
 252         do
 253                 self.identifier = id
 254         end
 255
 256         init with_generic_params(id: String, gen_params: String...)
 257         do
 258                 self.init(id)
 259                 self.generic_params = new Array[NitType]
 260                 for param in gen_params do self.generic_params.add new NitType(param)
 261         end
 262
 263         init with_module(id: String, mod: NitModule)
 264         do
 265                 self.init(id)
 266                 self.mod = mod
 267         end
 268
 269         redef fun to_s: String
 270         do
 271                 var id = self.identifier
 272
 273                 if self.has_generic_params then
 274                         var gen_list = new Array[String]
 275
 276                         for param in generic_params do
 277                                 gen_list.add(param.to_s)
 278                         end
 279
 280                         id += "[{gen_list.join(", ")}]"
 281                 end
 282
 283                 return id
 284         end
 285 end
 286
 287 # Model of a single Java class
 288 class JavaClass
 289         # Type of this class
 290         var class_type = new JavaType(new JavaTypeConverter)
 291
 292         # Attributes of this class
 293         var attributes = new HashMap[String, JavaType]
 294
 295         # Methods of this class organized by their name
 296         var methods = new MultiHashMap[String, JavaMethod]
 297
 298         # Importations from this class
 299         var imports = new HashSet[NitModule]
 300 end
 301
 302 # Model of all the Java class analyzed in one run
 303 class JavaModel
 304         # Unknown Java types used in `classes`
 305         var unknown_types = new HashSet[JavaType]
 306
 307         # All analyzed classes
 308         var classes = new Array[JavaClass]
 309 end
 310
 311 # A Java method, with its signature
 312 class JavaMethod
 313         # Type returned by the method
 314         var return_type: JavaType
 315
 316         # Type of the arguments of the method
 317         var params: Array[JavaType]
 318 end
 319
 320 # A Nit module, use to import the referenced extern classes
 321 class NitModule
 322         # Name of the module
 323         var name: String
 324
 325         redef fun ==(other): Bool do return self.to_s == other.to_s
 326         redef fun to_s: String do return self.name
 327         redef fun hash: Int do return self.name.hash
 328 end