Readonly members emit changes

src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs

@@ -2990,7 +2990,7 @@ internal static bool HasHome(
                         return true;
                     }
 
-                    if (!IsAnyReadOnly(addressKind) && type.IsReadOnly)
+                    if (!IsAnyReadOnly(addressKind) && method.IsEffectivelyReadOnly)
                     {
                         return method.MethodKind == MethodKind.Constructor;
                     }

src/Compilers/CSharp/Portable/CodeGen/EmitAddress.cs

@@ -64,6 +64,13 @@ private LocalDefinition EmitAddress(BoundExpression expression, AddressKind addr
 
                     if (expression.Type.IsValueType)
                     {
+
+                        if (!HasHome(expression, addressKind))
+                        {
+                            // a readonly method is calling a non-readonly method, therefore we need to copy 'this'
+                            goto default;
+                        }
+
                         _builder.EmitLoadArgumentOpcode(0);
                     }
                     else

src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs

@@ -1688,7 +1688,7 @@ private bool IsReadOnlyCall(MethodSymbol method, NamedTypeSymbol methodContainin
         {
             Debug.Assert(methodContainingType.IsVerifierValue(), "only struct calls can be readonly");
 
-            if (methodContainingType.IsReadOnly && method.MethodKind != MethodKind.Constructor)
+            if (method.IsEffectivelyReadOnly && method.MethodKind != MethodKind.Constructor)
             {
                 return true;
             }

src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/SynthesizedSymbols/AnonymousType.SynthesizedMethodBase.cs

@@ -117,6 +117,8 @@ public sealed override ImmutableArray<MethodSymbol> ExplicitInterfaceImplementat
                 get { return ImmutableArray<MethodSymbol>.Empty; }
             }
 
+            internal sealed override bool IsDeclaredReadOnly => true;
+
             public sealed override ImmutableArray<CustomModifier> RefCustomModifiers
             {
                 get { return ImmutableArray<CustomModifier>.Empty; }

src/Compilers/CSharp/Portable/Symbols/ErrorMethodSymbol.cs

@@ -124,6 +124,8 @@ public override ImmutableArray<MethodSymbol> ExplicitInterfaceImplementations
             get { return ImmutableArray<MethodSymbol>.Empty; }
         }
 
+        internal override bool IsDeclaredReadOnly => false;
+
         internal override int ParameterCount
         {
             get { return 0; }

src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEMethodSymbol.cs

@@ -1027,6 +1027,9 @@ public override ImmutableArray<MethodSymbol> ExplicitInterfaceImplementations
             }
         }
 
+        // PROTOTYPE: need to round trip readonly attribute in metadata
+        internal override bool IsDeclaredReadOnly => false;
+
         public override string GetDocumentationCommentXml(CultureInfo preferredCulture = null, bool expandIncludes = false, CancellationToken cancellationToken = default(CancellationToken))
         {
             return PEDocumentationCommentUtils.GetDocumentationComment(this, _containingType.ContainingPEModule, preferredCulture, cancellationToken, ref AccessUncommonFields()._lazyDocComment);

src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs

@@ -297,6 +297,21 @@ internal virtual bool IsExplicitInterfaceImplementation
             get { return ExplicitInterfaceImplementations.Any(); }
         }
 
+        // PROTOTYPE: this should become public API
+        /// <summary>
+        /// Indicates whether the method is declared readonly, i.e.
+        /// whether 'this' is readonly in the scope of the method.
+        /// See also <see cref="IsEffectivelyReadOnly"/>
+        /// </summary>
+        internal abstract bool IsDeclaredReadOnly { get; }
+
+        // PROTOTYPE: this should become public API
+        /// <summary>
+        /// Indicates whether the method is effectively readonly,
+        /// by either the method or the containing type being marked readonly.
+        /// </summary>
+        internal bool IsEffectivelyReadOnly => IsDeclaredReadOnly || ContainingType?.IsReadOnly == true;
+
         /// <summary>
         /// Returns interface methods explicitly implemented by this method.
         /// </summary>

src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs

@@ -373,6 +373,9 @@ internal override bool IsExplicitInterfaceImplementation
             get { return false; }
         }
 
+        // extension methods are static and therefore not readonly
+        internal override bool IsDeclaredReadOnly => false;
+
         public override ImmutableArray<MethodSymbol> ExplicitInterfaceImplementations
         {
             get { return ImmutableArray<MethodSymbol>.Empty; }

src/Compilers/CSharp/Portable/Symbols/SignatureOnlyMethodSymbol.cs

@@ -143,6 +143,8 @@ internal override bool IsMetadataFinal
             }
         }
 
