From b85d02a790537f6201cc6354f25912ee6df7e19c Mon Sep 17 00:00:00 2001
From: EgorBo <egorbo@gmail.com>
Date: Thu, 16 Jan 2020 17:27:04 +0300
Subject: [PATCH 1/9] Optimize `box + isinst + unbox.any` as `nop`

---
 src/coreclr/src/jit/importer.cpp | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/coreclr/src/jit/importer.cpp b/src/coreclr/src/jit/importer.cpp
index 132cf2bf082e47..1f3c1404c14bc2 100644
--- a/src/coreclr/src/jit/importer.cpp
+++ b/src/coreclr/src/jit/importer.cpp
@@ -5902,13 +5902,13 @@ int Compiler::impBoxPatternMatch(CORINFO_RESOLVED_TOKEN* pResolvedToken, const B
             break;
 
         case CEE_ISINST:
-            // box + isinst + br_true/false
             if (codeAddr + 1 + sizeof(mdToken) + 1 <= codeEndp)
             {
                 const BYTE* nextCodeAddr = codeAddr + 1 + sizeof(mdToken);
 
                 switch (nextCodeAddr[0])
                 {
+                    // box + isinst + br_true/false
                     case CEE_BRTRUE:
                     case CEE_BRTRUE_S:
                     case CEE_BRFALSE:
@@ -5941,6 +5941,27 @@ int Compiler::impBoxPatternMatch(CORINFO_RESOLVED_TOKEN* pResolvedToken, const B
                                 }
                             }
                         }
+                        break;
+
+                    // box + isinst + unbox.any
+                    case CEE_UNBOX_ANY:
+                        if ((nextCodeAddr + 5) <= codeEndp)
+                        {
+                            CORINFO_RESOLVED_TOKEN unboxResolvedToken = {};
+                            impResolveToken(codeAddr + 1, &unboxResolvedToken, CORINFO_TOKENKIND_Class);
+
+                            // See if the resolved tokens describe types that are equal.
+                            const TypeCompareState compare =
+                                info.compCompHnd->compareTypesForEquality(unboxResolvedToken.hClass, pResolvedToken->hClass);
+
+                            // If so, box/unbox.any is a nop.
+                            if (compare == TypeCompareState::Must)
+                            {
+                                JITDUMP("\n Importing BOX; ISINST, UNBOX.ANY as NOP\n");
+                                return 6 + sizeof(mdToken);
+                            }
+                        }
+                        break;
                 }
             }
             break;

From 017eb8c4b7349e07f9d478078badd7c5a5e1f109 Mon Sep 17 00:00:00 2001
From: Egor Bogatov <egorbo@gmail.com>
Date: Thu, 16 Jan 2020 20:11:54 +0300
Subject: [PATCH 2/9] Formatting

---
 src/coreclr/src/jit/importer.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/coreclr/src/jit/importer.cpp b/src/coreclr/src/jit/importer.cpp
