Strengthen NullableAnnotationExtensions.ToPublicAnnotation helper against null input. (#49849)

Fixes #49754.

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
             {

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()