+        internal override bool IsDeclaredReadOnly => false;
+
         internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree) { throw ExceptionUtilities.Unreachable; }
 
         #endregion

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

@@ -396,6 +396,8 @@ internal override bool GenerateDebugInfo
             get { return true; }
         }
 
+        internal override bool IsDeclaredReadOnly => false;
+
         public override ImmutableArray<TypeParameterConstraintClause> GetTypeParameterConstraintClauses(bool early) => ImmutableArray<TypeParameterConstraintClause>.Empty;
 
         internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

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

@@ -360,6 +360,8 @@ internal override TypeSymbol IteratorElementType
 
         internal bool IsExpressionBodied => _syntax.Body == null && _syntax.ExpressionBody != null;
 
+        internal override bool IsDeclaredReadOnly => false;
+
         public override DllImportData GetDllImportData() => null;
 
         internal override ImmutableArray<string> GetAppliedConditionalSymbols() => ImmutableArray<string>.Empty;

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

@@ -509,7 +509,7 @@ public sealed override bool IsAsync
             }
         }
 
-        internal bool IsReadOnly
+        internal override bool IsDeclaredReadOnly
         {
             get
             {

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

@@ -938,7 +938,7 @@ private void CheckModifiers(bool hasBody, Location location, DiagnosticBag diagn
                 // The modifier '{0}' is not valid for this item
                 diagnostics.Add(ErrorCode.ERR_BadMemberFlag, location, SyntaxFacts.GetText(SyntaxKind.VirtualKeyword));
             }
-            else if (IsStatic && IsReadOnly)
+            else if (IsStatic && IsDeclaredReadOnly)
             {
                 // The modifier '{0}' is not valid for this item
                 diagnostics.Add(ErrorCode.ERR_BadMemberFlag, location, SyntaxFacts.GetText(SyntaxKind.ReadOnlyKeyword));

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

@@ -456,7 +456,7 @@ private void CheckModifiers(Location location, bool hasBody, bool isAutoProperty
             {
                 diagnostics.Add(AccessCheck.GetProtectedMemberInSealedTypeError(ContainingType), location, this);
             }
-            else if (IsStatic && IsReadOnly && !_property.HasReadOnlyModifier)
+            else if (IsStatic && IsDeclaredReadOnly && !_property.HasReadOnlyModifier)
             {
                 // The modifier '{0}' is not valid for this item
                 diagnostics.Add(ErrorCode.ERR_BadMemberFlag, location, SyntaxFacts.GetText(SyntaxKind.ReadOnlyKeyword));

src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs

@@ -208,6 +208,8 @@ public override ImmutableArray<MethodSymbol> ExplicitInterfaceImplementations
             get { return ImmutableArray<MethodSymbol>.Empty; }
         }
 
+        internal sealed override bool IsDeclaredReadOnly => false;
+
         internal sealed override bool IsMetadataNewSlot(bool ignoreInterfaceImplementationChanges = false)
         {
             return false;

src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedGlobalMethodSymbol.cs

@@ -300,6 +300,8 @@ public override ImmutableArray<MethodSymbol> ExplicitInterfaceImplementations
             get { return ImmutableArray<MethodSymbol>.Empty; }
         }
 
+        internal sealed override bool IsDeclaredReadOnly => false;
+
         internal override bool SynthesizesLoweredBoundBody
         {
             get { return true; }

src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedInstanceMethodSymbol.cs

@@ -56,5 +56,7 @@ internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree l
         {
             throw ExceptionUtilities.Unreachable;
         }
+
+        internal override bool IsDeclaredReadOnly => false;
     }
 }

src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedIntrinsicOperatorSymbol.cs

@@ -261,6 +261,8 @@ public override ImmutableArray<MethodSymbol> ExplicitInterfaceImplementations
             }
         }
 
+        internal override bool IsDeclaredReadOnly => true;
+
         public override ImmutableArray<CustomModifier> RefCustomModifiers
         {
             get

src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedStaticConstructor.cs

@@ -278,6 +278,8 @@ public override ImmutableArray<MethodSymbol> ExplicitInterfaceImplementations
             }
         }
 
+        internal override bool IsDeclaredReadOnly => false;
+
         public sealed override bool IsImplicitlyDeclared
         {
             get

src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedMethodSymbol.cs

@@ -320,5 +320,7 @@ internal override bool GenerateDebugInfo
                 return UnderlyingMethod.GenerateDebugInfo;
             }
         }
+
+        internal override bool IsDeclaredReadOnly => UnderlyingMethod.IsDeclaredReadOnly;
     }
 }