Delete obsolete CORINFO_TYPE_... entries (#128243)

Delete `CORINFO_TYPE_STRING`, legacy `CORINFO_TYPE_REFANY`, and
`CORINFO_TYPE_VAR` enum slots from the JIT/EE

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: jkotas <6668460+jkotas@users.noreply.github.com>
Co-authored-by: Jan Kotas <jkotas@microsoft.com>
Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

Author: 3 people

src/coreclr/inc/corinfo.h

@@ -612,20 +612,11 @@ enum CorInfoType
     CORINFO_TYPE_NATIVEUINT      = 0xd,
     CORINFO_TYPE_FLOAT           = 0xe,
     CORINFO_TYPE_DOUBLE          = 0xf,
-    CORINFO_TYPE_STRING          = 0x10,         // Not used, should remove
-    CORINFO_TYPE_PTR             = 0x11,
-    CORINFO_TYPE_BYREF           = 0x12,
-    CORINFO_TYPE_VALUECLASS      = 0x13,
-    CORINFO_TYPE_CLASS           = 0x14,
-    CORINFO_TYPE_REFANY          = 0x15,
-
-    // CORINFO_TYPE_VAR is for a generic type variable.
-    // Generic type variables only appear when the JIT is doing
-    // verification (not NOT compilation) of generic code
-    // for the EE, in which case we're running
-    // the JIT in "import only" mode.
-
-    CORINFO_TYPE_VAR             = 0x16,
+    CORINFO_TYPE_PTR             = 0x10,
+    CORINFO_TYPE_BYREF           = 0x11,
+    CORINFO_TYPE_VALUECLASS      = 0x12,
+    CORINFO_TYPE_CLASS           = 0x13,
+
     CORINFO_TYPE_COUNT,                         // number of jit types
 };
 

src/coreclr/inc/jiteeversionguid.h

@@ -37,11 +37,11 @@
 
 #include <minipal/guid.h>
 
