Note that neither the Microsoft C# compiler nor the Mono one emit tail calls. In practice, the MS .NET Just-In-Time compiler however transforms tail recursion to loops even if the compiler didn't ask for it if a number of conditions are met. I'm no JVM expert by any means but I don't see why the JVM couldn't do something similar, in theory or in practice.

The F# compiler does, and not just for self-recursive calls.

> the MS .NET Just-In-Time compiler however transforms tail recursion to loops

The hard problem is to have mutually recursive functions ... A() calls B() calls C() calls A().

I'm currently working on a compiler that behind the scenes implements trampolines, so if you had something like ...

  int methodA() {
      // does something here
      return methodB("calling B");
  }

  int methodA(TailCallException ex) {
      // do something here

      ex.method = methodB;
      ex.args   = [ 'calling B' ];
      throw ex;
  }

  // trampoline implemented for any method with tail-calls
  int methodA() {
      int result;
      has_next = true;
      method = reference to methodA;
      args   = []

      // reusing the same TailCallException instance
      exc = new TailCallException(); 

      while (has_next) {
          try {
              result = method.invoke(args, exc);
              has_next = false;
          }
          catch (TailCallException ex) {
              method = ex.method;
              args   = ex.args;
          }
      }

      return result;
  }