1 files changed, 0 insertions, 128 deletions
diff --git a/source/slang/slang-ir-legalize-types.cpp b/source/slang/slang-ir-legalize-types.cpp
index 5168f0466..021566e12 100644
--- a/source/slang/slang-ir-legalize-types.cpp
+++ b/source/slang/slang-ir-legalize-types.cpp
@@ -1950,133 +1950,6 @@ static LegalVal legalizeDefaultConstruct(IRTypeLegalizationContext* context, Leg
     }
 }
 
-// If a legalized `val` has a different flavor than `type`, try to coerce it to `type`.
-//
-static LegalVal coerceToLegalType(IRTypeLegalizationContext* context, LegalType type, LegalVal val)
-{
-    switch (type.flavor)
-    {
-    case LegalType::Flavor::none:
-        return LegalVal();
-    case LegalType::Flavor::simple:
-        {
-            if (val.flavor != LegalVal::Flavor::simple)
-                return val;
-            auto simpleVal = val.getSimple();
-            if (simpleVal->getDataType() == type.getSimple())
-                return val;
-
-            auto resultType = type.getSimple();
-            auto structType = as<IRStructType>(resultType);
-            if (!structType)
-            {
-                auto resultValueType = tryGetPointedToType(context->builder, resultType);
-                if (!resultValueType)
-                    return val;
-                auto valValueType = tryGetPointedToType(context->builder, simpleVal->getDataType());
-                if (!valValueType)
-                    return val;
-                if (resultValueType == valValueType)
-                    return val;
-                auto loadedVal = context->builder->emitLoad(val.getSimple());
-                auto innerLegalVal = coerceToLegalType(
-                    context,
-                    LegalType::simple(resultValueType),
-                    LegalVal::simple(loadedVal));
-                return LegalVal::implicitDeref(innerLegalVal);
-            }
-            ShortList<IRInst*> fields;
-            for (auto field : structType->getFields())
-            {
-                if (as<IRVoidType>(field->getFieldType()))
-                    continue;
-                auto fieldVal = coerceToLegalType(
-                    context,
-                    LegalType::simple(field->getFieldType()),
-                    LegalVal::simple(
-                        context->builder->emitFieldExtract(simpleVal, field->getKey())));
-                fields.add(fieldVal.getSimple());
-            }
-            return LegalVal::simple(context->builder->emitMakeStruct(
-                structType,
-                (UInt)fields.getCount(),
-                fields.getArrayView().getBuffer()));
-        }
-    case LegalType::Flavor::implicitDeref:
-        {
-            auto innerVal = val;
-            if (innerVal.flavor == LegalVal::Flavor::implicitDeref)
-                innerVal = innerVal.getImplicitDeref();
-            else if (innerVal.flavor == LegalVal::Flavor::simple)
-                innerVal = LegalVal::simple(context->builder->emitLoad(innerVal.getSimple()));
-            innerVal = coerceToLegalType(context, type.getImplicitDeref()->valueType, innerVal);
-            return LegalVal::implicitDeref(innerVal);
-        }
-    case LegalType::Flavor::pair:
-        {
-            if (val.flavor == LegalVal::Flavor::pair)
-                return val;
-            else if (val.flavor == LegalVal::Flavor::simple)
-            {
-                auto pairType = type.getPair();
-                auto pairInfo = pairType->pairInfo;
-                LegalVal ordinaryVal = coerceToLegalType(context, pairType->ordinaryType, val);
-                LegalVal specialVal = coerceToLegalType(context, pairType->specialType, val);
-                return LegalVal::pair(ordinaryVal, specialVal, pairInfo);
-            }
-            else if (val.flavor == LegalVal::Flavor::implicitDeref)
-            {
-                LegalVal innerVal = coerceToLegalType(context, type, val.getImplicitDeref());
-                return LegalVal::implicitDeref(innerVal);
-            }
-            else
-            {
-                SLANG_UNEXPECTED("unhandled legal type coercion");
-                UNREACHABLE_RETURN(LegalVal());
-            }
-        }
-    case LegalType::Flavor::tuple:
-        {
-            if (val.flavor == LegalVal::Flavor::tuple)
-                return val;
-            else if (val.flavor == LegalVal::Flavor::simple)
-            {
-                auto tupleType = type.getTuple();
-                RefPtr<TuplePseudoVal> tupleVal = new TuplePseudoVal();
-                auto simpleVal = val.getSimple();
-                for (auto elem : tupleType->elements)
-                {
-                    IRInst* elementVal = nullptr;
-                    if (as<IRPtrTypeBase>(simpleVal->getDataType()) ||
-                        as<IRPointerLikeType>(simpleVal->getDataType()))
-                        elementVal = context->builder->emitFieldAddress(simpleVal, elem.key);
-                    else
-                        elementVal = context->builder->emitFieldExtract(simpleVal, elem.key);
-                    LegalVal legalElementVal =
-                        coerceToLegalType(context, elem.type, LegalVal::simple(elementVal));
-                    TuplePseudoVal::Element tupleElem;
-                    tupleElem.key = elem.key;
-                    tupleElem.val = legalElementVal;
-                    tupleVal->elements.add(tupleElem);
-                }
-                return LegalVal::tuple(tupleVal);
-            }
-            else if (val.flavor == LegalVal::Flavor::implicitDeref)
-            {
-                LegalVal innerVal = coerceToLegalType(context, type, val.getImplicitDeref());
-                return LegalVal::implicitDeref(innerVal);
-            }
-            else
-            {
-                SLANG_UNEXPECTED("unhandled legal type coercion");
-                UNREACHABLE_RETURN(LegalVal());
-            }
-        }
-    default:
-        return val;
-    }
-}
-
 static LegalVal legalizeUndefined(IRTypeLegalizationContext* context, IRInst* inst)
 {
     IRType* opaqueType = nullptr;
@@ -2188,7 +2061,6 @@ static LegalVal legalizeInst(
         SLANG_UNEXPECTED("non-simple operand(s)!");
         break;
     }
-    result = coerceToLegalType(context, type, result);
     return result;
 }