Fix verification failure

Author: RikkiGibson

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_NullChecking.cs

@@ -79,13 +79,19 @@ private static BoundStatement ConstructDirectNullCheck(ParameterSymbol parameter
             BoundExpression paramIsNullCondition;
             var loweredLeft = factory.Parameter(parameter);
 
-            if (loweredLeft.Type.IsNullableTypeOrTypeParameter(out var underlyingNullableType))
+            if (loweredLeft.Type.IsNullableType())
             {
-                paramIsNullCondition = factory.Not(factory.MakeNullableHasValue(loweredLeft.Syntax, loweredLeft, underlyingNullableType));
+                paramIsNullCondition = factory.Not(factory.MakeNullableHasValue(loweredLeft.Syntax, loweredLeft));
             }
             else
             {
-                Debug.Assert(parameter.Type.IsPointerOrFunctionPointer());
+                // Examples of how we might get here:
+                // int*
+                // delegate*<...>
+                // T where T : int? (via some indirection)
+                Debug.Assert(parameter.Type.IsPointerOrFunctionPointer()
+                    || (parameter.Type.IsNullableTypeOrTypeParameter() && !parameter.Type.IsNullableType()));
+
                 paramIsNullCondition = factory.MakeNullCheck(loweredLeft.Syntax, loweredLeft, BinaryOperatorKind.Equal);
             }
 

src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs

@@ -1581,13 +1581,11 @@ internal BoundExpression MakeNullCheck(SyntaxNode syntax, BoundExpression rewrit
             }
         }
 
-#nullable enable
-        internal BoundExpression MakeNullableHasValue(SyntaxNode syntax, BoundExpression expression, NamedTypeSymbol? nullableType = null)
+        internal BoundExpression MakeNullableHasValue(SyntaxNode syntax, BoundExpression expression)
         {
             // PROTOTYPE(param-nullchecking): consider restoring the 'private' accessibility of 'static LocalRewriter.UnsafeGetNullableMethod()'
-            return BoundCall.Synthesized(syntax, expression, LocalRewriter.UnsafeGetNullableMethod(syntax, nullableType ?? expression.Type!, CodeAnalysis.SpecialMember.System_Nullable_T_get_HasValue, Compilation, Diagnostics));
+            return BoundCall.Synthesized(syntax, expression, LocalRewriter.UnsafeGetNullableMethod(syntax, expression.Type, CodeAnalysis.SpecialMember.System_Nullable_T_get_HasValue, Compilation, Diagnostics));
         }
-#nullable disable
 
         internal BoundExpression RewriteNullableNullEquality(
             SyntaxNode syntax,

src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs

@@ -99,13 +99,9 @@ public static bool IsVoidType(this TypeSymbol type)
         }
 
         public static bool IsNullableTypeOrTypeParameter(this TypeSymbol? type)
-            => IsNullableTypeOrTypeParameter(type, out _);
-
-        public static bool IsNullableTypeOrTypeParameter(this TypeSymbol? type, [NotNullWhen(true)] out NamedTypeSymbol? underlyingNullableType)
         {
             if (type is null)
             {
-                underlyingNullableType = null;
                 return false;
             }
 
@@ -114,30 +110,22 @@ public static bool IsNullableTypeOrTypeParameter(this TypeSymbol? type, [NotNull
                 var constraintTypes = ((TypeParameterSymbol)type).ConstraintTypesNoUseSiteDiagnostics;
                 foreach (var constraintType in constraintTypes)
                 {
-                    if (constraintType.Type.IsNullableTypeOrTypeParameter(out underlyingNullableType))
+                    if (constraintType.Type.IsNullableTypeOrTypeParameter())
                     {
                         return true;
                     }
                 }
-
-                underlyingNullableType = null;
                 return false;
             }
 
-            if (type.IsNullableType())
-            {
-                underlyingNullableType = (NamedTypeSymbol)type;
-                return true;
-            }
-            underlyingNullableType = null;
-            return false;
+            return type.IsNullableType();
         }
 
         /// <summary>
         /// Is this System.Nullable`1 type, or its substitution.
         ///
         /// To check whether a type is System.Nullable`1 or is a type parameter constrained to System.Nullable`1
-        /// use <see cref="TypeSymbolExtensions.IsNullableTypeOrTypeParameter(TypeSymbol?)" /> instead.
+        /// use <see cref="TypeSymbolExtensions.IsNullableTypeOrTypeParameter" /> instead.
         /// </summary>
         public static bool IsNullableType(this TypeSymbol type)
         {

src/Compilers/CSharp/Portable/Symbols/TypeWithAnnotations.cs

@@ -250,7 +250,7 @@ public TypeWithAnnotations WithModifiers(ImmutableArray<CustomModifier> customMo
         /// Is this System.Nullable`1 type, or its substitution.
         /// 
         /// To check whether a type is System.Nullable`1 or is a type parameter constrained to System.Nullable`1
-        /// use <see cref="TypeSymbolExtensions.IsNullableTypeOrTypeParameter(TypeSymbol?)" /> instead.
+        /// use <see cref="TypeSymbolExtensions.IsNullableTypeOrTypeParameter" /> instead.
         /// </summary>
         public bool IsNullableType() => Type.IsNullableType();
 

src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenNullCheckedParameterTests.cs

@@ -566,15 +566,15 @@ static void Main()
             var compilation = CompileAndVerify(source, parseOptions: TestOptions.RegularPreview, expectedOutput: "12");
             compilation.VerifyIL("B3<T>.M<U>(U)", @"
 {
-  // Code size       21 (0x15)
+  // Code size       20 (0x14)
   .maxstack  1
-  IL_0000:  ldarga.s   V_1
-  IL_0002:  call       ""bool T?.HasValue.get""
-  IL_0007:  brtrue.s   IL_0014
-  IL_0009:  ldstr      ""u""
-  IL_000e:  newobj     ""System.ArgumentNullException..ctor(string)""
-  IL_0013:  throw
-  IL_0014:  ret
+  IL_0000:  ldarg.1
+  IL_0001:  box        ""U""
+  IL_0006:  brtrue.s   IL_0013
+  IL_0008:  ldstr      ""u""
+  IL_000d:  newobj     ""System.ArgumentNullException..ctor(string)""
+  IL_0012:  throw
+  IL_0013:  ret
 }");
         }
 
@@ -1693,7 +1693,7 @@ public static unsafe void Main()
         }
     }
 }";
-            var verifier = CompileAndVerify(source, options: TestOptions.UnsafeDebugExe, expectedOutput: "123456");
+            var verifier = CompileAndVerify(source, options: TestOptions.UnsafeDebugExe, verify: Verification.Skipped, expectedOutput: "123456");
             verifier.VerifyDiagnostics();
             verifier.VerifyIL("C.M1", @"
 {