path: root/compiler/seminst.nim

#
#
#           The Nimrod Compiler
#        (c) Copyright 2012 Andreas Rumpf
#
#    See the file "copying.txt", included in this
#    distribution, for details about the copyright.
#

# This module implements the instantiation of generic procs.
# included from sem.nim

proc instantiateGenericParamList(c: PContext, n: PNode, pt: TIdTable,
                                 entry: var TInstantiation) = 
  if n.kind != nkGenericParams: 
    InternalError(n.info, "instantiateGenericParamList; no generic params")
  newSeq(entry.concreteTypes, n.len)
  for i in countup(0, n.len - 1):
    var a = n.sons[i]
    if a.kind != nkSym: 
      InternalError(a.info, "instantiateGenericParamList; no symbol")
    var q = a.sym
    if q.typ.kind notin {tyTypeDesc, tyGenericParam, tyTypeClass, tyExpr}: continue
    var s = newSym(skType, q.name, getCurrOwner(), q.info)
    s.flags = s.flags + {sfUsed, sfFromGeneric}
    var t = PType(IdTableGet(pt, q.typ))
    if t == nil:
      if tfRetType in q.typ.flags:
        # keep the generic type and allow the return type to be bound 
        # later by semAsgn in return type inference scenario
        t = q.typ
      else:
        LocalError(a.info, errCannotInstantiateX, s.name.s)
        t = errorType(c)
    elif t.kind == tyGenericParam: 
      InternalError(a.info, "instantiateGenericParamList: " & q.name.s)
    elif t.kind == tyGenericInvokation:
      #t = instGenericContainer(c, a, t)
      t = generateTypeInstance(c, pt, a, t)
      #t = ReplaceTypeVarsT(cl, t)
    s.typ = t
    addDecl(c, s)
    entry.concreteTypes[i] = t

proc sameInstantiation(a, b: TInstantiation): bool =
  if a.concreteTypes.len == b.concreteTypes.len:
    for i in 0..a.concreteTypes.high:
      if not compareTypes(a.concreteTypes[i], b.concreteTypes[i],
                          flags = {TypeDescExactMatch}): return
    result = true

proc GenericCacheGet(genericSym: Psym, entry: TInstantiation): PSym =
  if genericSym.procInstCache != nil:
    for inst in genericSym.procInstCache:
      if sameInstantiation(entry, inst[]):
        return inst.sym

proc removeDefaultParamValues(n: PNode) = 
  # we remove default params, because they cannot be instantiated properly
  # and they are not needed anyway for instantiation (each param is already
  # provided).
  when false:
    for i in countup(1, sonsLen(n)-1): 
      var a = n.sons[i]
      if a.kind != nkIdentDefs: IllFormedAst(a)
      var L = a.len
      if a.sons[L-1].kind != nkEmpty and a.sons[L-2].kind != nkEmpty:
        # ``param: typ = defaultVal``. 
        # We don't need defaultVal for semantic checking and it's wrong for
        # ``cmp: proc (a, b: T): int = cmp``. Hm, for ``cmp = cmp`` that is
        # not possible... XXX We don't solve this issue here.
        a.sons[L-1] = ast.emptyNode

proc freshGenSyms(n: PNode, owner: PSym, symMap: var TIdTable) =
  # we need to create a fresh set of gensym'ed symbols:
  if n.kind == nkSym and sfGenSym in n.sym.flags:
    var x = PSym(IdTableGet(symMap, n.sym))
    if x == nil:
      x = copySym(n.sym, false)
      x.owner = owner
      IdTablePut(symMap, n.sym, x)
    n.sym = x
  else:
    for i in 0 .. <safeLen(n): freshGenSyms(n.sons[i], owner, symMap)

proc addParamOrResult(c: PContext, param: PSym, kind: TSymKind)

proc instantiateBody(c: PContext, n: PNode, result: PSym) =
  if n.sons[bodyPos].kind != nkEmpty:
    # add it here, so that recursive generic procs are possible:
    addDecl(c, result)
    pushProcCon(c, result)
    # add params to scope
    for i in 1 .. <result.typ.n.len:
      var param = result.typ.n.sons[i].sym
      param.owner = result
      addParamOrResult(c, param, result.kind)
    # debug result.typ.n
    maybeAddResult(c, result, n)
    var b = n.sons[bodyPos]
    var symMap: TIdTable
    InitIdTable symMap
    freshGenSyms(b, result, symMap)
    b = semProcBody(c, b)
    b = hloBody(c, b)
    n.sons[bodyPos] = transformBody(c.module, b, result)
    #echo "code instantiated ", result.name.s
    excl(result.flags, sfForward)
    popProcCon(c)

proc fixupInstantiatedSymbols(c: PContext, s: PSym) =
  for i in countup(0, c.generics.len - 1):
    if c.generics[i].genericSym.id == s.id:
      var oldPrc = c.generics[i].inst.sym
      pushInfoContext(oldPrc.info)
      openScope(c)
      var n = oldPrc.ast
      n.sons[bodyPos] = copyTree(s.getBody)
      instantiateBody(c, n, oldPrc)
      closeScope(c)
      popInfoContext()

proc sideEffectsCheck(c: PContext, s: PSym) = 
  if {sfNoSideEffect, sfSideEffect} * s.flags ==
      {sfNoSideEffect, sfSideEffect}: 
    LocalError(s.info, errXhasSideEffects, s.name.s)
  elif sfThread in s.flags and semthreads.needsGlobalAnalysis() and 
      s.ast.sons[genericParamsPos].kind == nkEmpty:
    c.threadEntries.add(s)

