Object initializer updates

proposals/csharp-11.0/low-level-struct-improvements.md

@@ -1,5 +1,4 @@
-Low Level Struct Improvements
-====
+# Low Level Struct Improvements
 
 [!INCLUDE[Specletdisclaimer](../speclet-disclaimer.md)]
 
@@ -411,6 +410,30 @@ Span<int> ComplexScopedRefExample(scoped ref Span<int> span)
 }
 ```
 
+#### Rules for object initializers
+
+The *safe-context* of an object initializer expression is narrowest of:
+
+1. The *safe-context* of the constructor call.
+2. The *safe-context* arguments to member initializer indexers that can escape to the receiver (can escape to *caller-context*)
+3. The *safe-context* of the RHS of assignments in member initializers to non-readonly setters or *ref-safe-context* in case of ref assignment.
+
+Another way of modeling this is to think of any argument to a member initializer that can be assigned to the receiver as being an argument to the constructor. This is because the member initializer is effectively a constructor call.
+
+```c#
+Span<int> heapSpan = default;
+Span<int> stackSpan = stackalloc int[42];
+var x = new S(ref heapSpan)
+{
+    Field = stackSpan;
+}
+
+// Can be modeled as 
+var x = new S(ref heapSpan, stackSpan)
+```
+
+This modeling is important because it demonstrates that our [MAMM][rules-method-arguments-must-match] need to account specially for member initializers. Consider that this particular case needs to be illegal as it allows for a value with a narrower *safe-context* to be assigned to a higher one.
+
 ### Method arguments must match
 <a name="rules-method-arguments-must-match"></a>