Example #1
0
def _getCallCodePosConstantKeywordConstArgs(
    to_name, called_name, expression, call_args, call_kw, emit, context
):
    kw_items = tuple(call_kw.getCompileTimeConstant().items())

    args = call_args.getCompileTimeConstant()

    values = args + tuple(item[1] for item in kw_items)
    kw_names = tuple(item[0] for item in kw_items)

    arg_size = len(args)
    quick_mixed_calls_used.add((arg_size, False, False))

    if isMutable(values):
        args_values_name = context.allocateTempName("call_args_values")

        args_values_name.getCType().emitAssignmentCodeFromConstant(
            to_name=args_values_name,
            constant=values,
            may_escape=True,
            emit=emit,
            context=context,
        )
        vector_name = args_values_name
    else:
        args_values_name = context.getConstantCode(values)
        vector_name = None

    emitLineNumberUpdateCode(expression, emit, context)

    emit(
        """%s = CALL_FUNCTION_WITH_ARGS%d_VECTORCALL(%s, &PyTuple_GET_ITEM(%s, 0), %s);"""
        % (
            to_name,
            arg_size,
            called_name,
            args_values_name,
            context.getConstantCode(kw_names),
        )
    )

    getErrorExitCode(
        check_name=to_name,
        release_names=(called_name, vector_name),
        emit=emit,
        context=context,
    )

    context.addCleanupTempName(to_name)
Example #2
0
def _generateCallCodeKwSplitFromConstant(
    to_name, expression, call_kw, called_name, called_attribute_name, emit, context
):
    assert called_name is not None
    # TODO: Not yet specialized for method calls.
    assert called_attribute_name is None

    kw_items = tuple(call_kw.getCompileTimeConstant().items())

    values = tuple(item[1] for item in kw_items)
    kw_names = tuple(item[0] for item in kw_items)

    if isMutable(values):
        args_kwsplit_name = context.allocateTempName("call_args_kwsplit")

        args_kwsplit_name.getCType().emitAssignmentCodeFromConstant(
            to_name=args_kwsplit_name,
            constant=values,
            may_escape=True,
            emit=emit,
            context=context,
        )
        split_name = args_kwsplit_name
    else:
        args_kwsplit_name = context.getConstantCode(values)
        split_name = None

    emitLineNumberUpdateCode(expression, emit, context)

    emit(
        """%s = CALL_FUNCTION_WITH_NO_ARGS_KWSPLIT(%s, &PyTuple_GET_ITEM(%s, 0), %s);"""
        % (
            to_name,
            called_name,
            args_kwsplit_name,
            context.getConstantCode(kw_names),
        )
    )

    getErrorExitCode(
        check_name=to_name,
        release_names=(called_name, split_name),
        emit=emit,
        context=context,
    )

    context.addCleanupTempName(to_name)
Example #3
0
def _getCallCodeFromTuple(
    to_name, called_name, expression, args_value, needs_check, emit, context
):
    arg_size = len(args_value)

    # For 0 arguments, NOARGS is supposed to be used.
    assert arg_size > 0

    emitLineNumberUpdateCode(expression, emit, context)

    # We create a tuple for the call, as this can be prepared and might have to be
    # recreated for cases, e.g. when calling C functions, so this is a good way of
    # having them.
    if isMutable(args_value):
        arg_tuple_name = context.allocateTempName("call_args_kwsplit")

        arg_tuple_name.getCType().emitAssignmentCodeFromConstant(
            to_name=arg_tuple_name,
            constant=args_value,
            may_escape=True,
            emit=emit,
            context=context,
        )
        args_name = arg_tuple_name
    else:
        arg_tuple_name = context.getConstantCode(constant=args_value)
        args_name = None

    quick_tuple_calls_used.add(arg_size)

    emit(
        """\
%s = CALL_FUNCTION_WITH_POSARGS%d(%s, %s);
"""
        % (to_name, arg_size, called_name, arg_tuple_name)
    )

    getErrorExitCode(
        check_name=to_name,
        release_names=(called_name, args_name),
        needs_check=needs_check,
        emit=emit,
        context=context,
    )

    context.addCleanupTempName(to_name)
