Misc.

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

@@ -616,16 +616,16 @@ private void InheritNullableStateOfTrackableStruct(TypeSymbol targetType, int ta
             // See ModifyMembers_StructPropertyNoBackingField and PropertyCycle_Struct tests.
             foreach (var field in _emptyStructTypeCache.GetStructInstanceFields(targetType))
             {
-                InheritNullableStateOfFieldOrProperty(targetSlot, valueSlot, field, isByRefTarget, slotWatermark);
+                InheritNullableStateOfMember(targetSlot, valueSlot, field, isByRefTarget, slotWatermark);
             }
         }
 
         // 'slotWatermark' is used to avoid inheriting members from inherited members.
-        private void InheritNullableStateOfFieldOrProperty(int targetContainerSlot, int valueContainerSlot, Symbol fieldOrProperty, bool isByRefTarget, int slotWatermark)
+        private void InheritNullableStateOfMember(int targetContainerSlot, int valueContainerSlot, Symbol member, bool isByRefTarget, int slotWatermark)
         {
             Debug.Assert(valueContainerSlot <= slotWatermark);
 
-            TypeSymbolWithAnnotations fieldOrPropertyType = fieldOrProperty.GetTypeOrReturnType();
+            TypeSymbolWithAnnotations fieldOrPropertyType = member.GetTypeOrReturnType();
 
             if (fieldOrPropertyType.IsReferenceType)
             {
@@ -633,17 +633,17 @@ private void InheritNullableStateOfFieldOrProperty(int targetContainerSlot, int
                 // Declaration information takes priority.
                 if (fieldOrPropertyType.IsNullable != false)
                 {
-                    int targetMemberSlot = GetOrCreateSlot(fieldOrProperty, targetContainerSlot);
+                    int targetMemberSlot = GetOrCreateSlot(member, targetContainerSlot);
                     bool? value = !fieldOrPropertyType.IsNullable;
                     if (isByRefTarget)
                     {
-                        // This is a property/field access through a by ref entity and it isn't considered declared as not-nullable. 
-                        // Since reference can point to the heap, we cannot assume the property/field doesn't have null value after this assignment,
-                        // regardless of what value is being assigned.
+                        // This is a member access through a by ref entity and it isn't considered declared as not-nullable. 
+                        // Since reference can point to the heap, we cannot assume the member doesn't have null value
+                        // after this assignment, regardless of what value is being assigned.
                     }
                     else if (valueContainerSlot > 0)
                     {
-                        int valueMemberSlot = VariableSlot(fieldOrProperty, valueContainerSlot);
+                        int valueMemberSlot = VariableSlot(member, valueContainerSlot);
                         value = valueMemberSlot > 0 && valueMemberSlot < this.State.Capacity ?
                             this.State[valueMemberSlot] :
                             null;
@@ -654,23 +654,23 @@ private void InheritNullableStateOfFieldOrProperty(int targetContainerSlot, int
 
                 if (valueContainerSlot > 0)
                 {
-                    int valueMemberSlot = VariableSlot(fieldOrProperty, valueContainerSlot);
+                    int valueMemberSlot = VariableSlot(member, valueContainerSlot);
                     if (valueMemberSlot > 0 && valueMemberSlot <= slotWatermark)
                     {
-                        int targetMemberSlot = GetOrCreateSlot(fieldOrProperty, targetContainerSlot);
+                        int targetMemberSlot = GetOrCreateSlot(member, targetContainerSlot);
                         InheritNullableStateOfTrackableType(targetMemberSlot, valueMemberSlot, isByRefTarget, slotWatermark);
                     }
                 }
             }
             else if (EmptyStructTypeCache.IsTrackableStructType(fieldOrPropertyType.TypeSymbol))
             {
-                int targetMemberSlot = GetOrCreateSlot(fieldOrProperty, targetContainerSlot);
+                int targetMemberSlot = GetOrCreateSlot(member, targetContainerSlot);
                 if (targetMemberSlot > 0)
                 {
                     int valueMemberSlot = -1;
                     if (valueContainerSlot > 0)
                     {
-                        int slot = GetOrCreateSlot(fieldOrProperty, valueContainerSlot);
+                        int slot = GetOrCreateSlot(member, valueContainerSlot);
                         if (slot < slotWatermark)
                         {
                             valueMemberSlot = slot;
@@ -712,8 +712,8 @@ private void InheritNullableStateOfTrackableType(int targetSlot, int valueSlot,
                     continue;
                 }
                 var member = variable.Symbol;
-                Debug.Assert(member.Kind == SymbolKind.Field || member.Kind == SymbolKind.Property);
-                InheritNullableStateOfFieldOrProperty(targetSlot, valueSlot, member, isByRefTarget, slotWatermark);
+                Debug.Assert(member.Kind == SymbolKind.Field || member.Kind == SymbolKind.Property || member.Kind == SymbolKind.Event);
+                InheritNullableStateOfMember(targetSlot, valueSlot, member, isByRefTarget, slotWatermark);
             }
         }
 

src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs

@@ -238,7 +238,7 @@ class C
                 Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "int").WithArguments("System.Int32").WithLocation(4, 17));
         }
 
-        [Fact]
+        [ConditionalFact(typeof(DesktopOnly))]
         public void UnannotatedAssemblies_WithSomeExtraAnnotations()
         {
             // PROTOTYPE(NullableReferenceTypes): external annotations should be removed or fully designed/productized
@@ -33885,6 +33885,30 @@ static void F()
                 Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "b.Q.P2").WithLocation(25, 9));
         }
 
+        [Fact]
+        public void Members_ObjectInitializer_Events()
+        {
+            var source =
+@"delegate void D();
+class C
+{
+    event D? E;
+    static void F()
+    {
+        C c;
+        c = new C() { };
+        c.E.Invoke(); // warning
+        c = new C() { E = F };
+        c.E.Invoke();
+    }
+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular8);
+            comp.VerifyDiagnostics(
+                // (9,9): warning CS8602: Possible dereference of a null reference.
+                //         c.E.Invoke(); // warning
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "c.E").WithLocation(9, 9));
+        }
+
         // PROTOTYPE(NullableReferenceTypes): Support assignment of derived type instances.
         [Fact(Skip = "TODO")]
         public void Members_ObjectInitializer_DerivedType()

src/Compilers/Core/Portable/Operations/OperationKind.cs

@@ -192,8 +192,6 @@ public enum OperationKind
         ConstructorBodyOperation = 0x59,
         /// <summary>Indicates an <see cref="IDiscardOperation"/>.</summary>
         Discard = 0x5A,
-        /// <summary>Indicates an <see cref="ISuppressNullableWarningOperation"/>.</summary>
-        SuppressNullableWarning = 0x5B,
 
         /// <summary>Indicates an <see cref="IFlowCaptureOperation"/>.</summary>
         FlowCapture = 0x5B,
@@ -207,6 +205,8 @@ public enum OperationKind
         StaticLocalInitializationSemaphore = 0x5F,
         /// <summary>Indicates an <see cref="IFlowAnonymousFunctionOperation"/>.</summary>
         FlowAnonymousFunction = 0x60,
+        /// <summary>Indicates an <see cref="ISuppressNullableWarningOperation"/>.</summary>
+        SuppressNullableWarning = 0x61,
 
         // /// <summary>Indicates an <see cref="IFixedOperation"/>.</summary>
         // https://github.com/dotnet/roslyn/issues/21281

src/Compilers/Core/Portable/PublicAPI.Unshipped.txt

@@ -15,7 +15,7 @@ Microsoft.CodeAnalysis.FlowAnalysis.IIsNullOperation.Operand.get -> Microsoft.Co
 Microsoft.CodeAnalysis.FlowAnalysis.IStaticLocalInitializationSemaphoreOperation
 Microsoft.CodeAnalysis.FlowAnalysis.IStaticLocalInitializationSemaphoreOperation.Local.get -> Microsoft.CodeAnalysis.ILocalSymbol
 Microsoft.CodeAnalysis.IOperation.SemanticModel.get -> Microsoft.CodeAnalysis.SemanticModel
-Microsoft.CodeAnalysis.OperationKind.SuppressNullableWarning = 91 -> Microsoft.CodeAnalysis.OperationKind
+Microsoft.CodeAnalysis.OperationKind.SuppressNullableWarning = 97 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.Operations.CommonConversion.IsImplicit.get -> bool
 Microsoft.CodeAnalysis.Operations.ISuppressNullableWarningOperation
 Microsoft.CodeAnalysis.Operations.ISuppressNullableWarningOperation.Expression.get -> Microsoft.CodeAnalysis.IOperation

src/VisualStudio/Core/Test/ObjectBrowser/CSharp/ObjectBrowerTests.vb

@@ -141,7 +141,7 @@ namespace N
 
             Using state = CreateLibraryManager(GetWorkspaceDefinition(code, metaDatacode, False))
                 Dim library = state.GetLibrary()
-                Dim list = library.GetProjectList().GetReferenceList(0).GetNamespaceList(0).GetTypeList(0)
+                Dim list = library.GetProjectList().GetReferenceList(0).GetNamespaceList(0).GetTypeList(1)
                 list.VerifyNames("C", "C.PublicEnumTest")
             End Using
         End Sub