proc instGenericContainer(c: PContext, info: TLineInfo, header: PType): PType =
  var cl: TReplTypeVars
  InitIdTable(cl.symMap)
  InitIdTable(cl.typeMap)
  cl.info = info
  cl.c = c
  result = ReplaceTypeVarsT(cl, header)

proc instGenericContainer(c: PContext, n: PNode, header: PType): PType =
  result = instGenericContainer(c, n.info, header)

proc fixupProcType(c: PContext, genericType: PType,
                   inst: TInstantiation): PType =
  # XXX: This is starting to look suspiciously like ReplaceTypeVarsT
  # there are few apparent differences, but maybe the code could be
  # moved over.
  # * the code here uses the new genericSym.position property when
  #   doing lookups. 
  # * the handling of tyTypeDesc seems suspicious in ReplaceTypeVarsT
  #   typedesc params were previously handled in the second pass of
  #   semParamList
  # * void (nkEmpty) params doesn't seem to be stripped in ReplaceTypeVarsT
  result = genericType
  if result == nil: return

  case genericType.kind
  of tyGenericParam, tyTypeClass:
    result = inst.concreteTypes[genericType.sym.position]
  of tyTypeDesc:
    result = inst.concreteTypes[genericType.sym.position]
    if tfUnresolved in genericType.flags:
      result = result.sons[0]
  of tyExpr:
    result = inst.concreteTypes[genericType.sym.position]
  of tyOpenArray, tyArray, tySet, tySequence, tyTuple, tyProc,
     tyPtr, tyVar, tyRef, tyOrdinal, tyRange, tyVarargs:
    if genericType.sons == nil: return
    var head = 0
    for i in 0 .. <genericType.sons.len:
      let origType = genericType.sons[i]
      var changed = fixupProcType(c, origType, inst)
      if changed != genericType.sons[i]:
        var changed = changed.skipIntLit
        if result == genericType:
          # the first detected change initializes the result
          result = copyType(genericType, genericType.owner, false)
          if genericType.n != nil:
            result.n = copyTree(genericType.n)

        # XXX: doh, we have to treat seq and arrays as special case
        # because sometimes the `@` magic will be applied to an empty
        # sequence having the type tySequence(tyEmpty)
        if changed.kind == tyEmpty and
           genericType.kind notin {tyArray, tySequence}:
          if genericType.kind == tyProc and i == 0:
            # return types of procs are overwritten with nil
            changed = nil
          else:
            # otherwise, `empty` is just erased from the signature
            result.sons[i..i] = []
            if result.n != nil: result.n.sons[i..i] = []
            continue
        
        result.sons[head] = changed
        
        if result.n != nil:
          if result.n.kind == nkRecList:
            for son in result.n.sons:
              if son.typ == origType:
                son.typ = changed
                son.sym = copySym(son.sym, true)
                son.sym.typ = changed
          if result.n.kind == nkFormalParams:
            if i != 0:
              let origParam = result.n.sons[head].sym
              var param = copySym(origParam)
              param.typ = changed
              param.ast = origParam.ast
              result.n.sons[head] = newSymNode(param)

      # won't be advanced on empty (void) nodes
      inc head
  
  of tyGenericInvokation:
    result = newTypeWithSons(c, tyGenericInvokation, genericType.sons)
    for i in 1 .. <genericType.sons.len:
      result.sons[i] = fixupProcType(c, result.sons[i], inst)
    result = instGenericContainer(c, getInfoContext(-1), result)
  
  else: nil

proc generateInstance(c: PContext, fn: PSym, pt: TIdTable,
                      info: TLineInfo): PSym =
  # no need to instantiate generic templates/macros:
  if fn.kind in {skTemplate, skMacro}: return fn
  
  # generates an instantiated proc
  if c.InstCounter > 1000: InternalError(fn.ast.info, "nesting too deep")
  inc(c.InstCounter)
  # careful! we copy the whole AST including the possibly nil body!
  var n = copyTree(fn.ast)
  # NOTE: for access of private fields within generics from a different module
  # we set the friend module:
  var oldFriend = c.friendModule
  c.friendModule = getModule(fn)
  #let oldScope = c.currentScope
  #c.currentScope = fn.scope
  result = copySym(fn, false)
  incl(result.flags, sfFromGeneric)
  result.owner = fn
  result.ast = n
  pushOwner(result)
  openScope(c)
  if n.sons[genericParamsPos].kind == nkEmpty: 
    InternalError(n.info, "generateInstance")
  n.sons[namePos] = newSymNode(result)
  pushInfoContext(info)
  var entry = TInstantiation.new
  entry.sym = result
  instantiateGenericParamList(c, n.sons[genericParamsPos], pt, entry[])
  result.typ = fixupProcType(c, fn.typ, entry[])
  n.sons[genericParamsPos] = ast.emptyNode
  var oldPrc = GenericCacheGet(fn, entry[])
  if oldPrc == nil:
    fn.procInstCache.safeAdd(entry)
    c.generics.add(makeInstPair(fn, entry))
    if n.sons[pragmasPos].kind != nkEmpty:
      pragma(c, result, n.sons[pragmasPos], allRoutinePragmas)
    if isNil(n.sons[bodyPos]):
      n.sons[bodyPos] = copyTree(fn.getBody)
    if fn.kind != skTemplate:
      instantiateBody(c, n, result)
      sideEffectsCheck(c, result)
    ParamsTypeCheck(c, result.typ)
  else:
    result = oldPrc
  popInfoContext()
  closeScope(c)           # close scope for parameters
  popOwner()
  #c.currentScope = oldScope
  c.friendModule = oldFriend
  dec(c.InstCounter)
  if result.kind == skMethod: finishMethod(c, result)