docs: def _placeholders_recursif(nodelist, plist, blist):
      """Recursively search into a template node list for PlaceholderNode
      node."""
      # I needed to do this lazy import to compile the documentation
      from django.template.loader_tags import BlockNode
  
      if len(blist):
          block = blist[-1]
      else:
          block = None
  
      for node in nodelist:
  
          if isinstance(node, BlockNode):
              if node not in blist:
                  blist.append(node)
              if not block:
                  block = node
  
          if block:
              if isinstance(node, template.base.VariableNode):
                  if(node.filter_expression.var.var == u'block.super'):
                      block.has_super_var = True
  
          # extends node?
          if hasattr(node, 'parent_name'):
              # I do not know why I did this... but the tests are guarding it
              dummy_context2 = Context()
              dummy_context2.template = template.Template("")
              _placeholders_recursif(node.get_parent(dummy_context2).nodelist,
                                     plist, blist)
          # include node?
          elif hasattr(node, 'template') and hasattr(node.template, 'nodelist'):
              _placeholders_recursif(node.template.nodelist, plist, blist)
  
          # Is it a placeholder?
          if hasattr(node, 'page') and hasattr(node, 'parsed') and \
                  hasattr(node, 'as_varname') and hasattr(node, 'name') \
                  and hasattr(node, 'section'):
              if block:
                  node.found_in_block = block
              plist.append(node)
              node.render(dummy_context)
  
          for key in ('nodelist', 'nodelist_true', 'nodelist_false'):
  
              if hasattr(node, key):
                  try:
                      _placeholders_recursif(getattr(node, key), plist, blist)
                  except:
                      pass