Add support for ref-readonly locals

Ref-readonly locals are mostly identical to ref-readonly parameters. The
most important difference is that when possibly mutating methods are
called on ref-readonly locals of struct type, a proper temporary is
created before calling the method.

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

@@ -773,7 +773,10 @@ protected BoundExpression BindInferredVariableInitializer(DiagnosticBag diagnost
             }
             else
             {
-                valueKind = BindValueKind.RefOrOut;
+                valueKind = variableRefKind == RefKind.RefReadOnly
+                    ? BindValueKind.ReadonlyRef
+                    : BindValueKind.RefOrOut;
+
                 if (initializer == null)
                 {
                     Error(diagnostics, ErrorCode.ERR_ByReferenceVariableMustBeInitialized, node);
@@ -836,19 +839,10 @@ protected BoundExpression BindInferredVariableInitializer(DiagnosticBag diagnost
             // might own nested scope.
             bool hasErrors = localSymbol.ScopeBinder.ValidateDeclarationNameConflictsInScope(localSymbol, diagnostics);
 
-            if (localSymbol.RefKind == RefKind.RefReadOnly)
-            {
-                Debug.Assert(typeSyntax.Parent is RefTypeSyntax);
-                var refKeyword = typeSyntax.Parent.GetFirstToken();
-                diagnostics.Add(ErrorCode.ERR_UnexpectedToken, refKeyword.GetLocation(), refKeyword.ToString());
-            }
-            else
+            var containingMethod = this.ContainingMemberOrLambda as MethodSymbol;
+            if (containingMethod != null && containingMethod.IsAsync && localSymbol.RefKind != RefKind.None)
             {
-                var containingMethod = this.ContainingMemberOrLambda as MethodSymbol;
-                if (containingMethod != null && containingMethod.IsAsync && localSymbol.RefKind != RefKind.None)
-                {
-                    Error(diagnostics, ErrorCode.ERR_BadAsyncLocalType, declarator);
-                }
+                Error(diagnostics, ErrorCode.ERR_BadAsyncLocalType, declarator);
             }
 
             EqualsValueClauseSyntax equalsClauseSyntax = declarator.Initializer;

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

@@ -40,13 +40,11 @@ private LocalDefinition EmitAddress(BoundExpression expression, AddressKind addr
                     break;
 
                 case BoundKind.Local:
-                    EmitLocalAddress((BoundLocal)expression);
-                    break;
+                    return EmitLocalAddress((BoundLocal)expression, addressKind);
 
                 case BoundKind.Dup:
                     Debug.Assert(((BoundDup)expression).RefKind != RefKind.None, "taking address of a stack value?");
-                    _builder.EmitOpCode(ILOpCode.Dup);
-                    break;
+                    return EmitDupAddress((BoundDup)expression, addressKind);
 
                 case BoundKind.ConditionalReceiver:
                     // do nothing receiver ref must be already pushed
@@ -213,10 +211,18 @@ private void EmitComplexConditionalReceiverAddress(BoundComplexConditionalReceiv
             _builder.MarkLabel(doneLabel);
         }
 
-        private void EmitLocalAddress(BoundLocal localAccess)
+        /// <summary>
+        /// May introduce a temp which it will return. (otherwise returns null)
+        /// </summary>
+        private LocalDefinition EmitLocalAddress(BoundLocal localAccess, AddressKind addressKind)
         {
             var local = localAccess.LocalSymbol;
 
+            if (!HasHome(localAccess, addressKind != AddressKind.ReadOnly))
+            {
+                return EmitAddressOfTempClone(localAccess);
+            }
+
             if (IsStackLocal(local))
             {
                 if (local.RefKind != RefKind.None)
@@ -234,6 +240,21 @@ private void EmitLocalAddress(BoundLocal localAccess)
             {
                 _builder.EmitLocalAddress(GetLocal(localAccess));
             }
+            return null;
+        }
+
+        /// <summary>
+        /// May introduce a temp which it will return. (otherwise returns null)
+        /// </summary>
+        private LocalDefinition EmitDupAddress(BoundDup dup, AddressKind addressKind)
+        {
+            if (!HasHome(dup, addressKind != AddressKind.ReadOnly))
+            {
+                return EmitAddressOfTempClone(dup);
+            }
+
+            _builder.EmitOpCode(ILOpCode.Dup);
+            return null;
         }
 
         private void EmitPseudoVariableAddress(BoundPseudoVariable expression)
@@ -345,9 +366,11 @@ private bool HasHome(BoundExpression expression, bool needWriteable)
                         ((BoundParameter)expression).ParameterSymbol.RefKind != RefKind.RefReadOnly;
 
                 case BoundKind.Local:
-                    // locals have home unless they are byval stack locals
+                    // locals have home unless they are byval stack locals or ref-readonly
+                    // locals in a mutating call
                     var local = ((BoundLocal)expression).LocalSymbol;
-                    return !IsStackLocal(local) || local.RefKind != RefKind.None;
+                    return !((IsStackLocal(local) && local.RefKind == RefKind.None) || 
+                        (needWriteable && local.RefKind == RefKind.RefReadOnly));
 
                 case BoundKind.Call:
                     var methodRefKind = ((BoundCall)expression).Method.RefKind;
@@ -356,9 +379,9 @@ private bool HasHome(BoundExpression expression, bool needWriteable)
 
                 case BoundKind.Dup:
                     //NB: Dup represents locals that do not need IL slot
-                    //    ref locals are currently always writeable, so we do not need to care about "needWriteable"
-                    Debug.Assert(((BoundDup)expression).RefKind != RefKind.RefReadOnly);
-                    return ((BoundDup)expression).RefKind != RefKind.None;
+                    var dupRefKind = ((BoundDup)expression).RefKind;
+                    return dupRefKind == RefKind.Ref ||
+                        (!needWriteable && dupRefKind == RefKind.RefReadOnly);
 
                 case BoundKind.FieldAccess:
                     return HasHome((BoundFieldAccess)expression, needWriteable);

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

@@ -971,7 +971,23 @@ private static bool IsIndirectAssignment(BoundAssignmentOperator node)
         {
             var lhs = node.Left;
 
-            Debug.Assert(node.RefKind == RefKind.None || (lhs as BoundLocal)?.LocalSymbol.RefKind == RefKind.Ref,
+            bool IsAssignable(RefKind lhsKind, RefKind rhsKind)
+            {
+                switch (lhsKind)
+                {
+                    case RefKind.None:
+                    case RefKind.Ref:
+                        return lhsKind == rhsKind;
+                    case RefKind.RefReadOnly:
+                        return rhsKind == RefKind.RefReadOnly || rhsKind == RefKind.Ref;
+                    default:
+                        throw ExceptionUtilities.UnexpectedValue(lhsKind);
+                }
+            }
+
+            Debug.Assert(node.RefKind == RefKind.None || 
+                         lhs is BoundLocal local &&
+                         IsAssignable(local.LocalSymbol.RefKind, node.RefKind),
                                 "only ref locals can be a target of a ref assignment");
 
             switch (lhs.Kind)
@@ -1034,6 +1050,7 @@ private static bool IsIndirectAssignment(BoundAssignmentOperator node)
                     throw ExceptionUtilities.UnexpectedValue(lhs.Kind);
             }
         }
+
         private static bool IsIndirectOrInstanceFieldAssignment(BoundAssignmentOperator node)
         {
             var lhs = node.Left;

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

@@ -268,7 +268,7 @@ internal virtual bool IsWritable
                     case LocalDeclarationKind.UsingVariable:
                         return false;
                     default:
-                        return true;
+                        return RefKind != RefKind.RefReadOnly;
                 }
             }
         }