Merge pull request #3499 from kumpera/fix_logging

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

diff --git a/mcs/mcs/expression.cs b/mcs/mcs/expression.cs
index 76bcdbfa0ee7bdf8109573a1e6db43c9b9797deb..2a9aa97fed0e62be46728b7c4dccb871de0ff0cc 100644 (file)
--- a/mcs/mcs/expression.cs
+++ b/mcs/mcs/expression.cs
@@ -2362,6 +2362,11 @@ namespace Mono.CSharp
                        eclass = ExprClass.Value;
                        TypeSpec etype = expr.Type;
 
+                       if (type == null) {
+                               type = InternalType.ErrorType;
+                               return this;
+                       }
+
                        if (!TypeSpec.IsReferenceType (type) && !type.IsNullableType) {
                                if (TypeManager.IsGenericParameter (type)) {
                                        ec.Report.Error (413, loc,
@@ -7023,6 +7028,16 @@ namespace Mono.CSharp
                        }
                }
 
+               bool statement_resolve;
+               public override ExpressionStatement ResolveStatement (BlockContext bc)
+               {
+                       statement_resolve = true;
+                       var es = base.ResolveStatement (bc);
+                       statement_resolve = false;
+
+                       return es;
+               }
+
                protected override Expression DoResolve (ResolveContext rc)
                {
                        ResolveConditionalAccessReceiver (rc);
@@ -7111,7 +7126,7 @@ namespace Mono.CSharp
 
                        var method = mg.BestCandidate;
                        type = mg.BestCandidateReturnType;
-                       if (conditional_access_receiver)
+                       if (conditional_access_receiver && !statement_resolve)
                                type = LiftMemberType (ec, type);
 
                        if (arguments == null && method.DeclaringType.BuiltinType == BuiltinTypeSpec.Type.Object && method.Name == Destructor.MetadataName) {
@@ -7862,6 +7877,8 @@ namespace Mono.CSharp
                {
                }
 
+               public bool NoEmptyInterpolation { get; set; }
+
                public ComposedTypeSpecifier Rank {
                        get {
                                return this.rank;
@@ -8072,11 +8089,21 @@ namespace Mono.CSharp
                        if (element == null)
                                return null;
 
-                       if (element is CompoundAssign.TargetExpression) {
-                               if (first_emit != null)
-                                       throw new InternalErrorException ("Can only handle one mutator at a time");
-                               first_emit = element;
-                               element = first_emit_temp = new LocalTemporary (element.Type);
+                       var te = element as CompoundAssign.TargetExpression;
+                       if (te != null) {
+                               for (int i = 1; i < initializers.Count; ++i) {
+                                       if (initializers [i].ContainsEmitWithAwait ()) {
+                                               te.RequiresEmitWithAwait = true;
+                                               break;
+                                       }
+                               }
+
+                               if (!te.RequiresEmitWithAwait) {
+                                       if (first_emit != null)
+                                               throw new InternalErrorException ("Can only handle one mutator at a time");
+                                       first_emit = element;
+                                       element = first_emit_temp = new LocalTemporary (element.Type);
+                               }
                        }
 
                        return Convert.ImplicitConversionRequired (
@@ -8398,7 +8425,7 @@ namespace Mono.CSharp
 
                public override void Emit (EmitContext ec)
                {
-                       if (EmitOptimizedEmpty (ec))
+                       if (!NoEmptyInterpolation && EmitOptimizedEmpty (ec))
                                return;
 
                        var await_field = EmitToFieldSource (ec);
@@ -9937,7 +9964,7 @@ namespace Mono.CSharp
 
                        TypeSpec nested = null;
                        while (expr_type != null) {
-                               nested = MemberCache.FindNestedType (expr_type, Name, Arity);
+                               nested = MemberCache.FindNestedType (expr_type, Name, Arity, false);
                                if (nested == null) {
                                        if (expr_type == tnew_expr) {
                                                Error_IdentifierNotFound (rc, expr_type);
@@ -9945,7 +9972,7 @@ namespace Mono.CSharp
                                        }
 
                                        expr_type = tnew_expr;
-                                       nested = MemberCache.FindNestedType (expr_type, Name, Arity);
+                                       nested = MemberCache.FindNestedType (expr_type, Name, Arity, false);
                                        ErrorIsInaccesible (rc, nested.GetSignatureForError (), loc);
                                        break;
                                }
@@ -9986,7 +10013,7 @@ namespace Mono.CSharp
 
                public void Error_IdentifierNotFound (IMemberContext rc, TypeSpec expr_type)
                {
-                       var nested = MemberCache.FindNestedType (expr_type, Name, -System.Math.Max (1, Arity));
+                       var nested = MemberCache.FindNestedType (expr_type, Name, -System.Math.Max (1, Arity), false);
 
                        if (nested != null) {
                                Error_TypeArgumentsCannotBeUsed (rc, nested, expr.Location);
@@ -12229,6 +12256,7 @@ namespace Mono.CSharp
                                                throw new NotImplementedException ();
 
                                        sf = ec.GetTemporaryField (type);
+                                       sf.AutomaticallyReuse = false;
                                        sf.EmitAssign (ec, temp, false, false);
                                        temp_target = sf;
                                        temp.Release (ec);
@@ -12246,8 +12274,8 @@ namespace Mono.CSharp
                                temp.Release (ec);
 
                        if (sf != null)
-                               sf.IsAvailableForReuse = true;
-
+                               sf.PrepareCleanup (ec);
+                       
                        return true;
                }