Example #4
0
    def getConstantReturnValue(self):
        """Special function that checks if code generation allows to use common C code."""
        body = self.subnode_body

        if body is None:
            return True, None

        first_statement = body.subnode_statements[0]

        if first_statement.isStatementReturnConstant():
            constant_value = first_statement.getConstant()

            # TODO: For mutable constants, we could also have something, but it would require an indicator
            # flag to make a deep copy.
            if not isMutable(constant_value):
                return True, constant_value
            else:
                return False, False
        else:
            return False, False
Example #5
0
def getConstantAccess(to_name, constant, emit, context):
    # Many cases, because for each type, we may copy or optimize by creating
    # empty.  pylint: disable=R0912,R0915

    if type(constant) is dict:
        if constant:
            for key, value in iterItems(constant):
                # key cannot be mutable.
                assert not isMutable(key)
                if isMutable(value):
                    needs_deep = True
                    break
            else:
                needs_deep = False

            if needs_deep:
                code = "DEEP_COPY( %s )" % getConstantCode(constant=constant,
                                                           context=context)
            else:
                code = "PyDict_Copy( %s )" % getConstantCode(constant=constant,
                                                             context=context)
        else:
            code = "PyDict_New()"

        ref_count = 1
    elif type(constant) is set:
        if constant:
            code = "PySet_New( %s )" % getConstantCode(constant=constant,
                                                       context=context)
        else:
            code = "PySet_New( NULL )"

        ref_count = 1
    elif type(constant) is list:
        if constant:
            for value in constant:
                if isMutable(value):
                    needs_deep = True
                    break
            else:
                needs_deep = False

            if needs_deep:
                code = "DEEP_COPY( %s )" % getConstantCode(constant=constant,
                                                           context=context)
            else:
                code = "LIST_COPY( %s )" % getConstantCode(constant=constant,
                                                           context=context)
        else:
            code = "PyList_New( 0 )"

        ref_count = 1
    elif type(constant) is tuple:
        for value in constant:
            if isMutable(value):
                needs_deep = True
                break
        else:
            needs_deep = False

        if needs_deep:
            code = "DEEP_COPY( %s )" % getConstantCode(constant=constant,
                                                       context=context)

            ref_count = 1
        else:
            code = getConstantCode(context=context, constant=constant)

            ref_count = 0
    else:
        code = getConstantCode(context=context, constant=constant)

        ref_count = 0

    emit("%s = %s;" % (
        to_name,
        code,
    ))

    if ref_count:
        context.addCleanupTempName(to_name)
Example #6
0
def getConstantAccess(to_name, constant, emit, context):
    # Many cases, because for each type, we may copy or optimize by creating
    # empty.  pylint: disable=too-many-branches,too-many-statements

    if to_name.c_type == "nuitka_bool" and Options.isDebug():
        info("Missing optimization for constant to C bool.")

    if type(constant) is dict:
        if constant:
            for key, value in iterItems(constant):
                # key cannot be mutable.
                assert not isMutable(key)
                if isMutable(value):
                    needs_deep = True
                    break
            else:
                needs_deep = False

            if needs_deep:
                code = "DEEP_COPY( %s )" % context.getConstantCode(constant)
            else:
                code = "PyDict_Copy( %s )" % context.getConstantCode(constant)
        else:
            code = "PyDict_New()"

        ref_count = 1
    elif type(constant) is set:
        if constant:
            code = "PySet_New( %s )" % context.getConstantCode(constant)
        else:
            code = "PySet_New( NULL )"

        ref_count = 1
    elif type(constant) is list:
        if constant:
            for value in constant:
                if isMutable(value):
                    needs_deep = True
                    break
            else:
                needs_deep = False

            if needs_deep:
                code = "DEEP_COPY( %s )" % context.getConstantCode(constant)
            else:
                code = "LIST_COPY( %s )" % context.getConstantCode(constant)
        else:
            code = "PyList_New( 0 )"

        ref_count = 1
    elif type(constant) is tuple:
        for value in constant:
            if isMutable(value):
                needs_deep = True
                break
        else:
            needs_deep = False

        if needs_deep:
            code = "DEEP_COPY( %s )" % context.getConstantCode(constant)

            ref_count = 1
        else:
            code = context.getConstantCode(constant)

            ref_count = 0
    elif type(constant) is bytearray:
        code = "BYTEARRAY_COPY( %s )" % context.getConstantCode(constant)
        ref_count = 1
    else:
        code = context.getConstantCode(constant=constant)

        ref_count = 0

    if to_name.c_type == "PyObject *":
        value_name = to_name
    else:
        value_name = context.allocateTempName("constant_value")

    emit("%s = %s;" % (value_name, code))

    if to_name is not value_name:
        to_name.getCType().emitAssignConversionCode(
            to_name=to_name,
            value_name=value_name,
            needs_check=False,
            emit=emit,
            context=context,
        )

        # Above is supposed to transfer ownership.
        if ref_count:
            getReleaseCode(value_name, emit, context)
    else:
        if ref_count:
            context.addCleanupTempName(value_name)
