code: def tre_return(self, func_name, func_args, func_store, use_mock=True):
          
          def tre_return_handle(loc, tokens):
              internal_assert(len(tokens) == 1, "invalid tail recursion elimination tokens", tokens)
              args = tokens[0][1:-1]  # strip parens
              # check if there is anything in the arguments that will store a reference
              # to the current scope, and if so, abort TRE, since it can't handle that
              if match_in(self.stores_scope, args):
                  return ignore_transform  # this is the only way to make the outer transform call return None
              if self.no_tco:
                  tco_recurse = "return " + func_name + "(" + args + ")"
              else:
                  tco_recurse = "return _coconut_tail_call(" + func_name + (", " + args if args else "") + ")"
              if not func_args or func_args == args:
                  tre_recurse = "continue"
              elif use_mock:
                  tre_recurse = func_args + " = " + tre_mock_var + "(" + args + ")" + "\ncontinue"
              else:
                  tre_recurse = func_args + " = " + args + "\ncontinue"
              return (
                  "try:\n" + openindent
                  + tre_check_var + " = " + func_name + " is " + func_store + "\n" + closeindent
                  + "except _coconut.NameError:\n" + openindent
                  + tre_check_var + " = False\n" + closeindent
                  + "if " + tre_check_var + ":\n" + openindent
                  + tre_recurse + "\n" + closeindent
                  + "else:\n" + openindent
                  + tco_recurse + "\n" + closeindent
              )
          return attach(
              self.start_marker + (keyword("return") + keyword(func_name)).suppress() + self.parens + self.end_marker,
              tre_return_handle,
          )
docs: Generate grammar element that matches a string which is just a TRE return statement.