#	leak or triggers use-after-free crashes. Leave that to the main
    #	compiler engine (and the STRING allocator) as that gets it right.

    method LoadTypedLiteral {value type} {
	if {[lindex $type 0] eq "IMPURE"} {
	    set sval [my LoadTypedLiteral $value STRING]
	    set itype [lrange $type 1 end]
	    if {$itype in {LIST DICT {EMPTY LIST} {EMPTY DICT}}} {
		return $sval
	    }
	    set tval [my LoadTypedLiteral $value $itype]
	    return [$b impure $itype $sval $tval]
	} elseif {$type eq "DOUBLE"} {
	    return [ConstReal [Type $type] $value]
	} elseif {$type in {"ZEROONE" "BOOLEAN" "ZEROONE BOOLEAN"}} {
	    return [Const [expr {$value}] bool]
	} elseif {$type in {"INT" "ENTIER"}} {
	    return [$b int [expr {entier($value)}]]
	} elseif {$type in {"STRING" "LIST" "DICT" "EMPTY" "EMPTY LIST" "EMPTY DICT"}} {
	    set result [Const $value STRING]
	    $b assume [$b shared $result]
	    return $result
	} else {
	    return -code error \
		"unhandled type for literal \"${value}\": \"$type\""
	}

	    }
	    {{EXPANDED NUMERIC} NUMERIC} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EXPANDED {NUMERIC BOOLEAN}} {NUMERIC BOOLEAN}} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE DICT} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE EMPTY DICT} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {DICT STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EMPTY DICT} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE LIST} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE EMPTY LIST} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {DICT LIST} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EMPTY DICT} {EMPTY LIST}} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE DICT} {IMPURE LIST}} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE EMPTY DICT} {IMPURE EMPTY LIST}} {
		append body2 { $} [lindex $f 0]
	    }
	}

	foreach type {
	    BOOLEAN
	    ZEROONE {ZEROONE BOOLEAN}
	    INT {INT BOOLEAN}

		    return [ConstInt [Type bool] 1 0]
		}
		if {[string is false -strict $value]} {
		    return [ConstInt [Type bool] 0 0]
		}
		error "invalid boolean value \"$value\""
	    }
	    "^STRING$" - "^(?:EMPTY )?(?:LIST|DICT)$" - "^EMPTY$" {
		variable thunkBuilder
		set theObj [$thunkBuilder obj.constant $value]
		return $theObj
	    }
	    {^LLVMTypeRef_\d+$} {
		switch [GetTypeKind $type] {
		    LLVMIntegerTypeKind {

	    ^long$ {
		# Machine word
		return [IntType [expr {$::tcl_platform(wordSize) * 8}]]
	    }
	    {^int(\d+)$} {
		return [IntType [lindex $m 1]]
	    }
	    ^STRING$ - {^(EMPTY )?(LIST|DICT)$} - ^EMPTY$ {
		return [Type named{Tcl_Obj}*]
	    }
	    ^ZEROONE$ - ^BOOLEAN$ - "^ZEROONE BOOLEAN$" {
		return [Type bool]
	    }
	    ^INT$ - ^ENTIER$ - "^INT BOOLEAN$" {
		return [Type named{INT,kind:int1,i32:int,i64:int64}]

    variable NUMERIC		[expr {$DOUBLE | $ENTIER}]

    # NUMERIC_OR_BOOLEAN - the value is a number, or some spelling of
    #                      'true' or 'false'

    variable NUMERIC_OR_BOOLEAN	[expr {$NUMERIC | $BOOLEAN}]

    # NONEMPTYDICT - the value is a non-empty dictionary of some sort. The
    #		types of the keys and the values are just STRING.

    variable NONEMPTYDICT	[expr 0x200]

    # NONDICTLIST - the value is a list of some sort that isn't a dictionary
    #		but isn't empty. The type of the elements is just STRING.

    variable NONDICTLIST	[expr 0x100]

    # LIST - the value is a list of some sort. The type of the elements is
    #		just STRING. Note that a DICT is also a LIST.

    variable LIST		[expr {$NONDICTLIST | $NONEMPTYDICT | $EMPTY}]

    # DICT - the value is a dict of some sort. The type of the keys and values
    #		are just STRING. Note that a DICT is also a LIST.

    variable DICT		[expr {$NONEMPTYDICT | $EMPTY}]

    # FOREACH - the value represents the iterator of a [foreach] or [lmap].
    #           There are no constants of this type, and it is therefore
    #           always pure.

    variable FOREACH		[expr 0x10000]

	DOUBLE		DOUBLE
	BIGINT		ENTIER
	OTHERINT64	INT
	OTHERINT32	INT
	ZEROONE		ZEROONE
	BOOLWORD	BOOLEAN
	NONDICTLIST	LIST
	NONEMPTYDICT	DICT
	DICT		DICT
	LIST		LIST
    } {
	namespace upvar dataType $name t
	if {$type & $t} {
	    namespace upvar dataType $wname w
	    lappend result $wname