Example #7
0
 def isMutable(self):
     return isMutable(self.constant)
Example #8
0
 def isMutable(self):
     return isMutable( self.constant )
Example #9
0
def getConstantAccess(to_name, constant, emit, context):
    # Many cases, because for each type, we may copy or optimize by creating
    # empty.  pylint: disable=R0912,R0915

    if type(constant) is dict:
        if constant:
            for key, value in iterItems(constant):
                # key cannot be mutable.
                assert not isMutable(key)
                if isMutable(value):
                    needs_deep = True
                    break
            else:
                needs_deep = False

            if needs_deep:
                code = "DEEP_COPY( %s )" % getConstantCode(
                    constant = constant,
                    context  = context
                )
            else:
                code = "PyDict_Copy( %s )" % getConstantCode(
                    constant = constant,
                    context  = context
                )
        else:
            code = "PyDict_New()"

        ref_count = 1
    elif type(constant) is set:
        if constant:
            code = "PySet_New( %s )" % getConstantCode(
                constant = constant,
                context  = context
            )
        else:
            code = "PySet_New( NULL )"

        ref_count = 1
    elif type(constant) is list:
        if constant:
            for value in constant:
                if isMutable(value):
                    needs_deep = True
                    break
            else:
                needs_deep = False

            if needs_deep:
                code = "DEEP_COPY( %s )" % getConstantCode(
                    constant = constant,
                    context  = context
                )
            else:
                code = "LIST_COPY( %s )" % getConstantCode(
                    constant = constant,
                    context  = context
                )
        else:
            code = "PyList_New( 0 )"

        ref_count = 1
    elif type(constant) is tuple:
        for value in constant:
            if isMutable(value):
                needs_deep = True
                break
        else:
            needs_deep = False

        if needs_deep:
            code = "DEEP_COPY( %s )" % getConstantCode(
                 constant = constant,
                 context  = context
            )

            ref_count = 1
        else:
            code = getConstantCode(
                context  = context,
                constant = constant
            )

            ref_count = 0
    else:
        code = getConstantCode(
            context  = context,
            constant = constant
        )

        ref_count = 0

    emit(
        "%s = %s;" % (
            to_name,
            code,
        )
    )

    if ref_count:
        context.addCleanupTempName(to_name)
