move lots of source files around to match their actual placement in the original treemain

1 files changed, 0 insertions, 1962 deletions

diff --git a/compiler_and_linker/unsorted/CTemplateTools.c b/compiler_and_linker/unsorted/CTemplateTools.c
deleted file mode 100644
index 0e77e74..0000000
--- a/compiler_and_linker/unsorted/CTemplateTools.c
+++ /dev/null
@@ -1,1962 +0,0 @@
-#include "compiler/CTemplateTools.h"
-#include "compiler/CABI.h"
-#include "compiler/CDecl.h"
-#include "compiler/CError.h"
-#include "compiler/CExpr.h"
-#include "compiler/CFunc.h"
-#include "compiler/CInline.h"
-#include "compiler/CInt64.h"
-#include "compiler/CMachine.h"
-#include "compiler/CParser.h"
-#include "compiler/CScope.h"
-#include "compiler/CTemplateClass.h"
-#include "compiler/CTemplateNew.h"
-#include "compiler/CompilerTools.h"
-#include "compiler/enode.h"
-#include "compiler/objects.h"
-#include "compiler/scopes.h"
-#include "compiler/templates.h"
-#include "compiler/types.h"
-
-short ctempl_instdepth;
-
-void CTemplTool_PushInstance(TemplStack *stack, TypeClass *tmclass, Object *func) {
-    if (tmclass) {
-        stack->u.theclass = tmclass;
-        stack->is_func = 0;
-    } else {
-        stack->u.func = func;
-        stack->is_func = 1;
-    }
-    stack->next = ctempl_curinstance;
-    ctempl_curinstance = stack;
-
-    if (++ctempl_instdepth >= 64)
-        CError_ErrorTerm(CErrorStr314);
-}
-
-void CTemplTool_PopInstance(TemplStack *stack) {
-    CError_ASSERT(53, ctempl_curinstance == stack);
-
-    ctempl_curinstance = stack->next;
-    if (--ctempl_instdepth < 0)
-        ctempl_instdepth = 0;
-}
-
-ENode *CTempTool_GetPTMTemplArgExpr(ENode *expr, Type *type) {
-    NameSpaceObjectList *list;
-
-    CError_ASSERT(69, ENODE_IS(expr, EMEMBER));
-    CError_ASSERT(70, IS_TYPE_MEMBERPOINTER(type));
-
-    if (!copts.cpp_extensions) {
-        if (!expr->data.emember->x11 || !expr->data.emember->pr_1D)
-            CError_Warning(CErrorStr331);
-    }
-
-    type = TYPE_MEMBER_POINTER(type)->ty1;
-    for (list = expr->data.emember->list; list; list = list->next) {
-        if (list->object->otype == OT_MEMBERVAR) {
-            if (!is_typeequal(OBJ_MEMBER_VAR(list->object)->type, type))
-                CError_Error(CErrorStr146);
-            return expr;
-        }
-
-        if (list->object->otype == OT_OBJECT && is_memberpointerequal(OBJECT(list->object)->type, type)) {
-            if (expr->data.emember->list != list || list->next) {
-                // rewrite the EMEMBER to contain just one node
-                expr->data.emember->list = galloc(sizeof(NameSpaceObjectList));
-                *expr->data.emember->list = *list;
-                expr->data.emember->list->next = NULL;
-            }
-            break;
-        }
-    }
-
-    if (!list)
-        CError_Error(CErrorStr146);
-
-    return expr;
-}
-
-Boolean CTemplTool_InitDeduceInfo(DeduceInfo *info, TemplParam *params, TemplArg *args, Boolean flag) {
-    int i;
-    TemplArg *buffer;
-    TemplParam *param;
-
-    if (!params) {
-        info->args = info->argBuffer;
-        info->maxCount = 0;
-        info->x12C = 0xFF;
-        return 1;
-    }
-
-    memclrw(info, sizeof(DeduceInfo));
-
-    i = 0;
-    param = params;
-    while (param) {
-        param = param->next;
-        i++;
-    }
-
-    if (i > 16) {
-        buffer = lalloc(i * sizeof(TemplArg));
-        memclrw(buffer, i * sizeof(TemplArg));
-    } else {
-        buffer = info->argBuffer;
-    }
-    info->args = buffer;
-    info->maxCount = i;
-    info->x12C = params->pid.nindex;
-
-    for (param = params, i = 0; param; param = param->next, i++)
-        buffer[i].pid = param->pid;
-
-    i = 0;
-    param = params;
-    while (args) {
-        if (!param || param->pid.type != args->pid.type)
-            return 0;
-
-        buffer[i].data = args->data;
-        if (i > 0)
-            buffer[i - 1].next = &buffer[i];
-        buffer[i].next = NULL;
-        buffer[i].is_deduced = 1;
-        info->count++;
-
-        if (param->pid.type == TPT_NONTYPE && !CTemplTool_IsTemplateArgumentDependentType(param->data.paramdecl.type)) {
-            if (CExpr_CanImplicitlyConvert(buffer[i].data.paramdecl.expr, param->data.paramdecl.type, param->data.paramdecl.qual)) {
-                buffer[i].data.paramdecl.expr = CExpr_AssignmentPromotion(
-                    buffer[i].data.paramdecl.expr, param->data.paramdecl.type, param->data.paramdecl.qual, 0);
-            } else {
-                return 0;
-            }
-        }
-
-        args = args->next;
-        param = param->next;
-        i++;
-    }
-
-    if (flag) {
-        for (param = params, i = 0; param; param = param->next, i++) {
-            if (!buffer[i].is_deduced && !param->name) {
-                switch (param->pid.type) {
-                    case TPT_TYPE:
-                        buffer[i].data.typeparam.type = &stvoid;
-                        break;
-                    case TPT_NONTYPE:
-                        buffer[i].data.paramdecl.expr = nullnode();
-                        break;
-                    case TPT_TEMPLATE:
-                    default:
-                        CError_FATAL(208);
-                }
-                buffer[i].is_deduced = 1;
-            }
-        }
-    }
-
-    return 1;
-}
-
-void CTemplTool_InsertTemplateParameter(NameSpace *nspace, TemplParam *param) {
-    Type *type;
-    ObjType *obj;
-    NameSpaceName *nsn;
-
-    type = CDecl_NewTemplDepType(TEMPLDEP_ARGUMENT);
-    TYPE_TEMPLATE(type)->u.pid = param->pid;
-
-    obj = galloc(sizeof(ObjType));
-    memclrw(obj, sizeof(ObjType));
-    obj->otype = OT_TYPE;
-    obj->access = ACCESSPUBLIC;
-    obj->type = type;
-
-    for (nsn = nspace->tparams; nsn; nsn = nsn->next) {
-        if (nsn->name == param->name) {
-            CError_Error(CErrorStr122, param->name->name);
-            return;
-        }
-    }
-
-    nsn = galloc(sizeof(NameSpaceName));
-    memclrw(nsn, sizeof(NameSpaceName));
-
-    nsn->name = param->name;
-    nsn->first.object = OBJ_BASE(obj);
-
-    nsn->next = nspace->tparams;
-    nspace->tparams = nsn;
-}
-
-TemplArg *CTemplTool_MakeTemplArgList(DeduceInfo *info) {
-    TemplArg *args;
-    TemplArg *last;
-    int i;
-
-    for (i = 0; i < info->maxCount; i++) {
-        if (i) {
-            last->next = galloc(sizeof(TemplArg));
-            last = last->next;
-        } else {
-            args = last = galloc(sizeof(TemplArg));
-        }
-
-        *last = info->args[i];
-    }
-
-    last->next = NULL;
-    return args;
-}
-
-Boolean CTemplTool_IsIdenticalTemplArgList(TemplArg *args, TemplParam *params) {
-    while (args) {
-        if (!params)
-            return 0;
-
-        CError_ASSERT(297, params->pid.type == args->pid.type);
-
-        switch (args->pid.type) {
-            case TPT_TYPE:
-                if (
-                    !IS_TYPE_TEMPLATE(args->data.typeparam.type) ||
-                    TYPE_TEMPLATE(args->data.typeparam.type)->dtype != TEMPLDEP_ARGUMENT ||
-                    TYPE_TEMPLATE(args->data.typeparam.type)->u.pid.index != params->pid.index ||
-                    TYPE_TEMPLATE(args->data.typeparam.type)->u.pid.nindex != params->pid.nindex
-                    )
-                    return 0;
-                break;
-            case TPT_NONTYPE:
-                if (
-                    !ENODE_IS(args->data.paramdecl.expr, ETEMPLDEP) ||
-                    args->data.paramdecl.expr->data.templdep.subtype != TDE_PARAM ||
-                    args->data.paramdecl.expr->data.templdep.u.pid.index != params->pid.index ||
-                    args->data.paramdecl.expr->data.templdep.u.pid.nindex != params->pid.nindex
-                    )
-                    return 0;
-                break;
-            case TPT_TEMPLATE:
-                if (
-                    !IS_TYPE_TEMPLATE(args->data.ttargtype) ||
-                    TYPE_TEMPLATE(args->data.ttargtype)->dtype != TEMPLDEP_ARGUMENT ||
-                    TYPE_TEMPLATE(args->data.ttargtype)->u.pid.index != params->pid.index ||
-                    TYPE_TEMPLATE(args->data.ttargtype)->u.pid.nindex != params->pid.nindex
-                    )
-                    return 0;
-                break;
-            default:
-                CError_FATAL(331);
-        }
-
-        args = args->next;
-        params = params->next;
-    }
-
-    return !params;
-}
-
-Type *CTemplTool_GetSelfRefTemplate(Type *type) {
-    TemplClass *templ;
-    TemplArg *args;
-
-    CError_ASSERT(347, IS_TYPE_TEMPLATE(type));
-
-    if (TYPE_TEMPLATE(type)->dtype == TEMPLDEP_TEMPLATE) {
-        if (CTemplTool_IsIdenticalTemplArgList(
-            TYPE_TEMPLATE(type)->u.templ.args,
-            TYPE_TEMPLATE(type)->u.templ.templ->templ__params))
-            return TYPE(TYPE_TEMPLATE(type)->u.templ.templ);
-
-        if (TYPE_TEMPLATE(type)->u.templ.templ->pspecs) {
-            templ = TYPE_TEMPLATE(type)->u.templ.templ;
-            if (
-                CTemplClass_FindPartialTemplate(TYPE_TEMPLATE(type)->u.templ.args, &templ, &args) &&
-                CTemplTool_IsIdenticalTemplArgList(args, templ->templ__params)
-                )
-                return TYPE(templ);
-        }
-
-        return NULL;
-    }
-
-    if (TYPE_TEMPLATE(type)->dtype == TEMPLDEP_QUALNAME) {
-        Type *t = CTemplTool_GetSelfRefTemplate(TYPE(TYPE_TEMPLATE(type)->u.qual.type));
-        if (
-            t &&
-            (t = CScope_GetLocalTagType(TYPE_CLASS(t)->nspace, TYPE_TEMPLATE(type)->u.qual.name)) &&
-            IS_TEMPL_CLASS(t) &&
-            !TEMPL_CLASS(t)->templ__params
-            )
-            return t;
-
-        return NULL;
-    }
-
-    if (TYPE_TEMPLATE(type)->dtype == TEMPLDEP_QUALTEMPL) {
-        Type *t;
-
-        CError_ASSERT(389, TYPE_TEMPLATE(TYPE_TEMPLATE(type)->u.qualtempl.type)->dtype == TEMPLDEP_QUALNAME);
-
-        t = CTemplTool_GetSelfRefTemplate(TYPE(TYPE_TEMPLATE(TYPE_TEMPLATE(type)->u.qualtempl.type)->u.qual.type));
-        if (
-            t &&
-            (t = CScope_GetLocalTagType(TYPE_CLASS(t)->nspace, TYPE_TEMPLATE(TYPE_TEMPLATE(type)->u.qualtempl.type)->u.qual.name)) &&
-            IS_TEMPL_CLASS(t)
-            )
-        {
-            TemplClass *tm = TEMPL_CLASS(t);
-            if (CTemplTool_IsIdenticalTemplArgList(TYPE_TEMPLATE(type)->u.qualtempl.args, tm->templ__params))
-                return TYPE(tm);
-        }
-    }
-
-    return NULL;
-}
-
-TemplateFunction *CTemplTool_GetFuncTempl(Object *object) {
-    while (object->datatype == DALIAS)
-        object = object->u.alias.object;
-
-    CError_ASSERT(416, IS_TEMPL_FUNC(object->type));
-    return object->u.func.u.templ;
-}
-
-Boolean CTemplTool_ParamHasDefaultArg(TemplParam *param) {
-    switch (param->pid.type) {
-        case TPT_TYPE:
-            return param->data.typeparam.type != NULL;
-        case TPT_NONTYPE:
-            return param->data.paramdecl.defaultarg != NULL;
-        case TPT_TEMPLATE:
-        default:
-            CError_FATAL(438);
-            return 0;
-    }
-}
-
-void CTemplTool_MergeDefaultArgs(TemplParam *dest, TemplParam *src) {
-    while (1) {
-        if (!dest) {
-            CError_ASSERT(455, !src);
-            return;
-        }
-
-        CError_ASSERT(458, src);
-        CError_ASSERT(459, dest->pid.type == src->pid.type);
-
-        switch (dest->pid.type) {
-            case TPT_TYPE:
-                if (!dest->data.typeparam.type && src->data.typeparam.type)
-                    dest->data = src->data;
-                break;
-            case TPT_NONTYPE:
-                if (!dest->data.paramdecl.defaultarg && src->data.paramdecl.defaultarg)
-                    dest->data = src->data;
-                break;
-            case TPT_TEMPLATE:
-                if (!dest->data.templparam.defaultarg && src->data.templparam.defaultarg)
-                    dest->data = src->data;
-                break;
-            default:
-                CError_FATAL(484);
-        }
-
-        dest = dest->next;
-        src = src->next;
-    }
-}
-
-static FuncArg *CTemplTool_GetFirstRealArg(TypeFunc *tfunc) {
-    FuncArg *arg = tfunc->args;
-
-    if (IS_TYPEFUNC_NONSTATIC_METHOD(tfunc)) {
-        CError_ASSERT(502, arg);
-        arg = arg->next;
-        if ((tfunc->flags & FUNC_IS_CTOR) && (TYPE_METHOD(tfunc)->theclass->flags & CLASS_HAS_VBASES)) {
-            CError_ASSERT(507, arg);
-            arg = arg->next;
-        }
-    }
-
-    return arg;
-}
-
-void CTemplTool_MergeArgNames(TypeFunc *src, TypeFunc *dest) {
-    FuncArg *destArg;
-    FuncArg *srcArg;
-
-    CError_ASSERT(524, IS_TYPE_FUNC(dest) && IS_TYPE_FUNC(src));
-
-    srcArg = CTemplTool_GetFirstRealArg(src);
-    destArg = CTemplTool_GetFirstRealArg(dest);
-
-    while (1) {
-        if (!srcArg || !destArg || srcArg == &elipsis || destArg == &elipsis) {
-            CError_ASSERT(531, srcArg == destArg);
-            break;
-        }
-
-        destArg->name = srcArg->name;
-        srcArg = srcArg->next;
-        destArg = destArg->next;
-    }
-
-    if (IS_TYPEFUNC_NONSTATIC_METHOD(dest)) {
-        CError_ASSERT(538, destArg = dest->args);
-        if (!destArg->name)
-            destArg->name = this_name_node;
-    }
-}
-
-Boolean CTemplTool_EqualParams(TemplParam *a, TemplParam *b, Boolean copyNames) {
-    while (1) {
-        if (!a)
-            return !b;
-        if (!b)
-            return 0;
-
-        if (a->pid.type != b->pid.type)
-            return 0;
-
-        if (copyNames)
-            a->name = b->name;
-
-        switch (a->pid.type) {
-            case TPT_TYPE:
-                break;
-            case TPT_NONTYPE:
-                if (
-                    !is_typesame(a->data.paramdecl.type, b->data.paramdecl.type) ||
-                    a->data.paramdecl.qual != b->data.paramdecl.qual
-                    )
-                    return 0;
-                break;
-            case TPT_TEMPLATE:
-                break;
-            default:
-                CError_FATAL(576);
-        }
-
-        a = a->next;
-        b = b->next;
-    }
-}
-
-NameSpace *CTemplTool_SetupTemplateArgumentNameSpace(TemplParam *params, TemplArg *args, Boolean is_global) {
-    NameSpace *nspace;
-    Boolean clear_global;
-    ObjType *objType;
-    Object *object;
-
-    clear_global = 0;
-    if (!is_global && trychain) {
-        clear_global = 1;
-        is_global = 1;
-    }
-
-    nspace = CScope_NewListNameSpace(NULL, is_global);
-    nspace->is_templ = 1;
-
-    if (clear_global)
-        nspace->is_global = 0;
-
-    if (!params)
-        return nspace;
-
-    while (params) {
-        CError_ASSERT(607, args);
-
-        if (params->name) {
-            switch (args->pid.type) {
-                case TPT_TYPE:
-                    if (is_global) {
-                        objType = galloc(sizeof(ObjType));
-                        memclrw(objType, sizeof(ObjType));
-                    } else {
-                        objType = lalloc(sizeof(ObjType));
-                        memclrw(objType, sizeof(ObjType));
-                    }
-                    objType->otype = OT_TYPE;
-                    objType->access = ACCESSPUBLIC;
-                    objType->type = args->data.typeparam.type;
-                    objType->qual = args->data.typeparam.qual;
-                    CScope_AddObject(nspace, params->name, OBJ_BASE(objType));
-                    break;
-                case TPT_NONTYPE:
-                    if (is_global) {
-                        object = galloc(sizeof(Object));
-                        memclrw(object, sizeof(Object));
-                    } else {
-                        object = lalloc(sizeof(Object));
-                        memclrw(object, sizeof(Object));
-                    }
-                    object->otype = OT_OBJECT;
-                    object->access = ACCESSPUBLIC;
-                    object->nspace = nspace;
-                    object->name = params->name;
-                    object->type = args->data.paramdecl.expr->rtype;
-                    object->qual = ENODE_QUALS(args->data.paramdecl.expr);
-                    object->datatype = DEXPR;
-                    object->u.expr = args->data.paramdecl.expr;
-                    if (IS_TYPE_REFERENCE(params->data.paramdecl.type)) {
-                        CError_ASSERT(652, IS_TYPE_POINTER_ONLY(object->u.expr->rtype));
-                        object->u.expr = makemonadicnode(object->u.expr, EINDIRECT);
-                        object->u.expr->rtype = TPTR_TARGET(params->data.paramdecl.type);
-                    }
-                    if (is_global)
-                        object->u.expr = CInline_CopyExpression(object->u.expr, CopyMode1);
-                    CScope_AddObject(nspace, params->name, OBJ_BASE(object));
-                    break;
-                case TPT_TEMPLATE:
-                    if (is_global) {
-                        objType = galloc(sizeof(ObjType));
-                        memclrw(objType, sizeof(ObjType));
-                    } else {
-                        objType = lalloc(sizeof(ObjType));
-                        memclrw(objType, sizeof(ObjType));
-                    }
-                    objType->otype = OT_TYPE;
-                    objType->access = ACCESSPUBLIC;
-                    objType->type = args->data.ttargtype;
-                    objType->qual = 0;
-                    CScope_AddObject(nspace, params->name, OBJ_BASE(objType));
-                    break;
-                default:
-                    CError_FATAL(681);
-            }
-        }
-
-        params = params->next;
-        args = args->next;
-    }
-
-    CError_ASSERT(685, !args);
-
-    return nspace;
-}
-
-void CTemplTool_SetupOuterTemplateArgumentNameSpace(NameSpace *nspace) {
-    NameSpace *newns;
-
-    while (nspace) {
-        if (nspace->theclass && (nspace->theclass->flags & CLASS_IS_TEMPL_INST)) {
-            newns = CTemplTool_SetupTemplateArgumentNameSpace(
-                TEMPL_CLASS_INST(nspace->theclass)->templ->templ__params,
-                TEMPL_CLASS_INST(nspace->theclass)->inst_args,
-                0);
-            newns->parent = nspace->parent;
-            nspace->parent = newns;
-        }
-
-        nspace = nspace->parent;
-    }
-}
-
-NameSpace *CTemplTool_InsertTemplateArgumentNameSpace(TemplParam *params, TemplClassInst *inst, CScopeSave *save) {
-    NameSpace *nspace = CTemplTool_SetupTemplateArgumentNameSpace(params, inst->inst_args, 0);
-
-    nspace->parent = inst->theclass.nspace->parent;
-    inst->theclass.nspace->parent = nspace;
-
-    CTemplTool_SetupOuterTemplateArgumentNameSpace(nspace);
-    CScope_SetNameSpaceScope(inst->theclass.nspace, save);
-
-    return nspace;
-}
-
-void CTemplTool_RemoveOuterTemplateArgumentNameSpace(NameSpace *nspace) {
-    while (nspace->parent) {
-        if (nspace->theclass && (nspace->theclass->flags & CLASS_IS_TEMPL_INST) && nspace->parent->is_templ)
-            nspace->parent = nspace->parent->parent;
-        nspace = nspace->parent;
-    }
-}
-
-void CTemplTool_RemoveTemplateArgumentNameSpace(NameSpace *nspace, TemplClassInst *inst, CScopeSave *save) {
-    CTemplTool_RemoveOuterTemplateArgumentNameSpace(inst->theclass.nspace);
-    CScope_RestoreScope(save);
-}
-
-Boolean CTemplTool_IsTemplateArgumentDependentType(Type *type) {
-    FuncArg *arg;
-
-    while (1) {
-        switch (type->type) {
-            case TYPETEMPLATE:
-                return 1;
-            case TYPEVOID:
-            case TYPEINT:
-            case TYPEFLOAT:
-            case TYPEENUM:
-            case TYPESTRUCT:
-                return 0;
-            case TYPECLASS:
-                return (TYPE_CLASS(type)->flags & CLASS_IS_TEMPL) ? 1 : 0;
-            case TYPEMEMBERPOINTER:
-                if (CTemplTool_IsTemplateArgumentDependentType(TYPE_MEMBER_POINTER(type)->ty1))
-                    return 1;
-                type = TYPE_MEMBER_POINTER(type)->ty2;
-                continue;
-            case TYPEPOINTER:
-            case TYPEARRAY:
-                type = TPTR_TARGET(type);
-                continue;
-            case TYPEFUNC:
-                for (arg = TYPE_FUNC(type)->args; arg && arg != &elipsis && arg != &oldstyle; arg = arg->next) {
-                    if (CTemplTool_IsTemplateArgumentDependentType(arg->type))
-                        return 1;
-                }
-                type = TYPE_FUNC(type)->functype;
-                continue;
-            case TYPEBITFIELD:
-                type = TYPE_BITFIELD(type)->bitfieldtype;
-                continue;
-            case TYPETEMPLDEPEXPR:
-                return 1;
-            default:
-                CError_FATAL(822);
-        }
-    }
-}
-
-Boolean CTemplTool_IsTemplateArgumentDependentExpression(ENode *expr) {
-    if (!expr)
-        return 0;
-
-    if (IS_TYPE_TEMPLDEPEXPR(expr->rtype))
-        return 1;
-
-    return 0;
-}
-
-Boolean CTemplTool_IsSameTemplate(TemplParam *params, TemplArg *args) {
-    while (1) {
-        if (!args) {
-            CError_ASSERT(850, !params);
-            return 1;
-        }
-
-        CError_ASSERT(853, params && args->pid.type == params->pid.type);
-
-        switch (args->pid.type) {
-            case TPT_TYPE:
-                if (
-                    !IS_TYPE_TEMPLATE(args->data.typeparam.type) ||
-                    TYPE_TEMPLATE(args->data.typeparam.type)->dtype != TEMPLDEP_ARGUMENT ||
-                    TYPE_TEMPLATE(args->data.typeparam.type)->u.pid.nindex != params->pid.nindex ||
-                    TYPE_TEMPLATE(args->data.typeparam.type)->u.pid.index != params->pid.index ||
-                    args->data.typeparam.qual != 0
-                    )
-                    return 0;
-                break;
-            case TPT_NONTYPE:
-                if (
-                    !ENODE_IS(args->data.paramdecl.expr, ETEMPLDEP) ||
-                    args->data.paramdecl.expr->data.templdep.subtype != TDE_PARAM ||
-                    args->data.paramdecl.expr->data.templdep.u.pid.nindex != params->pid.nindex ||
-                    args->data.paramdecl.expr->data.templdep.u.pid.index != params->pid.index
-                    )
-                    return 0;
-                break;
-            case TPT_TEMPLATE:
-                if (!IS_TYPE_TEMPLATE(args->data.ttargtype))
-                    return 0;
-                break;
-            default:
-                CError_FATAL(886);
-        }
-
-        args = args->next;
-        params = params->next;
-    }
-}
-
-TemplClass *CTemplTool_IsTemplate(TypeTemplDep *ttd) {
-    if (ttd->dtype == TEMPLDEP_QUALNAME && ttd->u.qual.type->dtype == TEMPLDEP_TEMPLATE)
-        ttd = ttd->u.qual.type;
-    else if (ttd->dtype != TEMPLDEP_TEMPLATE)
-        return NULL;
-
-    if (CTemplTool_IsSameTemplate(ttd->u.templ.templ->templ__params, ttd->u.templ.args))
-        return ttd->u.templ.templ;
-    else
-        return NULL;
-}
-
-Type *CTemplTool_IsDependentTemplate(TemplClass *tmclass, TemplArg *args) {
-    TemplParam *param;
-    TemplArg *arg;
-    Type *type;
-
-    if (!tmclass->templ_parent || tmclass->inst_parent) {
-        arg = args;
-        param = tmclass->templ__params;
-        while (1) {
-            if (!arg) {
-                CError_ASSERT(988, !param);
-                return NULL;
-            }
-
-            CError_ASSERT(991, param && arg->pid.type == param->pid.type);
-
-            switch (arg->pid.type) {
-                case TPT_TYPE:
-                    if (CTemplTool_IsTemplateArgumentDependentType(arg->data.typeparam.type))
-                        goto done;
-                    break;
-                case TPT_NONTYPE:
-                    if (CTemplTool_IsTemplateArgumentDependentExpression(arg->data.paramdecl.expr))
-                        goto done;
-                    break;
-                case TPT_TEMPLATE:
-                    if (!IS_TYPE_CLASS(arg->data.ttargtype) && CTemplTool_IsTemplateArgumentDependentType(arg->data.ttargtype))
-                        goto done;
-                    break;
-                default:
-                    CError_FATAL(1008);
-                    goto done;
-            }
-
-            arg = arg->next;
-            param = param->next;
-        }
-    }
-done:
-    if (cscope_current->theclass == TYPE_CLASS(tmclass) && CTemplTool_IsSameTemplate(tmclass->templ__params, args))
-        return TYPE(tmclass);
-
-    type = CDecl_NewTemplDepType(TEMPLDEP_TEMPLATE);
-    TYPE_TEMPLATE(type)->u.templ.templ = tmclass;
-    TYPE_TEMPLATE(type)->u.templ.args = args;
-    return type;
-}
-
-Boolean CTemplTool_EqualExprTypes(ENode *a, ENode *b) {
-    Object *objA;
-    Object *objB;
-
-    if (!a || !b)
-        return 0;
-    if (a->type != b->type)
-        return 0;
-
-    switch (a->type) {
-        case EINTCONST:
-            return CInt64_Equal(a->data.intval, b->data.intval);
-        case EOBJREF:
-            objA = a->data.objref;
-            while (objA->datatype == DALIAS)
-                objA = objA->u.alias.object;
-            objB = b->data.objref;
-            while (objB->datatype == DALIAS)
-                objB = objB->u.alias.object;
-            return objA == objB;
-        case EMEMBER:
-            return a->data.emember->list == b->data.emember->list;
-        case ETEMPLDEP:
-            if (a->data.templdep.subtype != b->data.templdep.subtype)
-                return 0;
-
-            switch (a->data.templdep.subtype) {
-                case TDE_PARAM:
-                    return a->data.templdep.u.pid.nindex == b->data.templdep.u.pid.nindex &&
-                        a->data.templdep.u.pid.index == b->data.templdep.u.pid.index;
-                case TDE_SIZEOF:
-                case TDE_ALIGNOF:
-                    return is_typesame(a->data.templdep.u.typeexpr.type, b->data.templdep.u.typeexpr.type);
-                case TDE_CAST:
-                    return is_typesame(a->data.templdep.u.cast.type, b->data.templdep.u.cast.type) &&
-                        a->data.templdep.u.cast.qual == b->data.templdep.u.cast.qual;
-                case TDE_QUALNAME:
-                    return is_typesame(TYPE(a->data.templdep.u.qual.type), TYPE(b->data.templdep.u.qual.type)) &&
-                           a->data.templdep.u.qual.name == b->data.templdep.u.qual.name;
-                case TDE_OBJ:
-                    return a->data.templdep.u.obj == b->data.templdep.u.obj;
-                case TDE_ADDRESS_OF:
-                    return CTemplTool_EqualExprTypes(a->data.templdep.u.monadic, b->data.templdep.u.monadic);
-                default:
-                    CError_FATAL(1086);
-            }
-        case EMUL:
-        case EDIV:
-        case EMODULO:
-        case EADD:
-        case ESUB:
-        case ESHL:
-        case ESHR:
-        case ELESS:
-        case EGREATER:
-        case ELESSEQU:
-        case EGREATEREQU:
-        case EEQU:
-        case ENOTEQU:
-        case EAND:
-        case EXOR:
-        case EOR:
-        case ELAND:
-        case ELOR:
-        case EROTL:
-        case EROTR:
-            return CTemplTool_EqualExprTypes(a->data.diadic.left, b->data.diadic.left) &&
-                   CTemplTool_EqualExprTypes(a->data.diadic.right, b->data.diadic.right);
-        case EMONMIN:
-        case EBINNOT:
-        case ELOGNOT:
-            return CTemplTool_EqualExprTypes(a->data.monadic, b->data.monadic);
-        case ECOND:
-            return CTemplTool_EqualExprTypes(a->data.cond.cond, b->data.cond.cond) &&
-                   CTemplTool_EqualExprTypes(a->data.cond.expr1, b->data.cond.expr1) &&
-                   CTemplTool_EqualExprTypes(a->data.cond.expr2, b->data.cond.expr2);
-        default:
-            CError_FATAL(1122);
-            return 0;
-    }
-}
-
-ENode *CTempl_MakeTemplDepExpr(ENode *left, ENodeType nt, ENode *right) {
-    if (!IS_TYPE_TEMPLDEPEXPR(right->rtype)) {
-        right = pointer_generation(right);
-        if (!ENODE_IS(right, EINTCONST)) {
-            CError_Error(CErrorStr348);
-            right = nullnode();
-        }
-    }
-
-    if (left) {
-        if (!IS_TYPE_TEMPLDEPEXPR(left->rtype)) {
-            left = pointer_generation(left);
-            if (!ENODE_IS(left, EINTCONST)) {
-                CError_Error(CErrorStr348);
-                left = nullnode();
-            }
-        }
-
-        left = makediadicnode(left, right, nt);
-    } else {
-        left = makemonadicnode(right, nt);
-    }
-
-    left->rtype = &sttemplexpr;
-    return left;
-}
-
-void CTemplTool_CheckTemplArgType(Type *type) {
-    while (IS_TYPE_POINTER_ONLY(type))
-        type = TPTR_TARGET(type);
-
-    if (IS_TYPE_CLASS(type)) {
-        if (IsTempName(TYPE_CLASS(type)->classname) || CScope_IsInLocalNameSpace(TYPE_CLASS(type)->nspace))
-            CError_Error(CErrorStr232);
-    }
-}
-
-Boolean CTemplTool_EqualArgs(TemplArg *a, TemplArg *b) {
-    while (a) {
-        if (!b || a->pid.type != b->pid.type)
-            return 0;
-
-        switch (a->pid.type) {
-            case TPT_TYPE:
-                if (
-                    !is_typesame(a->data.typeparam.type, b->data.typeparam.type) ||
-                    a->data.typeparam.qual != b->data.typeparam.qual
-                    )
-                    return 0;
-                break;
-            case TPT_NONTYPE:
-                if (!CTemplTool_EqualExprTypes(a->data.paramdecl.expr, b->data.paramdecl.expr))
-                    return 0;
-                break;
-            case TPT_TEMPLATE:
-                if (!is_typesame(a->data.ttargtype, b->data.ttargtype))
-                    return 0;
-                break;
-            default:
-                CError_FATAL(1215);
-        }
-
-        a = a->next;
-        b = b->next;
-    }
-
-    if (b)
-        return 0;
-
-    return 1;
-}
-
-TemplArg *CTemplTool_MakeGlobalTemplArgCopy(TemplArg *args) {
-    TemplArg *firstCopy;
-    TemplArg *copy;
-
-    firstCopy = NULL;
-    while (args) {
-        if (firstCopy) {
-            copy->next = galloc(sizeof(TemplArg));
-            copy = copy->next;
-        } else {
-            copy = galloc(sizeof(TemplArg));
-            firstCopy = copy;
-        }
-
-        *copy = *args;
-        if (copy->pid.type == TPT_NONTYPE && copy->data.paramdecl.expr)
-            copy->data.paramdecl.expr = CInline_CopyExpression(copy->data.paramdecl.expr, CopyMode1);
-
-        args = args->next;
-    }
-
-    return firstCopy;
-}
-
-Boolean CTemplTool_TemplDepTypeCompare(TypeTemplDep *a, TypeTemplDep *b) {
-    if (a == b)
-        return 1;
-    if (a->dtype != b->dtype)
-        return 0;
-
-    switch (a->dtype) {
-        case TEMPLDEP_ARGUMENT:
-            return a->u.pid.nindex == b->u.pid.nindex &&
-                   a->u.pid.index == b->u.pid.index;
-        case TEMPLDEP_QUALNAME:
-            return CTemplTool_TemplDepTypeCompare(a->u.qual.type, b->u.qual.type) &&
-                   a->u.qual.name == b->u.qual.name;
-        case TEMPLDEP_TEMPLATE:
-            return a->u.templ.templ == b->u.templ.templ &&
-                   CTemplTool_EqualArgs(a->u.templ.args, b->u.templ.args);
-        case TEMPLDEP_ARRAY:
-            return is_typesame(a->u.array.type, b->u.array.type) &&
-                   CTemplTool_EqualExprTypes(a->u.array.index, b->u.array.index);
-        case TEMPLDEP_QUALTEMPL:
-            return CTemplTool_TemplDepTypeCompare(a->u.qualtempl.type, b->u.qualtempl.type) &&
-                   CTemplTool_EqualArgs(a->u.qualtempl.args, b->u.qualtempl.args);
-        case TEMPLDEP_BITFIELD:
-            return is_typesame(a->u.bitfield.type, b->u.bitfield.type) &&
-                   CTemplTool_EqualExprTypes(a->u.bitfield.size, b->u.bitfield.size);
-        default:
-            CError_FATAL(1286);
-            return 0;
-    }
-}
-
-Type *CTemplTool_DeduceArgDepType(TemplArg *args, Type *type, UInt32 qual, UInt32 *resultQual) {
-    TemplArg *arg;
-
-    *resultQual = qual;
-
-    if (IS_TYPE_TEMPLATE(type) && TYPE_TEMPLATE(type)->dtype == TEMPLDEP_ARGUMENT) {
-        arg = args;
-        while (1) {
-            if (!arg)
-                return NULL;
-
-            if (
-                arg->pid.index == TYPE_TEMPLATE(type)->u.pid.index &&
-                arg->pid.nindex == TYPE_TEMPLATE(type)->u.pid.nindex
-            )
-                break;
-
-            arg = arg->next;
-        }
-
-        CError_ASSERT(1314, arg->pid.type == TPT_TYPE);
-        *resultQual |= arg->data.typeparam.qual;
-        return arg->data.typeparam.type;
-    }
-
-    return NULL;
-}
-
-static TemplClassInst *CTemplTool_FindNestedClassInstance(TemplClass *a, TemplClass *b, TemplClassInst *c) {
-    TemplClass *array[32];
-    TemplClassInst *inst;
-    int i;
-
-    array[0] = a;
-    i = 0;
-    while (1) {
-        CError_ASSERT(1338, i < 32);
-        CError_ASSERT(1339, a = a->templ_parent);
-
-        if (a == b)
-            break;
-
-        CError_ASSERT(1341, a->templ__params == NULL);
-
-        array[++i] = a;
-    }
-
-    while (1) {
-        inst = array[i--]->instances;
-        while (1) {
-            CError_ASSERT(1350, inst);
-            if (inst->parent == c)
-                break;
-            inst = inst->next;
-        }
-
-        c = inst;
-        if (i < 0)
-            break;
-
-        if ((inst->theclass.flags & (CLASS_COMPLETED | CLASS_IS_TEMPL_INST)) == CLASS_IS_TEMPL_INST)
-            CTempl_InstantiateTemplateClass(TYPE_CLASS(inst));
-    }
-
-    return inst;
-}
-
-static TemplClassInst *CTemplTool_FindNestedClass(TemplClass *a, TemplClassInst *b, TemplClass *c) {
-    TemplClass *scan;
-
-    while (1) {
-        for (scan = c->templ_parent; scan; scan = scan->templ_parent) {
-            if (scan == a)
-                return CTemplTool_FindNestedClassInstance(c, a, b);
-        }
-
-        a = a->templ_parent;
-        if (!a)
-            break;
-
-        b = b->parent;
-        CError_ASSERT(1377, b);
-    }
-
-    return NULL;
-}
-
-static Type *CTemplTool_FindTemplateInstance(TypeDeduce *deduce, TemplClass *templ) {
-    TemplClass *scantempl;
-    TemplClass *dtempl;
-    TemplClassInst *scaninst;
-    TemplClassInst *dinst;
-
-    dtempl = deduce->tmclass;
-    CError_ASSERT(1393, dtempl);
-
-    dinst = deduce->inst;
-    if (!dinst) {
-        if (!dtempl->templ_parent || !dtempl->inst_parent)
-            return TYPE(templ);
-
-        dtempl = dtempl->templ_parent;
-        dinst = deduce->tmclass->inst_parent;
-    }
-
-    scantempl = dtempl;
-    scaninst = dinst;
-    while (1) {
-        if (scantempl == templ)
-            return TYPE(scaninst);
-
-        if (!scantempl->templ_parent && scantempl->pspec_owner)
-            scantempl = scantempl->pspec_owner;
-
-        scantempl = scantempl->templ_parent;
-        if (!scantempl)
-            break;
-
-        CError_ASSERT(1416, scaninst = scaninst->parent);
-    }
-
-    if (dtempl->flags & TEMPLCLASS_FLAGS_2) {
-        scantempl = TEMPL_CLASS(dtempl->theclass.nspace->theclass);
-        CError_ASSERT(1422, scantempl->theclass.flags & CLASS_IS_TEMPL);
-        scaninst = dinst;
-
-        while (1) {
-            if (scantempl == templ)
-                return TYPE(scaninst);
-
-            scantempl = scantempl->templ_parent;
-            if (!scantempl)
-                break;
-
-            CError_ASSERT(1430, scaninst = scaninst->parent);
-        }
-    }
-
-    if (!templ->templ__params && (scaninst = CTemplTool_FindNestedClass(dtempl, dinst, templ)))
-        return TYPE(scaninst);
-
-    CError_FATAL(1477);
-    return NULL;
-}
-
-static ENode *CTemplTool_DeduceExprCheck(ENode *expr) {
-    if (expr->type != EINTCONST) {
-        CError_Error(CErrorStr348);
-        expr = nullnode();
-    }
-
-    return expr;
-}
-
-static ENodeList *CTemplTool_DeduceExprList(TypeDeduce *deduce, ENodeList *list) {
-    ENodeList *resultList;
-    ENodeList *last;
-
-    resultList = NULL;
-    while (list) {
-        if (resultList) {
-            last->next = lalloc(sizeof(ENodeList));
-            last = last->next;
-        } else {
-            last = lalloc(sizeof(ENodeList));
-            resultList = last;
-        }
-
-        *last = *list;
-        last->node = CTemplTool_DeduceExpr(deduce, last->node);
-
-        list = list->next;
-    }
-
-    return resultList;
-}
-
-ENode *CTemplTool_DeduceExpr(TypeDeduce *deduce, ENode *expr) {
-    TemplArg *arg;
-    TemplClassInst *inst;
-    ENode *newExpr;
-    NameSpaceObjectList *nsObjectList;
-    TStreamElement *saved;
-    NameResult pr;
-    Type *type;
-    UInt32 qual;
-
-    if (!CTemplTool_IsTemplateArgumentDependentExpression(expr)) {
-        newExpr = lalloc(sizeof(ENode));
-        *newExpr = *expr;
-        return newExpr;
-    }
-
-    switch (expr->type) {
-        case ETEMPLDEP:
-            switch (expr->data.templdep.subtype) {
-                case TDE_PARAM:
-                    if (deduce->x15 && expr->data.templdep.u.pid.nindex == deduce->nindex) {
-                        newExpr = lalloc(sizeof(ENode));
-                        *newExpr = *expr;
-                        return newExpr;
-                    }
-
-                    for (arg = deduce->args; arg; arg = arg->next) {
-                        if (
-                            arg->pid.index == expr->data.templdep.u.pid.index &&
-                            arg->pid.nindex == expr->data.templdep.u.pid.nindex
-                            )
-                        {
-                            CError_ASSERT(1562, arg->pid.type == TPT_NONTYPE && arg->data.paramdecl.expr);
-                            newExpr = lalloc(sizeof(ENode));
-                            *newExpr = *arg->data.paramdecl.expr;
-                            return newExpr;
-                        }
-                    }
-
-                    for (inst = deduce->inst; inst; inst = inst->parent) {
-                        for (arg = inst->inst_args; arg; arg = arg->next) {
-                            if (
-                                arg->pid.index == expr->data.templdep.u.pid.index &&
-                                arg->pid.nindex == expr->data.templdep.u.pid.nindex
-                                )
-                            {
-                                CError_ASSERT(1575, arg->pid.type == TPT_NONTYPE && arg->data.paramdecl.expr);
-                                newExpr = lalloc(sizeof(ENode));
-                                *newExpr = *arg->data.paramdecl.expr;
-                                return newExpr;
-                            }
-                        }
-                    }
-
-                    CError_FATAL(1582);
-
-                case TDE_SIZEOF:
-                    qual = 0;
-                    type = CTemplTool_DeduceTypeCopy(deduce, TYPE(expr->data.templdep.u.typeexpr.type), &qual);
-                    CDecl_CompleteType(type);
-
-                    if (CTemplTool_IsTemplateArgumentDependentType(type)) {
-                        newExpr = lalloc(sizeof(ENode));
-                        *newExpr = *expr;
-                        newExpr->data.templdep.u.typeexpr.type = type;
-                        return newExpr;
-                    }
-
-                    return intconstnode(CABI_GetSizeTType(), type->size);
-
-                case TDE_ALIGNOF:
-                    qual = 0;
-                    type = CTemplTool_DeduceTypeCopy(deduce, TYPE(expr->data.templdep.u.typeexpr.type), &qual);
-                    CDecl_CompleteType(type);
-
-                    if (CTemplTool_IsTemplateArgumentDependentType(type)) {
-                        newExpr = lalloc(sizeof(ENode));
-                        *newExpr = *expr;
-                        newExpr->data.templdep.u.typeexpr.type = type;
-                        return newExpr;
-                    }
-
-                    return intconstnode(CABI_GetSizeTType(), CMach_GetTypeAlign(type));
-
-                case TDE_CAST:
-                    qual = expr->data.templdep.u.cast.qual;
-                    type = CTemplTool_DeduceTypeCopy(deduce, expr->data.templdep.u.cast.type, &qual);
-                    return CExpr_DoExplicitConversion(type, qual, CTemplTool_DeduceExprList(deduce, expr->data.templdep.u.cast.args));
-
-                case TDE_QUALNAME:
-                    qual = 0;
-                    type = CTemplTool_DeduceTypeCopy(deduce, TYPE(expr->data.templdep.u.qual.type), &qual);
-
-                    if (IS_TYPE_CLASS(type)) {
-                        CDecl_CompleteType(type);
-                        if (CScope_FindQualifiedClassMember(&pr, TYPE_CLASS(type), expr->data.templdep.u.qual.name))
-                            return pointer_generation(CExpr_MakeNameLookupResultExpr(&pr));
-
-                        CError_Error(CErrorStr150, expr->data.templdep.u.qual.name->name);
-                    } else if (IS_TYPE_TEMPLATE(type) && !deduce->inst) {
-                        newExpr = lalloc(sizeof(ENode));
-                        *newExpr = *expr;
-                        newExpr->data.templdep.u.qual.type = TYPE_TEMPLATE(type);
-                        return newExpr;
-                    } else {
-                        CError_Error(CErrorStr340, expr->data.templdep.u.qual.name->name);
-                    }
-
-                    return nullnode();
-
-                case TDE_OBJ:
-                    type = CTemplTool_FindTemplateInstance(deduce, TEMPL_CLASS(expr->data.templdep.u.obj->nspace->theclass));
-                    CError_ASSERT(1651, type && IS_TYPE_CLASS(type));
-
-                    nsObjectList = CScope_GetLocalObject(TYPE_CLASS(type)->nspace, expr->data.templdep.u.obj->name);
-                    CError_ASSERT(1654, nsObjectList);
-
-                    memclrw(&pr, sizeof(pr));
-                    pr.obj_10 = nsObjectList->object;
-                    return pointer_generation(CExpr_MakeNameLookupResultExpr(&pr));
-
-                case TDE_SOURCEREF:
-                    CError_LockErrorPos(expr->data.templdep.u.sourceref.token, &saved);
-                    newExpr = CTemplTool_DeduceExpr(deduce, expr->data.templdep.u.sourceref.expr);
-                    CError_UnlockErrorPos(&saved);
-                    return newExpr;
-
-                case TDE_ADDRESS_OF:
-                    return getnodeaddress(CTemplTool_DeduceExpr(deduce, expr->data.templdep.u.monadic), 1);
-
-                default:
-                    CError_FATAL(1671);
-            }
-        case EFUNCCALL:
-            newExpr = CExpr_PointerGeneration(CTemplTool_DeduceExpr(deduce, expr->data.funccall.funcref));
-            return CExpr_MakeFunctionCall(newExpr, CTemplTool_DeduceExprList(deduce, expr->data.funccall.args));
-        case ELOGNOT:
-            return CExpr_New_ELOGNOT_Node(CTemplTool_DeduceExpr(deduce, expr->data.monadic));
-        case EMONMIN:
-            return CExpr_New_EMONMIN_Node(CTemplTool_DeduceExpr(deduce, expr->data.monadic));
-        case EBINNOT:
-            return CExpr_New_EBINNOT_Node(CTemplTool_DeduceExpr(deduce, expr->data.monadic));
-        case EMUL:
-        case EDIV:
-        case EMODULO:
-        case EADD:
-        case ESUB:
-        case ESHL:
-        case ESHR:
-        case ELESS:
-        case EGREATER:
-        case ELESSEQU:
-        case EGREATEREQU:
-        case EEQU:
-        case ENOTEQU:
-        case EAND:
-        case EXOR:
-        case EOR:
-        case ELAND:
-        case ELOR:
-        case EROTL:
-        case EROTR:
-            return CExpr_NewDyadicNode(
-                CTemplTool_DeduceExpr(deduce, expr->data.diadic.left),
-                expr->type,
-                CTemplTool_DeduceExpr(deduce, expr->data.diadic.right));
-        case ECOND:
-            return CExpr_New_ECOND_Node(
-                CTemplTool_DeduceExpr(deduce, expr->data.cond.cond),
-                CTemplTool_DeduceExpr(deduce, expr->data.cond.expr1),
-                CTemplTool_DeduceExpr(deduce, expr->data.cond.expr2));
-        default:
-            CError_FATAL(1727);
-        case EINTCONST:
-            newExpr = lalloc(sizeof(ENode));
-            *newExpr = *expr;
-            return newExpr;
-    }
-}
-
-ENode *CTemplTool_DeduceDefaultArg(Object *func, ENode *expr) {
-    TypeDeduce deduce;
-
-    memclrw(&deduce, sizeof(deduce));
-    CError_ASSERT(1747, IS_TYPE_FUNC(func->type));
-
-    if (func->u.func.inst)
-        deduce.args = func->u.func.inst->args;
-
-    if ((TYPE_FUNC(func->type)->flags & FUNC_METHOD) && (TYPE_METHOD(func->type)->theclass->flags & CLASS_IS_TEMPL_INST)) {
-        deduce.inst = TEMPL_CLASS_INST(TYPE_METHOD(func->type)->theclass);
-        deduce.tmclass = TEMPL_CLASS_INST(TYPE_METHOD(func->type)->theclass)->templ;
-    }
-
-    return CTemplTool_DeduceExpr(&deduce, expr);
-}
-
-static TemplClass *CTemplTool_FindNestedTemplateInstance(TypeDeduce *deduce, TemplClass *templ) {
-    TemplClass *dtempl;
-    TemplClassInst *dinst;
-    Type *type;
-
-    if (templ->inst_parent)
-        return templ;
-
-    CError_ASSERT(1776, (dtempl = deduce->tmclass) && (dinst = deduce->inst));
-
-    while (1) {
-        if (
-            templ->templ_parent == dtempl &&
-            (type = CScope_GetLocalTagType(dinst->theclass.nspace, templ->theclass.classname)) &&
-            IS_TEMPL_CLASS(type) &&
-            TEMPL_CLASS(type)->templ_parent == templ->templ_parent
-            )
-            return TEMPL_CLASS(type);
-
-        dtempl = dtempl->templ_parent;
-        if (!dtempl)
-            break;
-
-        dinst = dinst->parent;
-        CError_ASSERT(1790, dinst);
-    }
-
-    return templ;
-}
-
-static Type *CTemplTool_DeduceClassInstanceCopy(TypeDeduce *deduce, TemplClass *templ, TemplArg *args) {
-    TemplArg *arg;
-    TemplArg *deducedArgs;
-    TemplArg *last;
-    TemplParam *param;
-    UInt32 qual;
-    Type *type;
-
-    if (templ->templ_parent)
-        templ = CTemplTool_FindNestedTemplateInstance(deduce, templ);
-
-    arg = args;
-    deducedArgs = NULL;
-    param = templ->templ__params;
-
-    while (arg) {
-        if (deducedArgs) {
-            last->next = galloc(sizeof(TemplArg));
-            last = last->next;
-        } else {
-            last = galloc(sizeof(TemplArg));
-            deducedArgs = last;
-        }
-
-        *last = *arg;
-
-        if (!param || param->pid.type != last->pid.type) {
-            CError_Error(CErrorStr374);
-            return &stvoid;
-        }
-
-        last->pid = param->pid;
-        param = param->next;
-
-        switch (last->pid.type) {
-            case TPT_TYPE:
-                last->data.typeparam.type = CTemplTool_DeduceTypeCopy(deduce, last->data.typeparam.type, &last->data.typeparam.qual);
-                break;
-
-            case TPT_NONTYPE:
-                if (!last->data.paramdecl.expr) {
-                    CError_FATAL(1873);
-                } else if (CTemplTool_IsTemplateArgumentDependentExpression(last->data.paramdecl.expr)) {
-                    last->data.paramdecl.expr = pointer_generation(CTemplTool_DeduceExpr(deduce, last->data.paramdecl.expr));
-                    last->data.paramdecl.expr = CInline_CopyExpression(last->data.paramdecl.expr, CopyMode1);
-                }
-                break;
-
-            case TPT_TEMPLATE:
-                qual = 0;
-                last->data.ttargtype = CTemplTool_DeduceTypeCopy(deduce, last->data.ttargtype, &qual);
-                break;
-
-            default:
-                CError_FATAL(1891);
-        }
-
-        arg = arg->next;
-    }
-
-    for (arg = deducedArgs; arg; arg = arg->next) {
-        switch (arg->pid.type) {
-            case TPT_TYPE:
-                if (CTemplTool_IsTemplateArgumentDependentType(arg->data.typeparam.type))
-                    break;
-                continue;
-
-            case TPT_NONTYPE:
-                if (CTemplTool_IsTemplateArgumentDependentExpression(arg->data.paramdecl.expr))
-                    break;
-
-                switch (arg->data.paramdecl.expr->type) {
-                    case EINTCONST:
-                    case EOBJLIST:
-                    case EMEMBER:
-                        break;
-                    case EOBJREF:
-                        if (CParser_HasInternalLinkage2(arg->data.paramdecl.expr->data.objref))
-                            CError_Error(CErrorStr357);
-                        break;
-                    default:
-                        CError_Error(CErrorStr371);
-                        arg->data.paramdecl.expr = nullnode();
-                        break;
-                }
-                continue;
-
-            case TPT_TEMPLATE:
-                if (!IS_TYPE_CLASS(arg->data.ttargtype) && CTemplTool_IsTemplateArgumentDependentType(arg->data.ttargtype))
-                    break;
-                continue;
-
-            default:
-                CError_FATAL(1937);
-        }
-
-        break;
-    }
-
-    if (arg) {
-        type = CDecl_NewTemplDepType(TEMPLDEP_TEMPLATE);
-        TYPE_TEMPLATE(type)->u.templ.templ = templ;
-        TYPE_TEMPLATE(type)->u.templ.args = deducedArgs;
-        return type;
-    }
-
-    if ((type = CTemplTool_IsDependentTemplate(templ, deducedArgs)))
-        return type;
-
-    return TYPE(CTemplClass_GetInstance(templ, deducedArgs, NULL));
-}
-
-static TemplArg *CTemplTool_FindTemplArg(TemplArg *args, TemplParamID pid) {
-    while (args) {
-        if (args->pid.index == pid.index && args->pid.nindex == pid.nindex) {
-            CError_ASSERT(1984, pid.type == args->pid.type);
-            return args;
-        }
-        args = args->next;
-    }
-
-    return NULL;
-}
-
-static TemplArg *CTemplTool_DeduceTemplArg(TypeDeduce *deduce, TemplParamID pid) {
-    TemplClass *tmclass;
-    TemplClassInst *inst;
-    TemplArg *arg;
-
-    if ((arg = CTemplTool_FindTemplArg(deduce->args, pid)))
-        return arg;
-
-    tmclass = deduce->tmclass;
-    CError_ASSERT(2008, tmclass);
-
-    inst = deduce->inst;
-    if (!inst) {
-        CError_ASSERT(2011, tmclass->templ_parent && tmclass->inst_parent);
-        inst = deduce->tmclass->inst_parent;
-    }
-
-    while (1) {
-        if ((arg = CTemplTool_FindTemplArg(inst->inst_args, pid)))
-            return arg;
-
-        inst = inst->parent;
-        CError_ASSERT(2022, inst);
-    }
-}
-
-static Type *CTemplTool_DeduceArrayCopy(TypeDeduce *deduce, Type *type, ENode *index, UInt32 *resultQual) {
-    if (CTemplTool_IsTemplateArgumentDependentType(type))
-        type = CTemplTool_DeduceTypeCopy(deduce, type, resultQual);
-
-    index = CTemplTool_DeduceExpr(deduce, index);
-
-    if (ENODE_IS(index, EINTCONST)) {
-        if (CInt64_IsNegative(&index->data.intval)) {
-            CError_Error(CErrorStr124);
-            index->data.intval = cint64_one;
-        }
-
-        if (!CDecl_CheckArrayIntegr(type))
-            type = TYPE(&stsignedchar);
-
-        type = CDecl_NewArrayType(type, type->size * CInt64_GetULong(&index->data.intval));
-    } else {
-        if (!deduce->x16)
-            CError_Error(CErrorStr124);
-    }
-
-    return type;
-}
-
-static Type *CTemplTool_DeduceBitfieldCopy(TypeDeduce *deduce, Type *type, ENode *size, UInt32 *resultQual) {
-    TypeBitfield *tbitfield;
-    short sizeval;
-    short maxsize;
-
-    if (CTemplTool_IsTemplateArgumentDependentType(type)) {
-        UInt32 qual = 0;
-        type = CTemplTool_DeduceTypeCopy(deduce, type, &qual);
-    }
-
-    if (!IS_TYPE_INT_OR_ENUM(type)) {
-        CError_Error(CErrorStr138);
-        type = TYPE(&stunsignedint);
-    }
-
-    switch (type->size) {
-        case 1:
-            maxsize = 8;
-            break;
-        case 2:
-            maxsize = 16;
-            break;
-        case 4:
-            maxsize = 32;
-            break;
-        default:
-            CError_Error(CErrorStr138);
-            return type;
-    }
-
-    if (!ENODE_IS(size, EINTCONST)) {
-        size = CTemplTool_DeduceExpr(deduce, size);
-        if (!ENODE_IS(size, EINTCONST)) {
-            CError_Error(CErrorStr124);
-            return type;
-        }
-    }
-
-    sizeval = CInt64_GetULong(&size->data.intval);
-    if (sizeval > maxsize || CInt64_IsNegative(&size->data.intval)) {
-        CError_Error(CErrorStr138);
-        sizeval = 1;
-    }
-
-    tbitfield = galloc(sizeof(TypeBitfield));
-    memclrw(tbitfield, sizeof(TypeBitfield));
-
-    tbitfield->type = TYPEBITFIELD;
-    tbitfield->size = type->size;
-    tbitfield->bitfieldtype = type;
-    tbitfield->bitlength = sizeval;
-
-    return TYPE(tbitfield);
-}
-
-static Type *CTemplTool_DeduceTemplDepType(TypeDeduce *deduce, TypeTemplDep *tdt, UInt32 *resultQual) {
-    Type *type;
-    UInt32 qual;
-    TemplArg *arg;
-
-    qual = 0;
-
-    if (deduce->x14) {
-        type = CTemplTool_GetSelfRefTemplate(TYPE(tdt));
-        if (type && type == TYPE(deduce->tmclass))
-            return type;
-
-        switch (tdt->dtype) {
-            case TEMPLDEP_ARGUMENT:
-                return TYPE(tdt);
-
-            case TEMPLDEP_QUALNAME:
-                type = CTemplTool_DeduceTypeCopy(deduce, TYPE(tdt->u.qual.type), &qual);
-                if (type == TYPE(tdt->u.qual.type))
-                    return TYPE(tdt);
-
-                if (!IS_TYPE_CLASS(type)) {
-                    TypeTemplDep *tdtCopy;
-                    CError_ASSERT(2157, IS_TYPE_TEMPLATE(type));
-                    tdtCopy = galloc(sizeof(TypeTemplDep));
-                    *tdtCopy = *tdt;
-                    tdtCopy->u.qual.type = TYPE_TEMPLATE(type);
-                    return TYPE(tdtCopy);
-                } else if ((type = CScope_GetType(TYPE_CLASS(type)->nspace, tdt->u.qual.name, resultQual))) {
-                    return type;
-                } else {
-                    CError_Error(CErrorStr150, tdt->u.qual.name->name);
-                    return TYPE(tdt);
-                }
-
-            case TEMPLDEP_TEMPLATE:
-                for (arg = tdt->u.templ.args; arg; arg = arg->next) {
-                    if (arg->pid.type == TPT_TYPE)
-                        arg->data.typeparam.type = CTemplTool_DeduceTypeCopy(deduce, arg->data.typeparam.type, &arg->data.typeparam.qual);
-                }
-                return TYPE(tdt);
-
-            case TEMPLDEP_ARRAY:
-                tdt->u.array.type = CTemplTool_DeduceTypeCopy(deduce, tdt->u.array.type, &qual);
-                return TYPE(tdt);
-
-            case TEMPLDEP_QUALTEMPL:
-                tdt->u.qualtempl.type = TYPE_TEMPLATE(CTemplTool_DeduceTemplDepType(deduce, tdt->u.qualtempl.type, &qual));
-                for (arg = tdt->u.qualtempl.args; arg; arg = arg->next) {
-                    if (arg->pid.type == TPT_TYPE)
-                        arg->data.typeparam.type = CTemplTool_DeduceTypeCopy(deduce, arg->data.typeparam.type, &arg->data.typeparam.qual);
-                }
-                return TYPE(tdt);
-
-            case TEMPLDEP_BITFIELD:
-                tdt->u.bitfield.type = CTemplTool_DeduceTypeCopy(deduce, tdt->u.bitfield.type, &qual);
-                return TYPE(tdt);
-        }
-    } else {
-        switch (tdt->dtype) {
-            case TEMPLDEP_ARGUMENT:
-                if (deduce->x15 && tdt->u.pid.nindex == deduce->nindex)
-                    return TYPE(tdt);
-
-                arg = CTemplTool_DeduceTemplArg(deduce, tdt->u.pid);
-                if (arg->pid.type == TPT_TEMPLATE) {
-                    CError_ASSERT(2222, IS_TEMPL_CLASS(arg->data.typeparam.type));
-                    *resultQual = arg->data.typeparam.qual;
-                    return arg->data.typeparam.type;
-                }
-
-                CError_ASSERT(2226, arg->pid.type == TPT_TYPE);
-                *resultQual = arg->data.typeparam.qual;
-                return arg->data.typeparam.type;
-
-            case TEMPLDEP_QUALNAME:
-                type = CTemplTool_DeduceTypeCopy(deduce, TYPE(tdt->u.qual.type), &qual);
-                if (IS_TYPE_CLASS(type)) {
-                    CDecl_CompleteType(type);
-                    if ((type = CScope_GetType(TYPE_CLASS(type)->nspace, tdt->u.qual.name, resultQual))) {
-                        return type;
-                    } else {
-                        CError_Error(CErrorStr150, tdt->u.qual.name->name);
-                    }
-                } else {
-                    if ((deduce->x15 || !deduce->inst) && IS_TYPE_TEMPLATE(type)) {
-                        TypeTemplDep *tdtCopy = galloc(sizeof(TypeTemplDep));
-                        *tdtCopy = *tdt;
-                        tdtCopy->u.qual.type = TYPE_TEMPLATE(type);
-                        return TYPE(tdtCopy);
-                    } else {
-                        CError_Error(CErrorStr340, tdt->u.qual.name->name);
-                    }
-                }
-                return TYPE(&stsignedint);
-
-            case TEMPLDEP_TEMPLATE:
-                return CTemplTool_DeduceClassInstanceCopy(deduce, tdt->u.templ.templ, tdt->u.templ.args);
-
-            case TEMPLDEP_ARRAY:
-                return CTemplTool_DeduceArrayCopy(deduce, tdt->u.array.type, tdt->u.array.index, resultQual);
-
-            case TEMPLDEP_QUALTEMPL:
-                type = CTemplTool_DeduceTypeCopy(deduce, TYPE(tdt->u.qualtempl.type), &qual);
-                if (!IS_TEMPL_CLASS(type)) {
-                    CError_Error(CErrorStr121);
-                    return TYPE(&stsignedint);
-                }
-                return CTemplTool_DeduceClassInstanceCopy(deduce, TEMPL_CLASS(type), tdt->u.qualtempl.args);
-
-            case TEMPLDEP_BITFIELD:
-                return CTemplTool_DeduceBitfieldCopy(deduce, tdt->u.bitfield.type, tdt->u.bitfield.size, resultQual);
-        }
-    }
-
-    CError_FATAL(2275);
-    return NULL;
-}
-
-static Type *CTemplTool_DeduceTypeQualCopy(TypeDeduce *deduce, Type *type, UInt32 *resultQual) {
-    Type *innerType;
-    UInt32 qual;
-    UInt32 innerQual;
-    TypePointer *newPtr;
-
-    qual = *resultQual;
-
-    if (IS_TYPE_POINTER_ONLY(type) && IS_TYPE_TEMPLATE(TPTR_TARGET(type))) {
-        innerQual = 0;
-        innerType = CTemplTool_DeduceTemplDepType(deduce, TYPE_TEMPLATE(TPTR_TARGET(type)), &innerQual);
-
-        newPtr = galloc(sizeof(TypePointer));
-        *newPtr = *TYPE_POINTER(type);
-
-        if (IS_TYPE_POINTER_ONLY(innerType)) {
-            newPtr->target = galloc(sizeof(TypePointer));
-            *TYPE_POINTER(newPtr->target) = *TYPE_POINTER(innerType);
-            *resultQual = innerQual & (Q_CONST | Q_VOLATILE);
-            TPTR_QUAL(newPtr->target) |= qual & (Q_CONST | Q_VOLATILE);
-        } else if (IS_TYPE_MEMBERPOINTER(innerType)) {
-            newPtr->target = galloc(sizeof(TypeMemberPointer));
-            *TYPE_MEMBER_POINTER(newPtr->target) = *TYPE_MEMBER_POINTER(innerType);
-            *resultQual = innerQual & (Q_CONST | Q_VOLATILE);
-            TYPE_MEMBER_POINTER(newPtr->target)->qual |= qual & (Q_CONST | Q_VOLATILE);
-        } else {
-            newPtr->target = innerType;
-            *resultQual = (qual | innerQual) & (Q_CONST | Q_VOLATILE);
-        }
-
-        return TYPE(newPtr);
-    }
-
-    return CTemplTool_DeduceTypeCopy(deduce, type, resultQual);
-}
-
-FuncArg *CTemplTool_DeduceArgCopy(TypeDeduce *deduce, FuncArg *args) {
-    FuncArg *resultArgs;
-    FuncArg *last;
-
-    if (args == &oldstyle || args == &elipsis)
-        return args;
-
-    resultArgs = NULL;
-
-    while (args) {
-        if (args == &elipsis) {
-            last->next = args;
-            break;
-        }
-
-        if (resultArgs) {
-            last->next = galloc(sizeof(FuncArg));
-            last = last->next;
-        } else {
-            last = galloc(sizeof(FuncArg));
-            resultArgs = last;
-        }
-
-        *last = *args;
-        last->type = CTemplTool_DeduceTypeQualCopy(deduce, last->type, &last->qual);
-        CanCreateObject(last->type);
-
-        args = args->next;
-    }
-
-    return resultArgs;
-}
-
-static ExceptSpecList *CTemplTool_DeduceExSpecCopy(TypeDeduce *deduce, ExceptSpecList *exspec) {
-    ExceptSpecList *copy;
-
-    copy = galloc(sizeof(ExceptSpecList));
-    *copy = *exspec;
-
-    if (copy->type && CTemplTool_IsTemplateArgumentDependentType(copy->type))
-        copy->type = CTemplTool_DeduceTypeCopy(deduce, copy->type, &copy->qual);
-
-    if (copy->next)
-        copy->next = CTemplTool_DeduceExSpecCopy(deduce, copy->next);
-
-    return copy;
-}
-
-Type *CTemplTool_DeduceTypeCopy(TypeDeduce *deduce, Type *type, UInt32 *resultQual) {
-    TemplClassInst *inst;
-    Type *deduced;
-    UInt32 qual2;
-    UInt32 qual;
-
-    switch (type->type) {
-        case TYPETEMPLATE:
-            qual = 0;
-            deduced = CTemplTool_DeduceTemplDepType(deduce, TYPE_TEMPLATE(type), &qual);
-            if (*resultQual & (Q_CONST | Q_VOLATILE)) {
-                if (IS_TYPE_POINTER_ONLY(deduced)) {
-                    TypePointer *newPtr = galloc(sizeof(TypePointer));
-                    *newPtr = *TYPE_POINTER(deduced);
-                    newPtr->qual |= *resultQual & (Q_CONST | Q_VOLATILE);
-                    *resultQual &= ~(Q_CONST | Q_VOLATILE);
-                    deduced = TYPE(newPtr);
-                } else if (IS_TYPE_MEMBERPOINTER(deduced)) {
-                    TypeMemberPointer *newPtr = galloc(sizeof(TypeMemberPointer));
-                    *newPtr = *TYPE_MEMBER_POINTER(deduced);
-                    newPtr->qual |= *resultQual & (Q_CONST | Q_VOLATILE);
-                    *resultQual &= ~(Q_CONST | Q_VOLATILE);
-                    deduced = TYPE(newPtr);
-                }
-            }
-            *resultQual |= qual;
-            return deduced;
-
-        case TYPEVOID:
-        case TYPEINT:
-        case TYPEFLOAT:
-        case TYPESTRUCT:
-            return type;
-
-        case TYPEENUM:
-            if (
-                TYPE_ENUM(type)->nspace->theclass &&
-                (TYPE_ENUM(type)->nspace->theclass->flags & CLASS_IS_TEMPL) &&
-                !deduce->x14
-                )
-            {
-                CError_ASSERT(2471, TYPE_ENUM(type)->enumname);
-                inst = TEMPL_CLASS_INST(CTemplTool_FindTemplateInstance(deduce, TEMPL_CLASS(TYPE_ENUM(type)->nspace->theclass)));
-                CError_ASSERT(2473, inst && inst->theclass.type == TYPECLASS);
-
-                CDecl_CompleteType(TYPE(inst));
-                type = CScope_GetLocalTagType(inst->theclass.nspace, TYPE_ENUM(type)->enumname);
-                CError_ASSERT(2477, type);
-                return type;
-            }
-            return type;
-
-        case TYPECLASS:
-            if (!deduce->x14) {
-                if (TYPE_CLASS(type)->flags & CLASS_IS_TEMPL)
-                    return CTemplTool_FindTemplateInstance(deduce, TEMPL_CLASS(type));
-
-                if (TYPE_CLASS(type)->nspace->theclass && (TYPE_CLASS(type)->nspace->theclass->flags & CLASS_IS_TEMPL)) {
-                    CError_ASSERT(2492, deduce->inst);
-                    CError_ASSERT(2493, TYPE_CLASS(type)->classname);
-
-                    type = CScope_GetLocalTagType(deduce->inst->theclass.nspace, TYPE_CLASS(type)->classname);
-                    CError_ASSERT(2496, type);
-                    return type;
-                }
-            }
-
-            return type;
-
-        case TYPEARRAY: {
-            SInt32 elements;
-
-            elements = TPTR_TARGET(type)->size;
-            if (elements > 0)
-                elements = type->size / elements;
-
-            deduced = galloc(sizeof(TypePointer));
-            *TYPE_POINTER(deduced) = *TYPE_POINTER(type);
-            TPTR_TARGET(deduced) = CTemplTool_DeduceTypeCopy(deduce, TPTR_TARGET(type), resultQual);
-
-            do {
-                type = TPTR_TARGET(type);
-            } while (IS_TYPE_ARRAY(type));
-
-            if (IS_TYPE_TEMPLATE(type)) {
-                CDecl_CompleteType(TPTR_TARGET(deduced));
-                deduced->size = TPTR_TARGET(deduced)->size * elements;
-            }
-
-            return deduced;
-        }
-
-        case TYPEPOINTER:
-            deduced = galloc(sizeof(TypePointer));
-            *TYPE_POINTER(deduced) = *TYPE_POINTER(type);
-            TPTR_TARGET(deduced) = CTemplTool_DeduceTypeCopy(deduce, TPTR_TARGET(type), resultQual);
-            return deduced;
-
-        case TYPEBITFIELD:
-            deduced = galloc(sizeof(TypeBitfield));
-            *TYPE_BITFIELD(deduced) = *TYPE_BITFIELD(type);
-            TYPE_BITFIELD(deduced)->bitfieldtype = CTemplTool_DeduceTypeCopy(deduce, TYPE_BITFIELD(type)->bitfieldtype, resultQual);
-            return deduced;
-
-        case TYPEMEMBERPOINTER:
-            deduced = galloc(sizeof(TypeMemberPointer));
-            *TYPE_MEMBER_POINTER(deduced) = *TYPE_MEMBER_POINTER(type);
-            TYPE_MEMBER_POINTER(deduced)->ty1 = CTemplTool_DeduceTypeCopy(deduce, TYPE_MEMBER_POINTER(type)->ty1, resultQual);
-            qual2 = 0;
-            TYPE_MEMBER_POINTER(deduced)->ty2 = CTemplTool_DeduceTypeCopy(deduce, TYPE_MEMBER_POINTER(type)->ty2, &qual2);
-
-            if (
-                !IS_TYPE_CLASS(TYPE_MEMBER_POINTER(deduced)->ty2) &&
-                !deduce->x14 &&
-                !deduce->x15 &&
-                !deduce->x16
-                )
-            {
-                CError_Error(CErrorStr232);
-                return TYPE_MEMBER_POINTER(deduced)->ty1;
-            }
-            return deduced;
-
-        case TYPEFUNC:
-            if (TYPE_FUNC(type)->flags & FUNC_METHOD) {
-                qual2 = 0;
-                deduced = galloc(sizeof(TypeMemberFunc));
-                *TYPE_METHOD(deduced) = *TYPE_METHOD(type);
-                TYPE_METHOD(deduced)->funcid = 0;
-                TYPE_METHOD(deduced)->theclass = TYPE_CLASS(CTemplTool_DeduceTypeQualCopy(deduce, TYPE(TYPE_METHOD(type)->theclass), &qual2));
-                CError_ASSERT(2556, IS_TYPE_CLASS(TYPE_METHOD(deduced)->theclass));
-            } else {
-                deduced = galloc(sizeof(TypeFunc));
-                *TYPE_FUNC(deduced) = *TYPE_FUNC(type);
-            }
-
-            TYPE_FUNC(deduced)->flags &= ~FUNC_IS_TEMPL;
-
-            qual2 = TYPE_FUNC(type)->qual;
-            TYPE_FUNC(deduced)->functype = CTemplTool_DeduceTypeQualCopy(deduce, TYPE_FUNC(type)->functype, &qual2);
-            TYPE_FUNC(deduced)->qual = qual2;
-
-            TYPE_FUNC(deduced)->args = CTemplTool_DeduceArgCopy(deduce, TYPE_FUNC(type)->args);
-            if (TYPE_FUNC(type)->exspecs)
-                TYPE_FUNC(deduced)->exspecs = CTemplTool_DeduceExSpecCopy(deduce, TYPE_FUNC(type)->exspecs);
-
-            CDecl_SetResultReg(TYPE_FUNC(deduced));
-            return deduced;
-
-        case TYPETEMPLDEPEXPR:
-            CError_Error(CErrorStr190);
-            return &stvoid;
-
-        default:
-            CError_FATAL(2580);
-            return NULL;
-    }
-}
-
-Type *CTemplTool_ResolveMemberSelfRefs(TemplClass *templ, Type *type, UInt32 *resultQual) {
-    TypeDeduce deduce;
-
-    memclrw(&deduce, sizeof(deduce));
-    deduce.tmclass = templ;
-    deduce.x14 = 1;
-
-    if (IS_TYPE_FUNC(type)) {
-        TYPE_FUNC(type)->functype = CTemplTool_DeduceTypeCopy(&deduce, TYPE_FUNC(type)->functype, &TYPE_FUNC(type)->qual);
-        TYPE_FUNC(type)->args = CTemplTool_DeduceArgCopy(&deduce, TYPE_FUNC(type)->args);
-        CDecl_SetResultReg(TYPE_FUNC(type));
-    } else {
-        type = CTemplTool_DeduceTypeCopy(&deduce, type, resultQual);
-    }
-
-    return type;
-}
-
-Boolean CTemplTool_IsSameTemplateType(Type *a, Type *b) {
-    return CTemplTool_GetSelfRefTemplate(b) == a;
-}