class_docstr: Gather aliasing informations across nodes
  
  As a result, each node from the module is associated to a set of node or
  Intrinsic to which it *may* alias to.
class_docstr_tok: ["Gather","aliasing","informations","across","nodes","As","a","result",",","each","node","from","the","module","is","associated","to","a","set","of","node","or","Intrinsic","to","which","it","*","may","*","alias","to","."]
docstr: Initialise aliasing default value before visiting.
  
  Add aliasing values for :
      - Pythonic
      - globals declarations
      - current function arguments
docstr_tok: ["Initialise","aliasing","default","value","before","visiting",".","Add","aliasing","values","for",":","-","Pythonic","-","globals","declarations","-","current","function","arguments"]
code: def visit_FunctionDef(self, node):
      """
      Initialise aliasing default value before visiting.
  
      Add aliasing values for :
          - Pythonic
          - globals declarations
          - current function arguments
      """
      self.aliases = IntrinsicAliases.copy()
  
      self.aliases.update(
          (k, {v}) for k, v in self.global_declarations.items()
      )
  
      self.aliases.update((arg.id, {arg}) for arg in node.args.args)
  
      self.generic_visit(node)
      if Aliases.RetId in self.aliases:
          # parametrize the expression
          def parametrize(exp):
              # constant or global -> no change
              if isinstance(
                  exp, (ast.Constant, Intrinsic, ast.FunctionDef)
              ):
                  return lambda _: {exp}
              elif isinstance(exp, ContainerOf):
                  index = exp.index
                  return lambda args: {
                      ContainerOf(
                          {
                              pc
                              for containee in exp.containees
                              for pc in parametrize(containee)(args)
                          },
                          index,
                      )
                  }
              elif isinstance(exp, ast.Name):
                  try:
                      w = node.args.args.index(exp)
  
                      def return_alias(args):
                          if w < len(args):
                              return {args[w]}
                          else:
                              return {node.args.defaults[w - len(args)]}
  
                      return return_alias
                  except ValueError:
                      return lambda _: self.get_unbound_value_set()
              elif isinstance(exp, ast.Subscript):
                  values = parametrize(exp.value)
                  slices = parametrize(exp.slice)
                  return lambda args: {
                      ast.Subscript(value, slice, ast.Load())
                      for value in values(args)
                      for slice in slices(args)
                  }
              else:
                  return lambda _: self.get_unbound_value_set()
  
          # this is a little tricky: for each returned alias,
          # parametrize builds a function that, given a list of args,
          # returns the alias
          # then as we may have multiple returned alias, we compute the union
          # of these returned aliases
          return_aliases = [
              parametrize(ret_alias)
              for ret_alias in self.aliases[Aliases.RetId]
          ]
  
          def merge_return_aliases(args):
              return {
                  ra
                  for return_alias in return_aliases
                  for ra in return_alias(args)
              }
  
          node.return_alias = merge_return_aliases
  
imports: from pythran.analyses.global_declarations import GlobalDeclarations
  from pythran.intrinsic import Intrinsic, Class, UnboundValue
  from pythran.passmanager import ModuleAnalysis
  from pythran.tables import functions, methods, MODULES
  from pythran.unparse import Unparser
  from pythran.conversion import demangle
  import pythran.metadata
  from pythran.utils import isnum
  from pythran.syntax import PythranSyntaxError
  import gast
  from copy import deepcopy
  from itertools import product
  import io
label_desc: Use image node_id 22 for calling the Aliases obj's underlying member method code with example usage: obj.visit_FunctionDef(node) and returns: unknown, function, function, return_alias, function, function, function, unknown, unknown