Example #10
0
def makeConstantRefNode(constant, source_ref, user_provided=False):
    # This is dispatching per constant value and types, every case
    # to be a return statement, pylint: disable=too-many-branches,too-many-return-statements,too-many-statements

    # Dispatch based on constants first.
    if constant is None:
        return ExpressionConstantNoneRef(source_ref=source_ref)
    elif constant is True:
        return ExpressionConstantTrueRef(source_ref=source_ref)
    elif constant is False:
        return ExpressionConstantFalseRef(source_ref=source_ref)
    elif constant is Ellipsis:
        return ExpressionConstantEllipsisRef(source_ref=source_ref)
    else:
        # Next, dispatch based on type.
        constant_type = type(constant)

        if constant_type is int:
            return ExpressionConstantIntRef(constant=constant,
                                            source_ref=source_ref)
        elif constant_type is str:
            return ExpressionConstantStrRef(
                constant=constant,
                user_provided=user_provided,
                source_ref=source_ref,
            )
        elif constant_type is float:
            return ExpressionConstantFloatRef(constant=constant,
                                              source_ref=source_ref)
        elif constant_type is long:
            return ExpressionConstantLongRef(
                constant=constant,
                user_provided=user_provided,
                source_ref=source_ref,
            )
        elif constant_type is unicode:
            return ExpressionConstantUnicodeRef(
                constant=constant,
                user_provided=user_provided,
                source_ref=source_ref,
            )
        elif constant_type is bytes:
            return ExpressionConstantBytesRef(
                constant=constant,
                user_provided=user_provided,
                source_ref=source_ref,
            )
        elif constant_type is dict:
            if constant:
                assert isConstant(constant), repr(constant)

                return ExpressionConstantDictRef(
                    constant=constant,
                    user_provided=user_provided,
                    source_ref=source_ref,
                )
            else:
                return ExpressionConstantDictEmptyRef(
                    user_provided=user_provided,
                    source_ref=source_ref,
                )
        elif constant_type is tuple:
            if constant:
                assert isConstant(constant), repr(constant)

                if isMutable(constant):
                    return ExpressionConstantTupleMutableRef(
                        constant=constant,
                        user_provided=user_provided,
                        source_ref=source_ref,
                    )
                else:
                    return ExpressionConstantTupleRef(
                        constant=constant,
                        user_provided=user_provided,
                        source_ref=source_ref,
                    )
            else:
                return ExpressionConstantTupleEmptyRef(
                    user_provided=user_provided,
                    source_ref=source_ref,
                )
        elif constant_type is list:
            if constant:
                assert isConstant(constant), repr(constant)

                return ExpressionConstantListRef(
                    constant=constant,
                    user_provided=user_provided,
                    source_ref=source_ref,
                )
            else:
                return ExpressionConstantListEmptyRef(
                    user_provided=user_provided,
                    source_ref=source_ref,
                )
        elif constant_type is set:
            if constant:
                assert isConstant(constant), repr(constant)

                return ExpressionConstantSetRef(
                    constant=constant,
                    user_provided=user_provided,
                    source_ref=source_ref,
                )
            else:
                return ExpressionConstantSetEmptyRef(
                    user_provided=user_provided,
                    source_ref=source_ref,
                )
        elif constant_type is frozenset:
            if constant:
                assert isConstant(constant), repr(constant)

                return ExpressionConstantFrozensetRef(
                    constant=constant,
                    user_provided=user_provided,
                    source_ref=source_ref,
                )
            else:
                return ExpressionConstantFrozensetEmptyRef(
                    user_provided=user_provided,
                    source_ref=source_ref,
                )
        elif constant_type is complex:
            return ExpressionConstantComplexRef(
                constant=constant,
                source_ref=source_ref,
            )
        elif constant_type is slice:
            return ExpressionConstantSliceRef(
                constant=constant,
                source_ref=source_ref,
            )
        elif constant_type is type:
            return ExpressionConstantTypeRef(constant=constant,
                                             source_ref=source_ref)
        elif constant_type is xrange:
            return ExpressionConstantXrangeRef(
                constant=constant,
                source_ref=source_ref,
            )
        elif constant_type is bytearray:
            return ExpressionConstantBytearrayRef(
                constant=constant,
                user_provided=user_provided,
                source_ref=source_ref,
            )
        elif constant in builtin_anon_values:
            from .BuiltinRefNodes import ExpressionBuiltinAnonymousRef

            return ExpressionBuiltinAnonymousRef(
                builtin_name=builtin_anon_values[constant],
                source_ref=source_ref,
            )
        elif constant in builtin_named_values:
            from .BuiltinRefNodes import ExpressionBuiltinRef

            return ExpressionBuiltinRef(
                builtin_name=builtin_named_values[constant],
                source_ref=source_ref)
        elif constant in builtin_exception_values_list:
            from .BuiltinRefNodes import ExpressionBuiltinExceptionRef

            if constant is NotImplemented:
                exception_name = "NotImplemented"
            else:
                exception_name = constant.__name__

            return ExpressionBuiltinExceptionRef(exception_name=exception_name,
                                                 source_ref=source_ref)
        else:
            # Missing constant type, ought to not happen, please report.
            assert False, (constant, constant_type)
