diff --git a/src/Compilers/CSharp/Portable/Symbols/NullableAnnotationExtensions.cs b/src/Compilers/CSharp/Portable/Symbols/NullableAnnotationExtensions.cs
index 36f6b14b927275afebe8004b381c34a94bb1e3ee..1c06e29b20673e5fe6f7f7d162792b169cfa5f80 100644
--- a/src/Compilers/CSharp/Portable/Symbols/NullableAnnotationExtensions.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/NullableAnnotationExtensions.cs
@@ -124,7 +124,9 @@ internal static ImmutableArray<ITypeSymbol> GetPublicSymbols(this ImmutableArray
         internal static ImmutableArray<CodeAnalysis.NullableAnnotation> ToPublicAnnotations(this ImmutableArray<TypeWithAnnotations> types) =>
             types.SelectAsArray(t => t.ToPublicAnnotation());
 
-        internal static CodeAnalysis.NullableAnnotation ToPublicAnnotation(TypeSymbol type, NullableAnnotation annotation)
+#nullable enable
+
+        internal static CodeAnalysis.NullableAnnotation ToPublicAnnotation(TypeSymbol? type, NullableAnnotation annotation)
         {
             Debug.Assert(annotation != NullableAnnotation.Ignored);
             return annotation switch
@@ -135,7 +137,7 @@ internal static CodeAnalysis.NullableAnnotation ToPublicAnnotation(TypeSymbol ty
                 // A value type may be oblivious or not annotated depending on whether the type reference
                 // is from source or metadata. (Binding using the #nullable context only when setting the annotation
                 // to avoid checking IsValueType early.) The annotation is normalized here in the public API.
-                NullableAnnotation.Oblivious when type.IsValueType => CodeAnalysis.NullableAnnotation.NotAnnotated,
+                NullableAnnotation.Oblivious when type?.IsValueType == true => CodeAnalysis.NullableAnnotation.NotAnnotated,
                 NullableAnnotation.Oblivious => CodeAnalysis.NullableAnnotation.None,
 
                 NullableAnnotation.Ignored => CodeAnalysis.NullableAnnotation.None,
@@ -144,6 +146,8 @@ internal static CodeAnalysis.NullableAnnotation ToPublicAnnotation(TypeSymbol ty
             };
         }
 
+#nullable disable
+
         internal static CSharp.NullableAnnotation ToInternalAnnotation(this CodeAnalysis.NullableAnnotation annotation) =>
             annotation switch
             {
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
index fe8c93a6bda01c203d251344e06d1208a39d952e..de14d902216c2a287af45f721f244ef087419699 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
@@ -142278,6 +142278,43 @@ static void F(object x, object? y)
                 Diagnostic(ErrorCode.WRN_NullReferenceArgument, "y").WithArguments("y", "object A.this[object? x, object y]").WithLocation(7, 22));
         }
 
+        [Fact]
+        [WorkItem(49754, "https://github.com/dotnet/roslyn/issues/49754")]
+        public void Issue49754()
+        {
+            var source0 =
+@"
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+#nullable enable
+
+namespace Repro
+{
+	public class Test
+	{
+		public void Test(IEnumerable<(int test, int score)> scores)
+		{
+			scores.Select(s => (s.test, s.score switch
+			{
+
+			}));
+		}
+	}
+}"
+;
+            var comp = CreateCompilation(source0);
+            comp.VerifyEmitDiagnostics(
+                // (12,15): error CS0542: 'Test': member names cannot be the same as their enclosing type
+                // 		public void Test(IEnumerable<(int test, int score)> scores)
+                Diagnostic(ErrorCode.ERR_MemberNameSameAsType, "Test").WithArguments("Test").WithLocation(12, 15),
+                // (14,11): error CS0411: The type arguments for method 'Enumerable.Select<TSource, TResult>(IEnumerable<TSource>, Func<TSource, TResult>)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                // 			scores.Select(s => (s.test, s.score switch
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "Select").WithArguments("System.Linq.Enumerable.Select<TSource, TResult>(System.Collections.Generic.IEnumerable<TSource>, System.Func<TSource, TResult>)").WithLocation(14, 11)
+                );
+        }
+
         [Fact]
         [WorkItem(48992, "https://github.com/dotnet/roslyn/issues/48992")]
         public void TryGetValue_GenericMethod()