This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue clojure#1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue clojure#2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

This solves two issues as specified by #CLJ-1134. Issue #1 is solved by doing a
relative jump forward within `absolute-reposition` in cl_format.clj, line 114 by
switching `(- (:pos navigator) position)` with `(- position (:pos navigator))`.

Issue #2 is handled by changing the default `n`-parameter to `*` depending on
whether the `@`-prefix is placed or not. If it is placed, then `n` defaults to
0, otherwise it defaults to 1.

In addition, new tests have been appended to `test_cl_format.clj` to ensure the
correctness of this patch. The tests have been tested on the Common Lisp
implementation GNU CLISP 2.49, which presumably handle the `~n@*`
correctly. This patch and GNU CLISP returns the same output for each format
call, sans case for printed symbols; Common Lisp has case-insensitive symbols,
whereas Clojure has not.

Signed-off-by: Stuart Halloway <stu@cognitect.com>

Typed Locals

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again

The criteria for when a tail call is a safe point to clear 'this':

1) Must be in return position
2) Not in a try block (might need 'this' during catch/finally)
3) When not direct linked

Return position (clojure#1) isn't simply context == C.RETURN because
loop bodies are always parsed in C.RETURN context

A new dynvar METHOD_RETURN_CONTEXT tracks whether an InvokeExpr
in tail position can directly leave the body of the compiled java
method. It is set to RT.T in the outermost parsing of a method body
and invalidated (set to null) when a loop body is being parsed
where the context for the loop expression is not RETURN parsed.

Also, clear on StaticInvokeExpr now that they are a thing again