[mcs] Initial by ref returns and variables support

[mono.git] / mcs / mcs / statement.cs

diff --git a/mcs/mcs/statement.cs b/mcs/mcs/statement.cs
index 7a379fc172aff0bd375aefb7cdbee386f7e4f0c4..0c02bf0562a271da6811188fd102ecf836f0986a 100644 (file)
--- a/mcs/mcs/statement.cs
+++ b/mcs/mcs/statement.cs
@@ -1272,16 +1272,38 @@ namespace Mono.CSharp {
                        if (expr == null)
                                return false;
 
+                       if (expr is ReferenceExpression && block_return_type.Kind != MemberKind.ByRef) {
+                               ec.Report.Error (8149, loc, "By-reference returns can only be used in methods that return by reference");
+                               return false;
+                       }
+
                        if (expr.Type != block_return_type && expr.Type != InternalType.ErrorType) {
-                               expr = Convert.ImplicitConversionRequired (ec, expr, block_return_type, loc);
+                               if (block_return_type.Kind == MemberKind.ByRef) {
+                                       var ref_expr = Expr as ReferenceExpression;
+                                       if (ref_expr == null) {
+                                               ec.Report.Error (8150, loc, "By-reference return is required when method returns by reference");
+                                               return false;
+                                       }
 
-                               if (expr == null) {
-                                       if (am != null && block_return_type == ec.ReturnType) {
-                                               ec.Report.Error (1662, loc,
-                                                       "Cannot convert `{0}' to delegate type `{1}' because some of the return types in the block are not implicitly convertible to the delegate return type",
-                                                       am.ContainerType, am.GetSignatureForError ());
+                                       var byref_return = (ReferenceContainer)block_return_type;
+
+                                       if (expr.Type != byref_return.Element) {
+                                               ec.Report.Error (8151, loc, "The return by reference expression must be of type `{0}' because this method returns by reference",
+                                                                                byref_return.GetSignatureForError ());
+                                               return false;
+                                       }
+                               } else {
+
+                                       expr = Convert.ImplicitConversionRequired (ec, expr, block_return_type, loc);
+
+                                       if (expr == null) {
+                                               if (am != null && block_return_type == ec.ReturnType) {
+                                                       ec.Report.Error (1662, loc,
+                                                               "Cannot convert `{0}' to delegate type `{1}' because some of the return types in the block are not implicitly convertible to the delegate return type",
+                                                               am.ContainerType, am.GetSignatureForError ());
+                                               }
+                                               return false;
                                        }
-                                       return false;
                                }
                        }
 
@@ -2185,7 +2207,7 @@ namespace Mono.CSharp {
                                }
 
                                if (type == null) {
-                                       type = type_expr.ResolveAsType (bc);
+                                       type = ResolveTypeExpression (bc);
                                        if (type == null)
                                                return false;
 
@@ -2208,6 +2230,25 @@ namespace Mono.CSharp {
                        }
 
                        if (initializer != null) {
+                               if (li.IsByRef) {
+                                       if (!(initializer is ReferenceExpression)) {
+                                               bc.Report.Error (8172, loc, "Cannot initialize a by-reference variable `{0}' with a value", li.Name);
+                                               return false;
+                                       }
+
+                                       if (bc.CurrentAnonymousMethod is AsyncInitializer) {
+                                               bc.Report.Error (8177, loc, "Async methods cannot use by-reference variables");
+                                       } else if (bc.CurrentIterator != null) {
+                                               bc.Report.Error (8176, loc, "Iterators cannot use by-reference variables");
+                                       }
+
+                               } else {
+                                       if (initializer is ReferenceExpression) {
+                                               bc.Report.Error (8171, loc, "Cannot initialize a by-value variable `{0}' with a reference expression", li.Name);
+                                               return false;
+                                       }
+                               }
+
                                initializer = ResolveInitializer (bc, li, initializer);
                                // li.Variable.DefinitelyAssigned 
                        }
@@ -2237,6 +2278,11 @@ namespace Mono.CSharp {
                        return a.ResolveStatement (bc);
                }
 
+               protected virtual TypeSpec ResolveTypeExpression (BlockContext bc)
+               {
+                       return type_expr.ResolveAsType (bc);
+               }
+
                protected override void DoEmit (EmitContext ec)
                {
                        li.CreateBuilder (ec);
@@ -2364,6 +2410,7 @@ namespace Mono.CSharp {
                        UsingVariable = 1 << 7,
                        IsLocked = 1 << 8,
                        SymbolFileHidden = 1 << 9,
+                       ByRef = 1 << 10,
 
                        ReadonlyMask = ForeachVariable | FixedVariable | UsingVariable
                }
@@ -2448,6 +2495,8 @@ namespace Mono.CSharp {
                        }
                }
 
+               public bool IsByRef => (flags & Flags.ByRef) != 0;
+
                public bool IsCompilerGenerated {
                        get {
                                return (flags & Flags.CompilerGenerated) != 0;
@@ -2550,10 +2599,15 @@ namespace Mono.CSharp {
                                throw new InternalErrorException ("Already created variable `{0}'", name);
                        }
 
-                       //
-                       // All fixed variabled are pinned, a slot has to be alocated
-                       //
-                       builder = ec.DeclareLocal (Type, IsFixed);
+                       if (IsByRef) {
+                               builder = ec.DeclareLocal (ReferenceContainer.MakeType (ec.Module, Type), IsFixed);
+                       } else {
+                               //
+                               // All fixed variabled are pinned, a slot has to be alocated
+                               //
+                               builder = ec.DeclareLocal(Type, IsFixed);
+                       }
+
                        if ((flags & Flags.SymbolFileHidden) == 0)
                                ec.DefineLocalVariable (name, builder);
                }
@@ -2602,7 +2656,10 @@ namespace Mono.CSharp {
                        if ((flags & Flags.CompilerGenerated) != 0)
                                CreateBuilder (ec);
 
-                       ec.Emit (OpCodes.Ldloca, builder);
+                       if (IsByRef)
+                               ec.Emit (OpCodes.Ldloc, builder);
+                       else
+                               ec.Emit (OpCodes.Ldloca, builder);
                }
 
                public static string GetCompilerGeneratedName (Block block)