-constexpr GUID JITEEVersionIdentifier = { /* ff61c3a1-5780-4001-84cf-c3a060138d2f */
-    0xff61c3a1,
-    0x5780,
-    0x4001,
-    {0x84, 0xcf, 0xc3, 0xa0, 0x60, 0x13, 0x8d, 0x2f}
+constexpr GUID JITEEVersionIdentifier = { /* 4b5934bd-e9a2-4376-bfbf-d4739f11bdb0 */
+    0x4b5934bd,
+    0xe9a2,
+    0x4376,
+    {0xbf, 0xbf, 0xd4, 0x73, 0x9f, 0x11, 0xbd, 0xb0}
   };
 
 #endif // JIT_EE_VERSIONING_GUID_H

src/coreclr/interpreter/compiler.cpp

@@ -2348,15 +2348,13 @@ static InterpType GetInterpType(CorInfoType corInfoType)
             return InterpTypeR4;
         case CORINFO_TYPE_DOUBLE:
             return InterpTypeR8;
-        case CORINFO_TYPE_STRING:
         case CORINFO_TYPE_CLASS:
             return InterpTypeO;
         case CORINFO_TYPE_PTR:
             return InterpTypeI;
         case CORINFO_TYPE_BYREF:
             return InterpTypeByRef;
         case CORINFO_TYPE_VALUECLASS:
-        case CORINFO_TYPE_REFANY:
             return InterpTypeVT;
         case CORINFO_TYPE_VOID:
             return InterpTypeVoid;
@@ -6151,7 +6149,6 @@ void InterpCompiler::EmitSuspend(const CORINFO_CALL_INFO &callInfo, Continuation
             suspendData->asyncMethodReturnType = m_methodInfo->args.retTypeClass;
             suspendData->asyncMethodReturnTypePrimitiveSize = 0;
             break;
-        case CORINFO_TYPE_STRING:
         case CORINFO_TYPE_CLASS:
             suspendData->asyncMethodReturnType = m_compHnd->getBuiltinClass(CLASSID_SYSTEM_OBJECT);
             suspendData->asyncMethodReturnTypePrimitiveSize = 0;
@@ -6199,13 +6196,7 @@ void InterpCompiler::EmitSuspend(const CORINFO_CALL_INFO &callInfo, Continuation
         case CORINFO_TYPE_PTR:
             suspendData->asyncMethodReturnTypePrimitiveSize = sizeof(void*);
             break;
-        case CORINFO_TYPE_REFANY:
-            BADCODE("TypedReference return types not supported for async methods");
-            break;
 
-        case CORINFO_TYPE_VAR:
-            BADCODE("VAR return types should have been translated before we get here on async methods");
-            break;
         default:
             // Other types are not supported
             BADCODE("Unsupported async method return type");

src/coreclr/interpreter/naming.cpp

@@ -48,13 +48,10 @@ void AppendCorInfoType(TArray<char, MallocAllocator>* printer, CorInfoType corIn
         "nuint",
         "float",
         "double",
-        "string",
         "ptr",
         "byref",
         "struct",
-        "class",
-        "typedbyref",
-        "var"
+        "class"
     };
 
     const char *corInfoTypeName = "CORINFO_TYPE_INVALID";
@@ -209,11 +206,8 @@ void AppendMethodName(COMP_HANDLE comp,
             CorInfoType type = strip(withMod);
             switch (type)
             {
-                case CORINFO_TYPE_STRING:
                 case CORINFO_TYPE_CLASS:
-                case CORINFO_TYPE_VAR:
                 case CORINFO_TYPE_VALUECLASS:
-                case CORINFO_TYPE_REFANY:
                 {
                     CORINFO_CLASS_HANDLE clsHnd = comp->getArgClass(sig, argLst);
                     // For some SIMD struct types we can get a nullptr back from eeGetArgClass on Linux/X64
@@ -243,11 +237,8 @@ void AppendMethodName(COMP_HANDLE comp,
                 printer->Add(':');
                 switch (retType)
                 {
-                    case CORINFO_TYPE_STRING:
                     case CORINFO_TYPE_CLASS:
-                    case CORINFO_TYPE_VAR:
                     case CORINFO_TYPE_VALUECLASS:
-                    case CORINFO_TYPE_REFANY:
                     {
                         CORINFO_CLASS_HANDLE clsHnd = sig->retTypeClass;
                         if (clsHnd != NO_CLASS_HANDLE)

src/coreclr/jit/compiler.cpp

@@ -1725,10 +1725,6 @@ unsigned Compiler::compGetTypeSize(CorInfoType cit, CORINFO_CLASS_HANDLE clsHnd)
     {
         sigSize = info.compCompHnd->getClassSize(clsHnd);
     }
-    else if (cit == CORINFO_TYPE_REFANY)
-    {
-        sigSize = 2 * TARGET_POINTER_SIZE;
-    }
     return sigSize;
 }
 

src/coreclr/jit/ee_il_dll.cpp

@@ -401,9 +401,6 @@ unsigned Compiler::eeGetArgSize(CorInfoType corInfoType, CORINFO_CLASS_HANDLE ty
         isHfa               = (hfaType != TYP_UNDEF);
         unsigned structSize = info.compCompHnd->getClassSize(typeHnd);
 
-        // make certain the EE passes us back the right thing for refanys
-        assert(corInfoType != CORINFO_TYPE_REFANY || structSize == 2 * TARGET_POINTER_SIZE);
-
         // For each target that supports passing struct args in multiple registers
         // apply the target specific rules for them here:
 

src/coreclr/jit/ee_il_dll.hpp

@@ -213,25 +213,10 @@ inline var_types JITtype2varType(CorInfoType type)
         TYP_I_IMPL, // CORINFO_TYPE_NATIVEUINT      = 0xd,
         TYP_FLOAT,  // CORINFO_TYPE_FLOAT           = 0xe,
         TYP_DOUBLE, // CORINFO_TYPE_DOUBLE          = 0xf,
-        TYP_REF,    // CORINFO_TYPE_STRING          = 0x10,         // Not used, should remove
-        TYP_I_IMPL, // CORINFO_TYPE_PTR             = 0x11,
-        TYP_BYREF,  // CORINFO_TYPE_BYREF           = 0x12,
-        TYP_STRUCT, // CORINFO_TYPE_VALUECLASS      = 0x13,
-        TYP_REF,    // CORINFO_TYPE_CLASS           = 0x14,
-        TYP_STRUCT, // CORINFO_TYPE_REFANY          = 0x15,
-
-        // Generic type variables only appear when we're doing
-        // verification of generic code, in which case we're running
-        // in "import only" mode.  Annoyingly the "import only"
-        // mode of the JIT actually does a fair bit of compilation,
-        // so we have to trick the compiler into thinking it's compiling
-        // a real instantiation.  We do that by just pretending we're
-        // compiling the "object" instantiation of the code, i.e. by
-        // turing all generic type variables refs, except for a few
-        // choice places to do with verification, where we use
-        // verification types and CLASS_HANDLEs to track the difference.
-
-        TYP_REF, // CORINFO_TYPE_VAR             = 0x16,
+        TYP_I_IMPL, // CORINFO_TYPE_PTR             = 0x10,
+        TYP_BYREF,  // CORINFO_TYPE_BYREF           = 0x11,
+        TYP_STRUCT, // CORINFO_TYPE_VALUECLASS      = 0x12,
+        TYP_REF,    // CORINFO_TYPE_CLASS           = 0x13,
     };
 
     // spot check to make certain enumerations have not changed
@@ -244,7 +229,6 @@ inline var_types JITtype2varType(CorInfoType type)
     assert(varTypeMap[CORINFO_TYPE_DOUBLE] == TYP_DOUBLE);
     assert(varTypeMap[CORINFO_TYPE_VOID] == TYP_VOID);
     assert(varTypeMap[CORINFO_TYPE_VALUECLASS] == TYP_STRUCT);
-    assert(varTypeMap[CORINFO_TYPE_REFANY] == TYP_STRUCT);
 
     assert(type < CORINFO_TYPE_COUNT);
     assert(varTypeMap[type] != TYP_UNDEF);
@@ -274,25 +258,11 @@ inline var_types JitType2PreciseVarType(CorInfoType type)
         TYP_U_IMPL, // CORINFO_TYPE_NATIVEUINT      = 0xd,
         TYP_FLOAT,  // CORINFO_TYPE_FLOAT           = 0xe,
         TYP_DOUBLE, // CORINFO_TYPE_DOUBLE          = 0xf,
-        TYP_REF,    // CORINFO_TYPE_STRING          = 0x10,         // Not used, should remove
-        TYP_U_IMPL, // CORINFO_TYPE_PTR             = 0x11,
-        TYP_BYREF,  // CORINFO_TYPE_BYREF           = 0x12,
-        TYP_STRUCT, // CORINFO_TYPE_VALUECLASS      = 0x13,
-        TYP_REF,    // CORINFO_TYPE_CLASS           = 0x14,
-        TYP_STRUCT, // CORINFO_TYPE_REFANY          = 0x15,
-
-        // Generic type variables only appear when we're doing
-        // verification of generic code, in which case we're running
-        // in "import only" mode.  Annoyingly the "import only"
-        // mode of the JIT actually does a fair bit of compilation,
-        // so we have to trick the compiler into thinking it's compiling
-        // a real instantiation.  We do that by just pretending we're
-        // compiling the "object" instantiation of the code, i.e. by
-        // turing all generic type variables refs, except for a few
-        // choice places to do with verification, where we use
-        // verification types and CLASS_HANDLEs to track the difference.
-
-        TYP_REF, // CORINFO_TYPE_VAR             = 0x16,
+        TYP_U_IMPL, // CORINFO_TYPE_PTR             = 0x10,
+        TYP_BYREF,  // CORINFO_TYPE_BYREF           = 0x11,
+        TYP_STRUCT, // CORINFO_TYPE_VALUECLASS      = 0x12,
+        TYP_REF,    // CORINFO_TYPE_CLASS           = 0x13,
+
     };
 
     // spot check to make certain enumerations have not changed
@@ -305,7 +275,6 @@ inline var_types JitType2PreciseVarType(CorInfoType type)
     assert(preciseVarTypeMap[CORINFO_TYPE_DOUBLE] == TYP_DOUBLE);
     assert(preciseVarTypeMap[CORINFO_TYPE_VOID] == TYP_VOID);
     assert(preciseVarTypeMap[CORINFO_TYPE_VALUECLASS] == TYP_STRUCT);
-    assert(preciseVarTypeMap[CORINFO_TYPE_REFANY] == TYP_STRUCT);
 
     assert(type < CORINFO_TYPE_COUNT);
     assert(preciseVarTypeMap[type] != TYP_UNDEF);

src/coreclr/jit/eeinterface.cpp

@@ -92,11 +92,10 @@ void Compiler::eePrintCorInfoType(StringPrinter* printer, CorInfoType corInfoTyp
 {
     static const char* preciseVarTypeMap[CORINFO_TYPE_COUNT] = {// see the definition of enum CorInfoType in file
                                                                 // inc/corinfo.h
-                                                                "<UNDEF>", "void",       "bool",   "char",  "sbyte",
-                                                                "byte",    "short",      "ushort", "int",   "uint",
-                                                                "long",    "ulong",      "nint",   "nuint", "float",
-                                                                "double",  "string",     "ptr",    "byref", "struct",
-                                                                "class",   "typedbyref", "var"};
+                                                                "<UNDEF>", "void",  "bool",   "char",   "sbyte",
+                                                                "byte",    "short", "ushort", "int",    "uint",
+                                                                "long",    "ulong", "nint",   "nuint",  "float",
+                                                                "double",  "ptr",   "byref",  "struct", "class"};
 
     const char* corInfoTypeName = "CORINFO_TYPE_INVALID";
     if (corInfoType >= 0 && corInfoType < CORINFO_TYPE_COUNT)

src/coreclr/jit/importer.cpp

@@ -2631,7 +2631,7 @@ bool Compiler::checkTailCallConstraint(OPCODE                  opcode,
         // Disallow the tailcall for this kind.
         CORINFO_CLASS_HANDLE classHandle;
         CorInfoType          ciType = strip(info.compCompHnd->getArgType(&sig, args, &classHandle));
-        if ((ciType == CORINFO_TYPE_PTR) || (ciType == CORINFO_TYPE_BYREF) || (ciType == CORINFO_TYPE_REFANY))
+        if ((ciType == CORINFO_TYPE_PTR) || (ciType == CORINFO_TYPE_BYREF))
         {
             return false;
         }

src/coreclr/jit/importercalls.cpp

@@ -636,8 +636,7 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
             if (sig->retTypeSigClass != actualMethodRetTypeSigClass)
             {
                 if (actualMethodRetTypeSigClass != nullptr && sig->retType != CORINFO_TYPE_CLASS &&
-                    sig->retType != CORINFO_TYPE_BYREF && sig->retType != CORINFO_TYPE_PTR &&
-                    sig->retType != CORINFO_TYPE_VAR)
+                    sig->retType != CORINFO_TYPE_BYREF && sig->retType != CORINFO_TYPE_PTR)
                 {
                     // Make sure that all valuetypes (including enums) that we push are loaded.
                     // This is to guarantee that if a GC is triggered from the prestub of this methods,
@@ -6554,7 +6553,7 @@ void Compiler::impPopCallArgs(CORINFO_SIG_INFO* sig, GenTreeCall* call)
         params[i].CorType = strip(info.compCompHnd->getArgType(sig, sigArg, &params[i].ClassHandle));
 
         if (params[i].CorType != CORINFO_TYPE_CLASS && params[i].CorType != CORINFO_TYPE_BYREF &&
-            params[i].CorType != CORINFO_TYPE_PTR && params[i].CorType != CORINFO_TYPE_VAR)
+            params[i].CorType != CORINFO_TYPE_PTR)
         {
             CORINFO_CLASS_HANDLE argRealClass = info.compCompHnd->getArgClass(sig, sigArg);
             if (argRealClass != nullptr)
@@ -6572,8 +6571,7 @@ void Compiler::impPopCallArgs(CORINFO_SIG_INFO* sig, GenTreeCall* call)
     }
 
     if ((sig->retTypeSigClass != nullptr) && (sig->retType != CORINFO_TYPE_CLASS) &&
-        (sig->retType != CORINFO_TYPE_BYREF) && (sig->retType != CORINFO_TYPE_PTR) &&
-        (sig->retType != CORINFO_TYPE_VAR))
+        (sig->retType != CORINFO_TYPE_BYREF) && (sig->retType != CORINFO_TYPE_PTR))
     {
         // Make sure that all valuetypes (including enums) that we push are loaded.
         // This is to guarantee that if a GC is triggered from the prestub of this methods,