class_docstr: Check the ``__init__`` method of a given ``nn.Module``.
  
  It ensures that all instance-level attributes can be properly initialized.
  
  Specifically, we do type inference based on attribute values...even
  if the attribute in question has already been typed using
  Python3-style annotations or ``torch.jit.annotate``. This means that
  setting an instance-level attribute to ``[]`` (for ``List``),
  ``{}`` for ``Dict``), or ``None`` (for ``Optional``) isn't enough
  information for us to properly initialize that attribute.
  
  An object of this class can walk a given ``nn.Module``'s AST and
  determine if it meets our requirements or not.
  
  Known limitations
  1. We can only check the AST nodes for certain constructs; we can't
  ``eval`` arbitrary expressions. This means that function calls,
  class instantiations, and complex expressions that resolve to one of
  the "empty" values specified above will NOT be flagged as
  problematic.
  2. We match on string literals, so if the user decides to use a
  non-standard import (e.g. `from typing import List as foo`), we
  won't catch it.
  
  Example:
      .. code-block:: python
  
          class M(torch.nn.Module):
              def fn(self):
                  return []
  
              def __init__(self):
                  super().__init__()
                  self.x: List[int] = []
  
              def forward(self, x: List[int]):
                  self.x = x
                  return 1
  
      The above code will pass the ``AttributeTypeIsSupportedChecker``
      check since we have a function call in ``__init__``. However,
      it will still fail later with the ``RuntimeError`` "Tried to set
      nonexistent attribute: x. Did you forget to initialize it in
      __init__()?".
  
  Args:
      nn_module - The instance of ``torch.nn.Module`` whose
          ``__init__`` method we wish to check
docstr: Determine if a Call node is 'torch.jit.annotate' in __init__.
  
  Visit a Call node in an ``nn.Module``'s ``__init__``
  method and determine if it's ``torch.jit.annotate``. If so,
  see if it conforms to our attribute annotation rules.
code: def visit_Call(self, node):
      """Determine if a Call node is 'torch.jit.annotate' in __init__.
  
      Visit a Call node in an ``nn.Module``'s ``__init__``
      method and determine if it's ``torch.jit.annotate``. If so,
      see if it conforms to our attribute annotation rules.
      """
      # If we have an attribute that's already been annotated at the
      # class level
      if self.visiting_class_level_ann:
          return
  
      # If this isn't a call to `torch.jit.annotate`
      try:
          if (
              node.func.value.value.id != "torch"
              or node.func.value.attr != "jit"
              or node.func.attr != "annotate"
          ):
              self.generic_visit(node)
          elif (
              node.func.value.value.id != "jit"
              or node.func.value.attr != "annotate"
          ):
              self.generic_visit(node)
      except AttributeError:
          # Looks like we didn't even have the right node structure
          # to check for `torch.jit.annotate` in the first place
          self.generic_visit(node)
  
      # Invariant: we have a `torch.jit.annotate` or a
      # `torch.annotate` call
  
      # A Call Node for `torch.jit.annotate` should have an `args`
      # list of length 2 where args[0] represents the annotation and
      # args[1] represents the actual value
      if len(node.args) != 2:
          return
  
      if not isinstance(node.args[0], ast.Subscript):
          return
  
      # See notes in `visit_AnnAssign` r.e. containers
  
      containers = {"List", "Dict", "Optional"}
  
      try:
          ann_type = node.args[0].value.id  # type: ignore[attr-defined]
      except AttributeError:
          return
  
      if ann_type not in containers:
          return
  
      # Check if the assigned variable is empty
      if not self._is_empty_container(node.args[1], ann_type):
          return
  
      warnings.warn(
          "The TorchScript type system doesn't support "
          "instance-level annotations on empty non-base "
          "types in `__init__`. Instead, either 1) use a "
          "type annotation in the class body, or 2) wrap "
          "the type in `torch.jit.Attribute`."
      )
  
file_path: pytorch/torch/jit/_check.py
imports: import ast
  import inspect
  import textwrap
  import warnings
  import torch
label_desc: Use image node_id 5 for calling the AttributeTypeIsSupportedChecker obj's underlying member method code with example usage: obj.visit_Call(node) without return types