Disallow inline array operations in expression trees.

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -7532,4 +7532,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_InvalidInlineArrayFields" xml:space="preserve">
     <value>Inline array struct must declare one and only one instance field which must not be a ref field.</value>
   </data>
+  <data name="ERR_ExpressionTreeContainsInlineArrayOperation" xml:space="preserve">
+    <value>An expression tree may not contain an inline array access or conversion</value>
+  </data>
 </root>

src/Compilers/CSharp/Portable/Errors/ErrorCode.cs

@@ -2198,6 +2198,7 @@ internal enum ErrorCode
         ERR_InvalidInlineArrayLength = 9504,
         ERR_InvalidInlineArrayLayout = 9505,
         ERR_InvalidInlineArrayFields = 9506,
+        ERR_ExpressionTreeContainsInlineArrayOperation = 9507,
 
         #endregion
 

src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs

@@ -2317,6 +2317,7 @@ internal static bool IsBuildOnlyDiagnostic(ErrorCode code)
                 case ErrorCode.ERR_InvalidInlineArrayLength:
                 case ErrorCode.ERR_InvalidInlineArrayLayout:
                 case ErrorCode.ERR_InvalidInlineArrayFields:
+                case ErrorCode.ERR_ExpressionTreeContainsInlineArrayOperation:
                     return false;
                 default:
                     // NOTE: All error codes must be explicitly handled in this switch statement

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

@@ -110,7 +110,11 @@ public override BoundNode VisitImplicitIndexerAccess(BoundImplicitIndexerAccess
 
         public override BoundNode VisitInlineArrayAccess(BoundInlineArrayAccess node)
         {
-            // PROTOTYPE(InlineArrays): Disallow.
+            if (_inExpressionLambda)
+            {
+                Error(ErrorCode.ERR_ExpressionTreeContainsInlineArrayOperation, node);
+            }
+
             return base.VisitInlineArrayAccess(node);
         }
 
@@ -793,7 +797,13 @@ public override BoundNode VisitConversion(BoundConversion node)
                     }
                     break;
 
-                // PROTOTYPE(InlineArrays): Disallow in expression trees
+                case ConversionKind.InlineArray:
+                    if (_inExpressionLambda)
+                    {
+                        Error(ErrorCode.ERR_ExpressionTreeContainsInlineArrayOperation, node);
+                    }
+                    break;
+
                 case ConversionKind.InterpolatedStringHandler:
                     if (_inExpressionLambda)
                     {

src/Compilers/CSharp/Portable/Symbols/Source/SourceAssemblySymbol.cs

@@ -2717,7 +2717,7 @@ internal ImmutableArray<Diagnostic> GetUnusedFieldWarnings(CancellationToken can
                     }
 
                     var containingType = field.ContainingType as SourceNamedTypeSymbol;
-                    if ((object)containingType != null && !containingType.HasStructLayoutAttribute) // PROTOTYPE(InlineArrays): && !containingType.HasInlineArrayAttribute(out _)
+                    if ((object)containingType != null && !containingType.HasStructLayoutAttribute && !containingType.HasInlineArrayAttribute(out _))
                     {
                         diagnostics.Add(ErrorCode.WRN_UnreferencedFieldAssg, field.GetFirstLocationOrNone(), field);
                     }

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

@@ -1851,6 +1851,28 @@ struct Buffer
             Assert.Equal(0, length);
         }
 
+        [ConditionalFact(typeof(MonoOrCoreClrOnly))]
+        public void InlineArrayType_42()
+        {
+            var src = @"
+var b = new Buffer();
+System.Console.WriteLine(b[0]);
+
+[System.Runtime.CompilerServices.InlineArray(10)]
+public struct Buffer
+{
+    private int _element0 = 111;
+
+    public Buffer()
+    {
+    }
+}
+";
+            var comp = CreateCompilation(src + InlineArrayAttributeDefinition, targetFramework: TargetFramework.NetCoreApp);
+            // No warning CS0414: The field 'Buffer._element0' is assigned but its value is never used
+            CompileAndVerify(comp, expectedOutput: "111", verify: Verification.Fails).VerifyDiagnostics();
+        }
+
         [ConditionalFact(typeof(MonoOrCoreClrOnly))]
         public void ElementAccess_Variable_01()
         {
@@ -4241,6 +4263,36 @@ public ref struct Buffer10
                 );
         }
 
+        [Fact]
+        public void ElementAccess_ExpressionTree_01()
+        {
+            var src = @"
+using System.Linq.Expressions;
+
+class Program
+{
+    static Expression<System.Func<int>> M1(Buffer10<int> x) =>
+        () => x[0];
+
+    static Expression<System.Action> M2(Buffer10<int> x) =>
+        () => x[0] = 111;
+}
+" + Buffer10Definition;
+
+            var comp = CreateCompilation(src, targetFramework: TargetFramework.NetCoreApp, options: TestOptions.ReleaseDll);
+            comp.VerifyDiagnostics(
+                // (7,15): error CS9507: An expression tree may not contain an inline array access or conversion
+                //         () => x[0];
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsInlineArrayOperation, "x[0]").WithLocation(7, 15),
+                // (10,15): error CS0832: An expression tree may not contain an assignment operator
+                //         () => x[0] = 111;
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsAssignment, "x[0] = 111").WithLocation(10, 15),
+                // (10,15): error CS9507: An expression tree may not contain an inline array access or conversion
+                //         () => x[0] = 111;
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsInlineArrayOperation, "x[0]").WithLocation(10, 15)
+                );
+        }
+
         [ConditionalFact(typeof(MonoOrCoreClrOnly))]
         public void ElementAccess_Await_14_GenericMethod()
         {
@@ -12477,6 +12529,33 @@ .locals init (int V_0,
 ");
         }
 
+        [Fact]
+        public void Conversion_ExpressionTree_01()
+        {
+            var src = @"
+using System.Linq.Expressions;
+
+class Program
+{
+    static Expression<System.Func<int>> M1(Buffer10<int> x) =>
+        () => ((System.Span<int>)x).Length;
+
+    static Expression<System.Func<int>> M2(Buffer10<int> x) =>
+        () => ((System.ReadOnlySpan<int>)x).Length;
+}
+" + Buffer10Definition;
+
+            var comp = CreateCompilation(src, targetFramework: TargetFramework.NetCoreApp, options: TestOptions.ReleaseDll);
+            comp.VerifyDiagnostics(
+                // (7,16): error CS9507: An expression tree may not contain an inline array access or conversion
+                //         () => ((System.Span<int>)x).Length;
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsInlineArrayOperation, "(System.Span<int>)x").WithLocation(7, 16),
+                // (10,16): error CS9507: An expression tree may not contain an inline array access or conversion
+                //         () => ((System.ReadOnlySpan<int>)x).Length;
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsInlineArrayOperation, "(System.ReadOnlySpan<int>)x").WithLocation(10, 16)
+                );
+        }
+
         [ConditionalFact(typeof(MonoOrCoreClrOnly))]
         public void Conversion_NotFromType_01()
         {