Example #11
0
    def emitAssignmentCodeFromConstant(cls, to_name, constant, emit, context):
        # Many cases to deal with, pylint: disable=too-many-branches,too-many-statements

        if type(constant) is dict:
            if constant:
                for key, value in iterItems(constant):
                    # key cannot be mutable.
                    assert not isMutable(key)
                    if isMutable(value):
                        needs_deep = True
                        break
                else:
                    needs_deep = False

                if needs_deep:
                    code = "DEEP_COPY(%s)" % context.getConstantCode(constant)
                else:
                    code = "PyDict_Copy(%s)" % context.getConstantCode(
                        constant)
            else:
                code = "PyDict_New()"

            ref_count = 1
        elif type(constant) is set:
            if constant:
                code = "PySet_New(%s)" % context.getConstantCode(constant)
            else:
                code = "PySet_New(NULL)"

            ref_count = 1
        elif type(constant) is list:
            if constant:
                for value in constant:
                    if isMutable(value):
                        needs_deep = True
                        break
                else:
                    needs_deep = False

                if needs_deep:
                    code = "DEEP_COPY(%s)" % context.getConstantCode(constant)
                else:
                    code = "LIST_COPY(%s)" % context.getConstantCode(constant)
            else:
                code = "PyList_New(0)"

            ref_count = 1
        elif type(constant) is tuple:
            for value in constant:
                if isMutable(value):
                    needs_deep = True
                    break
            else:
                needs_deep = False

            if needs_deep:
                code = "DEEP_COPY(%s)" % context.getConstantCode(constant)

                ref_count = 1
            else:
                code = context.getConstantCode(constant)

                ref_count = 0
        elif type(constant) is bytearray:
            code = "BYTEARRAY_COPY(%s)" % context.getConstantCode(constant)
            ref_count = 1
        else:
            code = context.getConstantCode(constant=constant)

            ref_count = 0

        if to_name.c_type == "PyObject *":
            value_name = to_name
        else:
            value_name = context.allocateTempName("constant_value")

        emit("%s = %s;" % (value_name, code))

        if to_name is not value_name:
            cls.emitAssignConversionCode(
                to_name=to_name,
                value_name=value_name,
                needs_check=False,
                emit=emit,
                context=context,
            )

            # Above is supposed to transfer ownership.
            if ref_count:
                getReleaseCode(value_name, emit, context)
        else:
            if ref_count:
                context.addCleanupTempName(value_name)
Example #12
0
def getConstantAccess(to_name, constant, emit, context):
    # Many cases, because for each type, we may copy or optimize by creating
    # empty.  pylint: disable=too-many-branches,too-many-statements

    if to_name.c_type == "nuitka_bool" and Options.isDebug():
        assert False, constant

    if type(constant) is dict:
        if constant:
            for key, value in iterItems(constant):
                # key cannot be mutable.
                assert not isMutable(key)
                if isMutable(value):
                    needs_deep = True
                    break
            else:
                needs_deep = False

            if needs_deep:
                code = "DEEP_COPY( %s )" % context.getConstantCode(constant)
            else:
                code = "PyDict_Copy( %s )" % context.getConstantCode(constant)
        else:
            code = "PyDict_New()"

        ref_count = 1
    elif type(constant) is set:
        if constant:
            code = "PySet_New( %s )" % context.getConstantCode(constant)
        else:
            code = "PySet_New( NULL )"

        ref_count = 1
    elif type(constant) is list:
        if constant:
            for value in constant:
                if isMutable(value):
                    needs_deep = True
                    break
            else:
                needs_deep = False

            if needs_deep:
                code = "DEEP_COPY( %s )" % context.getConstantCode(constant)
            else:
                code = "LIST_COPY( %s )" % context.getConstantCode(constant)
        else:
            code = "PyList_New( 0 )"

        ref_count = 1
    elif type(constant) is tuple:
        for value in constant:
            if isMutable(value):
                needs_deep = True
                break
        else:
            needs_deep = False

        if needs_deep:
            code = "DEEP_COPY( %s )" % context.getConstantCode(constant)

            ref_count = 1
        else:
            code = context.getConstantCode(constant)

            ref_count = 0
    elif type(constant) is bytearray:
        code = "BYTEARRAY_COPY( %s )" % context.getConstantCode(constant)
        ref_count = 1
    else:
        code = context.getConstantCode(constant=constant)

        ref_count = 0

    emit("%s = %s;" % (
        to_name,
        code,
    ))

    if ref_count:
        context.addCleanupTempName(to_name)
Example #13
0
    def getConstantCode(self, constant, deep_check=False):
        if deep_check and Options.is_debug:
            assert not isMutable(constant)

        return self.constant_accessor.getConstantCode(constant)
