#	cf -	The reference to the current callframe if 'havecf' is true.
    #	ec -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	resultName (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	None. The command's return value is in the coroutine promise.

    method invokeNRE {arguments havecf cf ec {resultName ""}} {
	my ExtractVector $arguments
	if {!$havecf} {
	    set cf {}
	}
	my call ${tcl.invoke.command.nre} [list $len $ary $cf $ec] $resultName

    #	flags -	LLVM bit array indicating which arguments to expand.
    #	ec -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	resultName (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	None. The command's return value is in the coroutine promise.

    method invokeExpanded {arguments flags ec {resultName ""}} {
	my ExtractVector $arguments
	my call ${tcl.invoke.expanded} [list $len $ary $flags $ec] $resultName
    }

    # Builder:invokeExpandedNRE --

    #	cf -	The reference to the current callframe if 'havecf' is true.
    #	ec -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	resultName (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	None.

    method invokeExpandedNRE {arguments flags havecf cf ec {resultName ""}} {
	my ExtractVector $arguments
	if {!$havecf} {
	    set cf {}
	}
	my call ${tcl.invoke.expanded.nre} [list $len $ary $flags $cf $ec] \

		    set arguments [my IssueNREReturnFromInvoke $theframe $l]
		    foreach aa $arguments {
			set arguments [lassign $arguments a]
			if {$a ni $arguments && consumed($a, $pc + 1)} {
			    lappend consumed $a
			}
		    }
		}
		"NRE.returnFromInvokeExpanded" {
		    set arguments \
			[my IssueNREReturnFromInvokeExpanded $theframe $l]
		    foreach aa $arguments {
			set arguments [lassign $arguments a]
			if {$a ni $arguments && consumed($a, $pc + 1)} {
			    lappend consumed $a
			}
		    }
		}
		"frameArgs" {
		    lassign $l opcode tgt src
		    set name [my LocalVarName $tgt]
		    set opcode frame.args
		    append opcode ( [my ValueTypes $src] )
		    set val [my LoadOrLiteral $src]

	if {callframe($thecallframe)} {
	    set result [$b frame.pack $callframe $result]
	}
	my StoreResult $tgt $result
	$b clearVector $objv $types $arguments
	return $arguments
    }

    # TclCompiler:IssueNREInvokeExpanded --
    #
    #	Issues the codeburst needed to handle invocation with argument
    #	expansion in the NRE environment.
    #
    # Parameters:
    #	callframe - LLVM reference to the call frame
    #	operation - The quadcode operation being compiled
    #
    # Results:
    #	None.

    method IssueNREInvokeExpanded {callframe operation} {
	set arguments [lassign $operation opcode tgt thecallframe]
	set rettype [lindex $opcode 1]
	set vname [my LocalVarName $tgt]
	set expandPositions [lmap s $arguments {
	    expr {"EXPANDED" in [my OperandType $s]}

	return .[rectest3 nn]
    }
}

proc openclose {} {
    close [open /dev/null w]
}

proc openclose2 {lst} {
    close [open {*}$lst]
}
    

proc treecollect {t} {
    set l {}
    treewalk l $t
    return $l
}
proc treewalk {lvar t} {

    {singleton::llindex}
    {singleton::srange}
    {rectest1}
    {treecollect {a {b {d {h i}} {e {j k}}} {c {f {l m}} {g {n o}}}}}
    {list [catch rectest2 result] $result}
    {set x 3; rectest3 x}
    {openclose}
    {openclose2 {/dev/null w}}
    {qsort {3 6 8 7 0 1 4 2 9 5}}
    {impure 0x0 0 0}
    {impure 0x3 0 0}
    {impure 0 1 1}
    {impure 10 10000 10}
    {impure 1 +2000 [string range "123" 2 2]}
    {impure-typecheck-int 10 10000 10}

    # Combined feature tests
    lcmRange
    bug-0616bcf08e::*
    rectest1
    rectest2
    rectest3
    openclose
    openclose2
    treecollect
    treewalk
    qsort
    impure
    impure-caller
    impure-typecheck-int
    impure2