src/semantize/auto_super_init.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 # Computing of super-constructors that must be implicitely called at the begin of constructors.
  18 # The current rules are a bit crazy but whatever.
  19 module auto_super_init
  20
  21 import typing
  22 private import annotation
  23
  24 redef class ToolContext
  25         var auto_super_init_phase: Phase = new AutoSuperInitPhase(self, [typing_phase])
  26 end
  27
  28 private class AutoSuperInitPhase
  29         super Phase
  30         redef fun process_npropdef(npropdef) do if npropdef isa AMethPropdef then npropdef.do_auto_super_init(toolcontext.modelbuilder)
  31 end
  32
  33 private class AutoSuperInitVisitor
  34         super Visitor
  35         init
  36         do
  37         end
  38
  39         redef fun visit(n)
  40         do
  41                 n.accept_auto_super_init(self)
  42                 n.visit_all(self)
  43         end
  44
  45         var has_explicit_super_init: nullable ANode = null
  46 end
  47
  48
  49 redef class AMethPropdef
  50         # In case of introduced constructor, the list of implicit auto super init constructors invoked (if needed)
  51         var auto_super_inits: nullable Array[CallSite] = null
  52
  53         # In case of redefined constructors, is an implicit call-to-super required?
  54         var auto_super_call = false
  55
  56         # Collect initializers and build the auto-init
  57         fun do_auto_super_init(modelbuilder: ModelBuilder)
  58         do
  59                 var mclassdef = self.parent.as(AClassdef).mclassdef.as(not null)
  60                 var mpropdef = self.mpropdef.as(not null)
  61                 var mmodule = mpropdef.mclassdef.mmodule
  62                 var anchor = mclassdef.bound_mtype
  63                 var recvtype = mclassdef.mclass.mclass_type
  64
  65                 # Get the annotation, but check its pertinence before returning
  66                 var nosuper = get_single_annotation("nosuper", modelbuilder)
  67
  68                 # Collect only for constructors
  69                 if not mpropdef.mproperty.is_init then
  70                         if nosuper != null then modelbuilder.error(nosuper, "Error: nosuper only in `init`")
  71                         return
  72                 end
  73
  74                 # FIXME: THIS IS STUPID (be here to keep the old code working)
  75                 if not mpropdef.mclassdef.is_intro then return
  76
  77                 # Do we inherit for a constructor?
  78                 var skip = true
  79                 for cd in mclassdef.in_hierarchy.direct_greaters do
  80                         if cd.mclass.kind.need_init then skip = false
  81                 end
  82                 if skip then return
  83
  84                 # Now we search for the absence of any explicit super-init invocation
  85                 #  * via a "super"
  86                 #  * via a call of an other init
  87                 var nblock = self.n_block
  88                 if nblock != null then
  89                         var v = new AutoSuperInitVisitor
  90                         v.enter_visit(nblock)
  91                         var anode = v.has_explicit_super_init
  92                         if anode != null then
  93                                 if nosuper != null then modelbuilder.error(anode, "Error: method is annotated nosuper but a constructor call is present")
  94                                 return
  95                         end
  96                 end
  97
  98                 if nosuper != null then return
  99
 100                 # Still here? So it means that we must add an implicit super-call on redefinitions.
 101                 if not mpropdef.is_intro then
 102                         auto_super_call = true
 103                         mpropdef.has_supercall = true
 104                         return
 105                 end
 106
 107                 # Still here? So it means that we must determine what super inits need to be automatically invoked
 108                 # The code that follow is required to deal with complex cases with old-style and new-style inits
 109
 110                 # Look for old-style super constructors
 111                 var auto_super_inits = new Array[CallSite]
 112                 for msupertype in mclassdef.supertypes do
 113                         # FIXME: the order is quite arbitrary
 114                         if not msupertype.mclass.kind.need_init then continue
 115                         msupertype = msupertype.anchor_to(mmodule, mclassdef.bound_mtype)
 116                         var candidate = modelbuilder.try_get_mproperty_by_name2(self, mmodule, msupertype, mpropdef.mproperty.name)
 117                         if candidate == null then
 118                                 candidate = modelbuilder.try_get_mproperty_by_name2(self, mmodule, msupertype, "init")
 119                         end
 120                         if candidate == null then
 121                                 modelbuilder.error(self, "Error: Cannot do an implicit constructor call in {mpropdef}; there is no constructor named {mpropdef.mproperty.name} in {msupertype}.")
 122                                 return
 123                         end
 124                         assert candidate isa MMethod
 125
 126                         # Skip new-style init
 127                         if candidate.is_root_init then continue
 128
 129                         var candidatedefs = candidate.lookup_definitions(mmodule, anchor)
 130                         var candidatedef = candidatedefs.first
 131                         # TODO, we drop the others propdefs in the callsite, that is not great :(
 132
 133                         var msignature = candidatedef.new_msignature or else candidatedef.msignature
 134                         msignature = msignature.resolve_for(recvtype, anchor, mmodule, true)
 135
 136                         var callsite = new CallSite(self, recvtype, mmodule, anchor, true, candidate, candidatedef, msignature, false)
 137                         auto_super_inits.add(callsite)
 138                 end
 139
 140                 # No old style? The look for new-style super constructors (called from a old style constructor)
 141                 var the_root_init_mmethod = modelbuilder.the_root_init_mmethod
 142                 if the_root_init_mmethod != null and auto_super_inits.is_empty then
 143                         var candidatedefs = the_root_init_mmethod.lookup_definitions(mmodule, anchor)
 144
 145                         # Search the longest-one and checks for conflict
 146                         var candidatedef = candidatedefs.first
 147                         if candidatedefs.length > 1 then
 148                                 # Check for conflict in the order of initializers
 149                                 # Each initializer list must me a prefix of the longest list
 150                                 # part 1. find the longest list
 151                                 for spd in candidatedefs do
 152                                         if spd.initializers.length > candidatedef.initializers.length then candidatedef = spd
 153                                 end
 154                                 # compare
 155                                 for spd in candidatedefs do
 156                                         var i = 0
 157                                         for p in spd.initializers do
 158                                                 if p != candidatedef.initializers[i] then
 159                                                         modelbuilder.error(self, "Error: Cannot do an implicit constructor call to comflicting for inherited inits {spd}({spd.initializers.join(", ")}) and {candidatedef}({candidatedef.initializers.join(", ")}). NOTE: Do not mix old-style and new-style init!")
 160                                                         return
 161                                                 end
 162                                                 i += 1
 163                                         end
 164                                 end
 165                         end
 166
 167                         var msignature = candidatedef.new_msignature or else candidatedef.msignature
 168                         msignature = msignature.resolve_for(recvtype, anchor, mmodule, true)
 169
 170                         var callsite = new CallSite(self, recvtype, mmodule, anchor, true, the_root_init_mmethod, candidatedef, msignature, false)
 171                         auto_super_inits.add(callsite)
 172                 end
 173                 if auto_super_inits.is_empty then
 174                         modelbuilder.error(self, "Error: No constructors to call implicitely in {mpropdef}. Call one explicitely.")
 175                         return
 176                 end
 177
 178                 # Can the super-constructors be called?
 179                 for auto_super_init in auto_super_inits do
 180                         var auto_super_init_def = auto_super_init.mpropdef
 181                         var msig = mpropdef.msignature.as(not null)
 182                         var supermsig = auto_super_init.msignature
 183                         if supermsig.arity > msig.arity then
 184                                 modelbuilder.error(self, "Error: Cannot do an implicit constructor call to {auto_super_init_def}{supermsig}. Expected at least {supermsig.arity} arguments, got {msig.arity}.")
 185                                 continue
 186                         end
 187                         var i = 0
 188                         for sp in supermsig.mparameters do
 189                                 var p = msig.mparameters[i]
 190                                 var sub = p.mtype
 191                                 var sup = sp.mtype
 192                                 if not sub.is_subtype(mmodule, anchor, sup) then
 193                                         modelbuilder.error(self, "Error: Cannot do an implicit constructor call to {auto_super_init_def}{supermsig}. Expected argument #{i} of type {sp.mtype}, got implicit argument {p.name} of type {p.mtype}.")
 194                                         break
 195                                 end
 196                                 i += 1
 197                         end
 198                 end
 199                 self.auto_super_inits = auto_super_inits
 200         end
 201
 202 end
 203
 204 redef class ANode
 205         private fun accept_auto_super_init(v: AutoSuperInitVisitor) do end
 206 end
 207
 208
 209 redef class ASendExpr
 210         redef fun accept_auto_super_init(v)
 211         do
 212                 var mproperty = self.callsite.mproperty
 213                 if mproperty.is_init then
 214                         v.has_explicit_super_init = self
 215                 end
 216         end
 217 end
 218
 219 redef class ASuperExpr
 220         redef fun accept_auto_super_init(v)
 221         do
 222                 # If the super is a standard call-next-method then there it is considered am explicit super init call
 223                 # The the super is a "super int" then it is also an explicit super init call
 224                 v.has_explicit_super_init = self
 225         end
 226 end