index 1f3c1404c14bc2..0e3fe11dbc40d4 100644
--- a/src/coreclr/src/jit/importer.cpp
+++ b/src/coreclr/src/jit/importer.cpp
@@ -5952,7 +5952,8 @@ int Compiler::impBoxPatternMatch(CORINFO_RESOLVED_TOKEN* pResolvedToken, const B
 
                             // See if the resolved tokens describe types that are equal.
                             const TypeCompareState compare =
-                                info.compCompHnd->compareTypesForEquality(unboxResolvedToken.hClass, pResolvedToken->hClass);
+                                info.compCompHnd->compareTypesForEquality(unboxResolvedToken.hClass,
+                                                                          pResolvedToken->hClass);
 
                             // If so, box/unbox.any is a nop.
                             if (compare == TypeCompareState::Must)

From 8eb9f803042bf4a097d7a18cf0b1347931a2c0b0 Mon Sep 17 00:00:00 2001
From: EgorBo <egorbo@gmail.com>
Date: Thu, 16 Jan 2020 22:27:21 +0300
Subject: [PATCH 3/9] Address feedback

---
 src/coreclr/src/jit/importer.cpp | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/src/coreclr/src/jit/importer.cpp b/src/coreclr/src/jit/importer.cpp
index 0e3fe11dbc40d4..3e4b67ee0a3fe9 100644
--- a/src/coreclr/src/jit/importer.cpp
+++ b/src/coreclr/src/jit/importer.cpp
@@ -5945,21 +5945,28 @@ int Compiler::impBoxPatternMatch(CORINFO_RESOLVED_TOKEN* pResolvedToken, const B
 
                     // box + isinst + unbox.any
                     case CEE_UNBOX_ANY:
-                        if ((nextCodeAddr + 5) <= codeEndp)
+                        if ((nextCodeAddr + 1 + sizeof(mdToken)) <= codeEndp)
                         {
+                            CORINFO_RESOLVED_TOKEN isinstResolvedToken = {};
+                            impResolveToken(codeAddr + 1, &isinstResolvedToken, CORINFO_TOKENKIND_Class);
+
                             CORINFO_RESOLVED_TOKEN unboxResolvedToken = {};
-                            impResolveToken(codeAddr + 1, &unboxResolvedToken, CORINFO_TOKENKIND_Class);
+                            impResolveToken(nextCodeAddr + 1, &unboxResolvedToken, CORINFO_TOKENKIND_Class);
 
                             // See if the resolved tokens describe types that are equal.
-                            const TypeCompareState compare =
+                            const TypeCompareState compareBoxIsInst =
+                                info.compCompHnd->compareTypesForEquality(isinstResolvedToken.hClass,
+                                                                          pResolvedToken->hClass);
+                            const TypeCompareState compareBoxUnbox =
                                 info.compCompHnd->compareTypesForEquality(unboxResolvedToken.hClass,
                                                                           pResolvedToken->hClass);
 
                             // If so, box/unbox.any is a nop.
-                            if (compare == TypeCompareState::Must)
+                            if (compareBoxIsInst == TypeCompareState::Must &&
+                                compareBoxUnbox == TypeCompareState::Must)
                             {
                                 JITDUMP("\n Importing BOX; ISINST, UNBOX.ANY as NOP\n");
-                                return 6 + sizeof(mdToken);
+                                return 2 + sizeof(mdToken) * 2;
                             }
                         }
                         break;

From ffdc2e1674067afafcdd08796ad2ca9b8d22dc7e Mon Sep 17 00:00:00 2001
From: EgorBo <egorbo@gmail.com>
Date: Fri, 17 Jan 2020 00:52:10 +0300
Subject: [PATCH 4/9] Add tests

---
 src/coreclr/src/jit/importer.cpp              |   3 +-
 .../Boxing/box_isinst_unbox-noinline.csproj   |  20 ++
 .../Conversions/Boxing/box_isinst_unbox.cs    | 237 ++++++++++++++++++
 .../Boxing/box_isinst_unbox.csproj            |  10 +
 4 files changed, 268 insertions(+), 2 deletions(-)
 create mode 100644 src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox-noinline.csproj
 create mode 100644 src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.cs
 create mode 100644 src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.csproj

diff --git a/src/coreclr/src/jit/importer.cpp b/src/coreclr/src/jit/importer.cpp
index 3e4b67ee0a3fe9..73e43cafda77c6 100644
--- a/src/coreclr/src/jit/importer.cpp
+++ b/src/coreclr/src/jit/importer.cpp
@@ -5962,8 +5962,7 @@ int Compiler::impBoxPatternMatch(CORINFO_RESOLVED_TOKEN* pResolvedToken, const B
                                                                           pResolvedToken->hClass);
 
                             // If so, box/unbox.any is a nop.
-                            if (compareBoxIsInst == TypeCompareState::Must &&
-                                compareBoxUnbox == TypeCompareState::Must)
+                            if (compareBoxIsInst == TypeCompareState::Must && compareBoxUnbox == TypeCompareState::Must)
                             {
                                 JITDUMP("\n Importing BOX; ISINST, UNBOX.ANY as NOP\n");
                                 return 2 + sizeof(mdToken) * 2;
diff --git a/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox-noinline.csproj b/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox-noinline.csproj
new file mode 100644
index 00000000000000..758180f61372b8
--- /dev/null
+++ b/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox-noinline.csproj
@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <DebugType>None</DebugType>
+    <Optimize>True</Optimize>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildProjectName).cs" />
+  </ItemGroup>
+  <PropertyGroup>
+    <CLRTestBatchPreCommands><![CDATA[
+$(CLRTestBatchPreCommands)
+set COMPlus_JitNoInline=1
+]]></CLRTestBatchPreCommands>
+    <BashCLRTestPreCommands><![CDATA[
+$(BashCLRTestPreCommands)
+export COMPlus_JitNoInline=1
+]]></BashCLRTestPreCommands>
+  </PropertyGroup>
+</Project>
diff --git a/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.cs b/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.cs
new file mode 100644
index 00000000000000..ef56f931667dd0
--- /dev/null
+++ b/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.cs
@@ -0,0 +1,237 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+public static class Tests
+{
+    private static int returnCode = 100;
+
+    public static int BoxIsInstUnbox1<T>(T t) => t is int n ? n : -1;
+    public static int BoxIsInstUnbox2<T>(T t) => t is string n ? n.Length : -1;
+    public static int BoxIsInstUnbox3<T>(T t) => t is Struct1<int> n ? n.a : -1;
+    public static int BoxIsInstUnbox4<T>(T t) => t is Struct1<IDisposable> n ? n.GetHashCode() : -1;
+    public static int BoxIsInstUnbox5<T>(T t) => t is Class1<int> n ? n.a : -1;
+    public static int BoxIsInstUnbox6<T>(T t) => t is RefBase n ? n.a : -1;
+    public static int BoxIsInstUnbox7<T>(T t) => t is object[] n ? n.Length : -1;
+
+    public static void Expect(this int actual, int expected, [CallerLineNumber] int line = 0)
+    {
+        if (expected != actual)
+        {
+            Console.WriteLine($"{actual} != {expected}, line {line}.");
+            returnCode++;
+        }
+    }
+
+    public static int Main()
+    {
+        BoxIsInstUnbox1<int>(1).Expect(1);
+        BoxIsInstUnbox1<uint>(1).Expect(-1);
+        BoxIsInstUnbox1<byte>(1).Expect(-1);
+        BoxIsInstUnbox1<long>(1).Expect(-1);
+        BoxIsInstUnbox1<decimal>(1).Expect(-1);
+        BoxIsInstUnbox1<int?>(1).Expect(1);
+        BoxIsInstUnbox1<int?>(null).Expect(-1);
+        BoxIsInstUnbox1<uint?>(1).Expect(-1);
+        BoxIsInstUnbox1<string>("1").Expect(-1);
+        BoxIsInstUnbox1<string>(1.ToString()).Expect(-1);
+        BoxIsInstUnbox1<string>(null).Expect(-1);
+        BoxIsInstUnbox1<Struct1<int>>(new Struct1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox1<Struct1<int>?>(new Struct1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox1<Struct1<uint>>(new Struct1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox1<Struct2<IDisposable>>(new Struct2<IDisposable>()).Expect(-1);
+        BoxIsInstUnbox1<Class1<int>>(new Class1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox1<Class1<uint>>(new Class1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox1<Class1<string>>(new Class1<string> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox1<Class1<int>>(new Class1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox1<Class1<uint>>(new Class1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox1<Class1<string>>(new Class1<string> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox1<Class1<IDisposable>>(new Class1<IDisposable> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox1<string[]>(new string[1]).Expect(-1);
+        BoxIsInstUnbox1<object[]>(new string[1]).Expect(-1);
+        BoxIsInstUnbox1<IEnumerable<object>>(new string[1]).Expect(-1);
+
+        BoxIsInstUnbox2<int>(1).Expect(-1);
+        BoxIsInstUnbox2<uint>(1).Expect(-1);
+        BoxIsInstUnbox2<byte>(1).Expect(-1);
+        BoxIsInstUnbox2<long>(1).Expect(-1);
+        BoxIsInstUnbox2<decimal>(1).Expect(-1);
+        BoxIsInstUnbox2<int?>(1).Expect(-1);
+        BoxIsInstUnbox2<int?>(null).Expect(-1);
+        BoxIsInstUnbox2<uint?>(1).Expect(-1);
+        BoxIsInstUnbox2<string>("1").Expect(1);
+        BoxIsInstUnbox2<string>(1.ToString()).Expect(1);
+        BoxIsInstUnbox2<string>(null).Expect(-1);
+        BoxIsInstUnbox2<Struct1<int>>(new Struct1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox2<Struct1<int>?>(new Struct1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox2<Struct1<uint>>(new Struct1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox2<Struct2<IDisposable>>(new Struct2<IDisposable>()).Expect(-1);
+        BoxIsInstUnbox2<Class1<int>>(new Class1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox2<Class1<uint>>(new Class1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox2<Class1<string>>(new Class1<string> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox2<Class1<int>>(new Class1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox2<Class1<uint>>(new Class1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox2<Class1<string>>(new Class1<string> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox2<Class1<IDisposable>>(new Class1<IDisposable> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox2<string[]>(new string[1]).Expect(-1);
+        BoxIsInstUnbox2<object[]>(new string[1]).Expect(-1);
+        BoxIsInstUnbox2<IEnumerable<object>>(new string[1]).Expect(-1);
+
+        BoxIsInstUnbox3<int>(1).Expect(-1);
+        BoxIsInstUnbox3<uint>(1).Expect(-1);
+        BoxIsInstUnbox3<byte>(1).Expect(-1);
+        BoxIsInstUnbox3<long>(1).Expect(-1);
+        BoxIsInstUnbox3<decimal>(1).Expect(-1);
+        BoxIsInstUnbox3<int?>(1).Expect(-1);
+        BoxIsInstUnbox3<int?>(null).Expect(-1);
+        BoxIsInstUnbox3<uint?>(1).Expect(-1);
+        BoxIsInstUnbox3<string>("1").Expect(-1);
+        BoxIsInstUnbox3<string>(1.ToString()).Expect(-1);
+        BoxIsInstUnbox3<string>(null).Expect(-1);
+        BoxIsInstUnbox3<Struct1<int>>(new Struct1<int> { a = 1 }).Expect(1);
+        BoxIsInstUnbox3<Struct1<int>?>(new Struct1<int> { a = 1 }).Expect(1);
+        BoxIsInstUnbox3<Struct1<uint>>(new Struct1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox3<Struct2<IDisposable>>(new Struct2<IDisposable>()).Expect(-1);
+        BoxIsInstUnbox3<Class1<int>>(new Class1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox3<Class1<uint>>(new Class1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox3<Class1<string>>(new Class1<string> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox3<Class1<int>>(new Class1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox3<Class1<uint>>(new Class1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox3<Class1<string>>(new Class1<string> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox3<Class1<IDisposable>>(new Class1<IDisposable> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox3<string[]>(new string[1]).Expect(-1);
+        BoxIsInstUnbox3<object[]>(new string[1]).Expect(-1);
+        BoxIsInstUnbox3<IEnumerable<object>>(new string[1]).Expect(-1);
+
+        BoxIsInstUnbox4<int>(1).Expect(-1);
+        BoxIsInstUnbox4<uint>(1).Expect(-1);
+        BoxIsInstUnbox4<byte>(1).Expect(-1);
+        BoxIsInstUnbox4<long>(1).Expect(-1);
+        BoxIsInstUnbox4<decimal>(1).Expect(-1);
+        BoxIsInstUnbox4<int?>(1).Expect(-1);
+        BoxIsInstUnbox4<int?>(null).Expect(-1);
+        BoxIsInstUnbox4<uint?>(1).Expect(-1);
+        BoxIsInstUnbox4<string>("1").Expect(-1);
+        BoxIsInstUnbox4<string>(1.ToString()).Expect(-1);
+        BoxIsInstUnbox4<string>(null).Expect(-1);
+        BoxIsInstUnbox4<Struct1<int>>(new Struct1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox4<Struct1<int>?>(new Struct1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox4<Struct1<uint>>(new Struct1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox4<Struct2<IDisposable>>(new Struct2<IDisposable>()).Expect(-1);
+        BoxIsInstUnbox4<Class1<int>>(new Class1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox4<Class1<uint>>(new Class1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox4<Class1<string>>(new Class1<string> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox4<Class1<int>>(new Class1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox4<Class1<uint>>(new Class1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox4<Class1<string>>(new Class1<string> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox4<Class1<IDisposable>>(new Class1<IDisposable> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox4<string[]>(new string[1]).Expect(-1);
+        BoxIsInstUnbox4<object[]>(new string[1]).Expect(-1);
+        BoxIsInstUnbox4<IEnumerable<object>>(new string[1]).Expect(-1);
+
+        BoxIsInstUnbox5<int>(1).Expect(-1);
+        BoxIsInstUnbox5<uint>(1).Expect(-1);
+        BoxIsInstUnbox5<byte>(1).Expect(-1);
+        BoxIsInstUnbox5<long>(1).Expect(-1);
+        BoxIsInstUnbox5<decimal>(1).Expect(-1);
+        BoxIsInstUnbox5<int?>(1).Expect(-1);
+        BoxIsInstUnbox5<int?>(null).Expect(-1);
+        BoxIsInstUnbox5<uint?>(1).Expect(-1);
+        BoxIsInstUnbox5<string>("1").Expect(-1);
+        BoxIsInstUnbox5<string>(1.ToString()).Expect(-1);
+        BoxIsInstUnbox5<string>(null).Expect(-1);
+        BoxIsInstUnbox5<Struct1<int>>(new Struct1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox5<Struct1<int>?>(new Struct1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox5<Struct1<uint>>(new Struct1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox5<Struct2<IDisposable>>(new Struct2<IDisposable>()).Expect(-1);
+        BoxIsInstUnbox5<Class1<int>>(new Class1<int> { a = 1 }).Expect(1);
+        BoxIsInstUnbox5<Class1<uint>>(new Class1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox5<Class1<string>>(new Class1<string> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox5<Class1<int>>(new Class1<int> { a = 1 }).Expect(1);
+        BoxIsInstUnbox5<Class1<uint>>(new Class1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox5<Class1<string>>(new Class1<string> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox5<Class1<IDisposable>>(new Class1<IDisposable> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox5<string[]>(new string[1]).Expect(-1);
+        BoxIsInstUnbox5<object[]>(new string[1]).Expect(-1);
+        BoxIsInstUnbox5<IEnumerable<object>>(new string[1]).Expect(-1);
+
+        BoxIsInstUnbox6<int>(1).Expect(-1);
+        BoxIsInstUnbox6<uint>(1).Expect(-1);
+        BoxIsInstUnbox6<byte>(1).Expect(-1);
+        BoxIsInstUnbox6<long>(1).Expect(-1);
+        BoxIsInstUnbox6<decimal>(1).Expect(-1);
+        BoxIsInstUnbox6<int?>(1).Expect(-1);
+        BoxIsInstUnbox6<int?>(null).Expect(-1);
+        BoxIsInstUnbox6<uint?>(1).Expect(-1);
+        BoxIsInstUnbox6<string>("1").Expect(-1);
+        BoxIsInstUnbox6<string>(1.ToString()).Expect(-1);
+        BoxIsInstUnbox6<string>(null).Expect(-1);
+        BoxIsInstUnbox6<Struct1<int>>(new Struct1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox6<Struct1<int>?>(new Struct1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox6<Struct1<uint>>(new Struct1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox6<Struct2<IDisposable>>(new Struct2<IDisposable>()).Expect(-1);
+        BoxIsInstUnbox6<Class1<int>>(new Class1<int> { a = 1 }).Expect(1);
+        BoxIsInstUnbox6<Class1<uint>>(new Class1<uint> { a = 1 }).Expect(1);
+        BoxIsInstUnbox6<Class1<string>>(new Class1<string> { a = 1 }).Expect(1);
+        BoxIsInstUnbox6<Class1<int>>(new Class1<int> { a = 1 }).Expect(1);
+        BoxIsInstUnbox6<Class1<uint>>(new Class1<uint> { a = 1 }).Expect(1);
+        BoxIsInstUnbox6<Class1<string>>(new Class1<string> { a = 1 }).Expect(1);
+        BoxIsInstUnbox6<Class1<IDisposable>>(new Class1<IDisposable> { a = 1 }).Expect(1);
+        BoxIsInstUnbox6<string[]>(new string[1]).Expect(-1);
+        BoxIsInstUnbox6<object[]>(new string[1]).Expect(-1);
+        BoxIsInstUnbox6<IEnumerable<object>>(new string[1]).Expect(-1);
+
+        BoxIsInstUnbox7<int>(1).Expect(-1);
+        BoxIsInstUnbox7<uint>(1).Expect(-1);
+        BoxIsInstUnbox7<byte>(1).Expect(-1);
+        BoxIsInstUnbox7<long>(1).Expect(-1);
+        BoxIsInstUnbox7<decimal>(1).Expect(-1);
+        BoxIsInstUnbox7<int?>(1).Expect(-1);
+        BoxIsInstUnbox7<int?>(null).Expect(-1);
+        BoxIsInstUnbox7<uint?>(1).Expect(-1);
+        BoxIsInstUnbox7<string>("1").Expect(-1);
+        BoxIsInstUnbox7<string>(1.ToString()).Expect(-1);
+        BoxIsInstUnbox7<string>(null).Expect(-1);
+        BoxIsInstUnbox7<Struct1<int>>(new Struct1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox7<Struct1<int>?>(new Struct1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox7<Struct1<uint>>(new Struct1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox7<Struct2<IDisposable>>(new Struct2<IDisposable>()).Expect(-1);
+        BoxIsInstUnbox7<Class1<int>>(new Class1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox7<Class1<uint>>(new Class1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox7<Class1<string>>(new Class1<string> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox7<Class1<int>>(new Class1<int> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox7<Class1<uint>>(new Class1<uint> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox7<Class1<string>>(new Class1<string> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox7<Class1<IDisposable>>(new Class1<IDisposable> { a = 1 }).Expect(-1);
+        BoxIsInstUnbox7<string[]>(new string[1]).Expect(1);
+        BoxIsInstUnbox7<object[]>(new string[1]).Expect(1);
+        BoxIsInstUnbox7<IEnumerable<object>>(new string[1]).Expect(1);
+
+        return returnCode;
+    }
+}
+
+public struct Struct1<T>
+{
+    public T a;
+}
+
+public struct Struct2<T>
+{
+    public T a;
+}
+
+public class RefBase : IDisposable
+{
+    public int a;
+    public void Dispose() { }
+}
+
+public class Class1<T> : RefBase
+{
+    public T b;
+}
diff --git a/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.csproj b/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.csproj
new file mode 100644
index 00000000000000..1100f420532dc8
--- /dev/null
+++ b/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.csproj
@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <DebugType>None</DebugType>
+    <Optimize>True</Optimize>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildProjectName).cs" />
+  </ItemGroup>
+</Project>

From 8c801146088ce84ddaf8b4bd0100780976c45942 Mon Sep 17 00:00:00 2001
From: EgorBo <egorbo@gmail.com>
Date: Fri, 17 Jan 2020 01:58:17 +0300
Subject: [PATCH 5/9] Fix CI errors

---
 .../Conversions/Boxing/box_isinst_unbox-noinline.csproj         | 2 +-
 .../src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.csproj | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox-noinline.csproj b/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox-noinline.csproj
index 758180f61372b8..82b3f06cd0a5d0 100644
--- a/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox-noinline.csproj
+++ b/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox-noinline.csproj
@@ -5,7 +5,7 @@
     <Optimize>True</Optimize>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="$(MSBuildProjectName).cs" />
+    <Compile Include="box_isinst_unbox.cs" />
   </ItemGroup>
   <PropertyGroup>
     <CLRTestBatchPreCommands><![CDATA[
diff --git a/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.csproj b/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.csproj
index 1100f420532dc8..3b6e765928d5d3 100644
--- a/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.csproj
+++ b/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.csproj
@@ -5,6 +5,6 @@
     <Optimize>True</Optimize>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="$(MSBuildProjectName).cs" />
+    <Compile Include="box_isinst_unbox.cs" />
   </ItemGroup>
 </Project>

From 3cf7d5c32c0eedd77e79453d628c2e8a58791ee9 Mon Sep 17 00:00:00 2001
From: EgorBo <egorbo@gmail.com>
Date: Sat, 18 Jan 2020 01:37:10 +0300
Subject: [PATCH 6/9] Address feedback

---
 src/coreclr/src/jit/importer.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/coreclr/src/jit/importer.cpp b/src/coreclr/src/jit/importer.cpp
index 73e43cafda77c6..7bb4cd5b01ec8f 100644
--- a/src/coreclr/src/jit/importer.cpp
+++ b/src/coreclr/src/jit/importer.cpp
@@ -5947,21 +5947,21 @@ int Compiler::impBoxPatternMatch(CORINFO_RESOLVED_TOKEN* pResolvedToken, const B
                     case CEE_UNBOX_ANY:
                         if ((nextCodeAddr + 1 + sizeof(mdToken)) <= codeEndp)
                         {
+                            // See if the resolved tokens in box, isinst and unbox.any describe types that are equal.
                             CORINFO_RESOLVED_TOKEN isinstResolvedToken = {};
                             impResolveToken(codeAddr + 1, &isinstResolvedToken, CORINFO_TOKENKIND_Class);
 
-                            CORINFO_RESOLVED_TOKEN unboxResolvedToken = {};
-                            impResolveToken(nextCodeAddr + 1, &unboxResolvedToken, CORINFO_TOKENKIND_Class);
-
-                            // See if the resolved tokens describe types that are equal.
                             const TypeCompareState compareBoxIsInst =
                                 info.compCompHnd->compareTypesForEquality(isinstResolvedToken.hClass,
                                                                           pResolvedToken->hClass);
+                            CORINFO_RESOLVED_TOKEN unboxResolvedToken = {};
+                            impResolveToken(nextCodeAddr + 1, &unboxResolvedToken, CORINFO_TOKENKIND_Class);
+
                             const TypeCompareState compareBoxUnbox =
                                 info.compCompHnd->compareTypesForEquality(unboxResolvedToken.hClass,
                                                                           pResolvedToken->hClass);
 
-                            // If so, box/unbox.any is a nop.
+                            // If so, box + isinst + unbox.any is a nop.
                             if (compareBoxIsInst == TypeCompareState::Must && compareBoxUnbox == TypeCompareState::Must)
                             {
                                 JITDUMP("\n Importing BOX; ISINST, UNBOX.ANY as NOP\n");

From 9b6726f6ff32bd805e83cee2dbfe1621a4546343 Mon Sep 17 00:00:00 2001
From: EgorBo <egorbo@gmail.com>
Date: Sat, 1 Feb 2020 16:35:59 +0300
Subject: [PATCH 7/9] Address feedback

---
 src/coreclr/src/jit/importer.cpp | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/src/coreclr/src/jit/importer.cpp b/src/coreclr/src/jit/importer.cpp
index 9606707cc5b5cb..805815c377f970 100644
--- a/src/coreclr/src/jit/importer.cpp
+++ b/src/coreclr/src/jit/importer.cpp
@@ -5953,21 +5953,19 @@ int Compiler::impBoxPatternMatch(CORINFO_RESOLVED_TOKEN* pResolvedToken, const B
                             CORINFO_RESOLVED_TOKEN isinstResolvedToken = {};
                             impResolveToken(codeAddr + 1, &isinstResolvedToken, CORINFO_TOKENKIND_Class);
 
-                            const TypeCompareState compareBoxIsInst =
-                                info.compCompHnd->compareTypesForEquality(isinstResolvedToken.hClass,
-                                                                          pResolvedToken->hClass);
-                            CORINFO_RESOLVED_TOKEN unboxResolvedToken = {};
-                            impResolveToken(nextCodeAddr + 1, &unboxResolvedToken, CORINFO_TOKENKIND_Class);
-
-                            const TypeCompareState compareBoxUnbox =
-                                info.compCompHnd->compareTypesForEquality(unboxResolvedToken.hClass,
-                                                                          pResolvedToken->hClass);
-
-                            // If so, box + isinst + unbox.any is a nop.
-                            if (compareBoxIsInst == TypeCompareState::Must && compareBoxUnbox == TypeCompareState::Must)
+                            if (info.compCompHnd->compareTypesForEquality(isinstResolvedToken.hClass,
+                                pResolvedToken->hClass) == TypeCompareState::Must)
                             {
-                                JITDUMP("\n Importing BOX; ISINST, UNBOX.ANY as NOP\n");
-                                return 2 + sizeof(mdToken) * 2;
+                                CORINFO_RESOLVED_TOKEN unboxResolvedToken = {};
+                                impResolveToken(nextCodeAddr + 1, &unboxResolvedToken, CORINFO_TOKENKIND_Class);
+
+                                // If so, box + isinst + unbox.any is a nop.
+                                if (info.compCompHnd->compareTypesForEquality(unboxResolvedToken.hClass,
+                                    pResolvedToken->hClass) == TypeCompareState::Must)
+                                {
+                                    JITDUMP("\n Importing BOX; ISINST, UNBOX.ANY as NOP\n");
+                                    return 2 + sizeof(mdToken) * 2;
+                                }
                             }
                         }
                         break;

From 4e36642201352a18865242ea5be32cf4ee8dca38 Mon Sep 17 00:00:00 2001
From: EgorBo <egorbo@gmail.com>
Date: Sat, 1 Feb 2020 16:39:28 +0300
Subject: [PATCH 8/9] Remove box_isinst_unbox-noinline.csproj

---
 .../Boxing/box_isinst_unbox-noinline.csproj   | 20 -------------------
 .../Conversions/Boxing/box_isinst_unbox.cs    | 13 ++++++++++++
 2 files changed, 13 insertions(+), 20 deletions(-)
 delete mode 100644 src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox-noinline.csproj

diff --git a/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox-noinline.csproj b/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox-noinline.csproj
deleted file mode 100644
index 82b3f06cd0a5d0..00000000000000
--- a/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox-noinline.csproj
+++ /dev/null
@@ -1,20 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <DebugType>None</DebugType>
-    <Optimize>True</Optimize>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="box_isinst_unbox.cs" />
-  </ItemGroup>
-  <PropertyGroup>
-    <CLRTestBatchPreCommands><![CDATA[
-$(CLRTestBatchPreCommands)
-set COMPlus_JitNoInline=1
-]]></CLRTestBatchPreCommands>
-    <BashCLRTestPreCommands><![CDATA[
-$(BashCLRTestPreCommands)
-export COMPlus_JitNoInline=1
-]]></BashCLRTestPreCommands>
-  </PropertyGroup>
-</Project>
diff --git a/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.cs b/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.cs
index ef56f931667dd0..49bb899f9d4a59 100644
--- a/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.cs
+++ b/src/coreclr/tests/src/JIT/Generics/Conversions/Boxing/box_isinst_unbox.cs
@@ -10,12 +10,25 @@ public static class Tests
 {
     private static int returnCode = 100;
 
+    [MethodImpl(MethodImplOptions.NoInlining)]
     public static int BoxIsInstUnbox1<T>(T t) => t is int n ? n : -1;
+    
+    [MethodImpl(MethodImplOptions.NoInlining)]
     public static int BoxIsInstUnbox2<T>(T t) => t is string n ? n.Length : -1;
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
     public static int BoxIsInstUnbox3<T>(T t) => t is Struct1<int> n ? n.a : -1;
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
     public static int BoxIsInstUnbox4<T>(T t) => t is Struct1<IDisposable> n ? n.GetHashCode() : -1;
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
     public static int BoxIsInstUnbox5<T>(T t) => t is Class1<int> n ? n.a : -1;
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
     public static int BoxIsInstUnbox6<T>(T t) => t is RefBase n ? n.a : -1;
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
     public static int BoxIsInstUnbox7<T>(T t) => t is object[] n ? n.Length : -1;
 
     public static void Expect(this int actual, int expected, [CallerLineNumber] int line = 0)

From 8040f7d51a55df1e54862b69d4321553f10d40e7 Mon Sep 17 00:00:00 2001
From: EgorBo <egorbo@gmail.com>
Date: Sat, 1 Feb 2020 16:58:12 +0300
Subject: [PATCH 9/9] Fix Formatting

---
 src/coreclr/src/jit/importer.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/coreclr/src/jit/importer.cpp b/src/coreclr/src/jit/importer.cpp
index 805815c377f970..5e475ae2b7d368 100644
--- a/src/coreclr/src/jit/importer.cpp
+++ b/src/coreclr/src/jit/importer.cpp
@@ -5954,14 +5954,16 @@ int Compiler::impBoxPatternMatch(CORINFO_RESOLVED_TOKEN* pResolvedToken, const B
                             impResolveToken(codeAddr + 1, &isinstResolvedToken, CORINFO_TOKENKIND_Class);
 
                             if (info.compCompHnd->compareTypesForEquality(isinstResolvedToken.hClass,
-                                pResolvedToken->hClass) == TypeCompareState::Must)
+                                                                          pResolvedToken->hClass) ==
+                                TypeCompareState::Must)
                             {
                                 CORINFO_RESOLVED_TOKEN unboxResolvedToken = {};
                                 impResolveToken(nextCodeAddr + 1, &unboxResolvedToken, CORINFO_TOKENKIND_Class);
 
                                 // If so, box + isinst + unbox.any is a nop.
                                 if (info.compCompHnd->compareTypesForEquality(unboxResolvedToken.hClass,
-                                    pResolvedToken->hClass) == TypeCompareState::Must)
+                                                                              pResolvedToken->hClass) ==
+                                    TypeCompareState::Must)
                                 {
                                     JITDUMP("\n Importing BOX; ISINST, UNBOX.ANY as NOP\n");
                                     return 2 + sizeof(mdToken) * 2;