code: def access_id(self, id_, lineno, scope=None, default_type=None, default_class=CLASS.unknown):
          
          if isinstance(default_type, symbols.BASICTYPE):
              default_type = symbols.TYPEREF(default_type, lineno, implicit=False)
          assert default_type is None or isinstance(default_type, symbols.TYPEREF)
  
          if not check_is_declared_explicit(lineno, id_):
              return None
  
          result = self.get_entry(id_, scope)
          if result is None:
              if default_type is None:
                  default_type = symbols.TYPEREF(self.basic_types[global_.DEFAULT_IMPLICIT_TYPE],
                                                 lineno, implicit=True)
  
              result = self.declare_variable(id_, lineno, default_type)
              result.declared = False  # It was implicitly declared
              result.class_ = default_class
              return result
  
          # The entry was already declared. If it's type is auto and the default type is not None,
          # update its type.
          if default_type is not None and result.type_ == self.basic_types[TYPE.auto]:
              result.type_ = default_type
              warning_implicit_type(lineno, id_, default_type)
  
          return result
docs: Access a symbol by its identifier and checks if it exists.
          If not, it's supposed to be an implicit declared variable.
  
          default_class is the class to use in case of an undeclared-implicit-accessed id