Example #14
0
def _getCallCodePosConstKeywordVariableArgs(
    to_name, called_name, expression, call_args, call_kw, emit, context
):
    # More details, pylint: disable=too-many-locals

    args = call_args.getCompileTimeConstant()

    kw_names = []

    dict_value_names = []

    for count, pair in enumerate(call_kw.subnode_pairs):
        kw_names.append(pair.subnode_key.getCompileTimeConstant())

        dict_value_name = context.allocateTempName("kw_call_value_%d" % count)

        generateExpressionCode(
            to_name=dict_value_name,
            expression=pair.subnode_value,
            emit=emit,
            context=context,
            allow_none=False,
        )

        dict_value_names.append(dict_value_name)

    args_count = len(args)

    quick_mixed_calls_used.add((args_count, True, True))

    if isMutable(args):
        args_value_name = context.allocateTempName("call_posargs_values")

        args_value_name.getCType().emitAssignmentCodeFromConstant(
            to_name=args_value_name,
            constant=args,
            may_escape=True,
            emit=emit,
            context=context,
        )
        args_name = args_value_name
    else:
        args_value_name = context.getConstantCode(args)
        args_name = None

    emitLineNumberUpdateCode(expression, emit, context)

    emit(
        """\
{
    PyObject *kw_values[%(kw_size)d] = {%(kw_values)s};
    %(to_name)s = CALL_FUNCTION_WITH_POSARGS%(args_count)d_KWSPLIT(%(called_name)s, %(pos_args)s, kw_values, %(kw_names)s);
}
"""
        % {
            "to_name": to_name,
            "kw_values": ", ".join(
                str(dict_value_name) for dict_value_name in dict_value_names
            ),
            "kw_size": len(call_kw.subnode_pairs),
            "pos_args": args_value_name,
            "args_count": args_count,
            "called_name": called_name,
            "kw_names": context.getConstantCode(tuple(kw_names)),
        }
    )

    getErrorExitCode(
        check_name=to_name,
        release_names=(called_name, args_name) + tuple(dict_value_names),
        emit=emit,
        context=context,
    )

    context.addCleanupTempName(to_name)
Example #15
0
def getConstantAccess(to_name, constant, emit, context):
    # Many cases, because for each type, we may copy or optimize by creating
    # empty.  pylint: disable=too-many-branches,too-many-statements

    if to_name.c_type == "nuitka_bool" and Options.isDebug():
        info("Missing optimization for constant to C bool.")

    if type(constant) is dict:
        if constant:
            for key, value in iterItems(constant):
                # key cannot be mutable.
                assert not isMutable(key)
                if isMutable(value):
                    needs_deep = True
                    break
            else:
                needs_deep = False

            if needs_deep:
                code = "DEEP_COPY( %s )" % context.getConstantCode(constant)
            else:
                code = "PyDict_Copy( %s )" % context.getConstantCode(constant)
        else:
            code = "PyDict_New()"

        ref_count = 1
    elif type(constant) is set:
        if constant:
            code = "PySet_New( %s )" % context.getConstantCode(constant)
        else:
            code = "PySet_New( NULL )"

        ref_count = 1
    elif type(constant) is list:
        if constant:
            for value in constant:
                if isMutable(value):
                    needs_deep = True
                    break
            else:
                needs_deep = False

            if needs_deep:
                code = "DEEP_COPY( %s )" % context.getConstantCode(constant)
            else:
                code = "LIST_COPY( %s )" % context.getConstantCode(constant)
        else:
            code = "PyList_New( 0 )"

        ref_count = 1
    elif type(constant) is tuple:
        for value in constant:
            if isMutable(value):
                needs_deep = True
                break
        else:
            needs_deep = False

        if needs_deep:
            code = "DEEP_COPY( %s )" % context.getConstantCode(constant)

            ref_count = 1
        else:
            code = context.getConstantCode(constant)

            ref_count = 0
    elif type(constant) is bytearray:
        code = "BYTEARRAY_COPY( %s )" % context.getConstantCode(constant)
        ref_count = 1
    else:
        code = context.getConstantCode(constant=constant)

        ref_count = 0

    if to_name.c_type == "PyObject *":
        value_name = to_name
    else:
        value_name = context.allocateTempName("constant_value")

    emit("%s = %s;" % (value_name, code))

    if ref_count:
        context.addCleanupTempName(value_name)

    if to_name is not value_name:
        to_name.getCType().emitAssignConversionCode(
            to_name=to_name,
            value_name=value_name,
            needs_check=False,
            emit=emit,
            context=context,
        )