Merge pull request #2799 from BrzVlad/fix-conc-card-clean

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

diff --git a/mcs/mcs/constant.cs b/mcs/mcs/constant.cs
index e794d9a7612f074249e34a3bd3078db0d86d9b17..a0ae78cdf518e42737b571c830e08a99adf00747 100644 (file)
--- a/mcs/mcs/constant.cs
+++ b/mcs/mcs/constant.cs
@@ -2179,8 +2179,11 @@ namespace Mono.CSharp {
                        var ma = expr as MemberAccess;
                        if (ma != null) {
                                var lexpr = ma.LeftExpression;
+                               Expression res;
 
-                               var res = ma.LookupNameExpression (rc, MemberLookupRestrictions.IgnoreAmbiguity);
+                               using (rc.Set (ResolveContext.Options.NameOfScope)) {
+                                       res = ma.LookupNameExpression (rc, MemberLookupRestrictions.IgnoreAmbiguity);
+                               }
 
                                if (res == null) {
                                        return false;
@@ -2194,11 +2197,6 @@ namespace Mono.CSharp {
                                        return false;
                                }
 
-                               if (!IsLeftExpressionValid (lexpr)) {
-                                       rc.Report.Error (8082, lexpr.Location, "An argument to nameof operator cannot include sub-expression");
-                                       return false;
-                               }
-
                                var mg = res as MethodGroupExpr;
                                if (mg != null) {
                                        var emg = res as ExtensionMethodGroupExpr;
@@ -2215,6 +2213,14 @@ namespace Mono.CSharp {
                                        }
                                }
 
+                               //
+                               // LAMESPEC: Why is conditional access not allowed?
+                               //
+                               if (!IsLeftResolvedExpressionValid (ma.LeftExpression) || ma.HasConditionalAccess ()) {
+                                       rc.Report.Error (8082, lexpr.Location, "An argument to nameof operator cannot include sub-expression");
+                                       return false;
+                               }
+
                                Value = ma.Name;
                                return true;
                        }
@@ -2223,26 +2229,25 @@ namespace Mono.CSharp {
                        return false;
                }
 
-               static bool IsLeftExpressionValid (Expression expr)
+               static bool IsLeftResolvedExpressionValid (Expression expr)
                {
-                       if (expr is SimpleName)
-                               return true;
+                       var fe = expr as FieldExpr;
+                       if (fe != null) {
+                               return fe.InstanceExpression == null || IsLeftResolvedExpressionValid (fe.InstanceExpression);
+                       }
 
-                       if (expr is This)
-                               return true;
+                       var pe = expr as PropertyExpr;
+                       if (pe != null)
+                               return pe.InstanceExpression == null || IsLeftResolvedExpressionValid (pe.InstanceExpression);
 
-                       if (expr is NamespaceExpression)
-                               return true;
+                       var dmb = expr as DynamicMemberBinder;
+                       if (dmb != null) {
+                               return IsLeftResolvedExpressionValid (dmb.Arguments [0].Expr);
+                       }
 
-                       if (expr is TypeExpr)
+                       if (expr is ConstantExpr || expr is TypeExpr || expr is NamespaceExpression || expr is VariableReference)
                                return true;
 
-                       var ma = expr as MemberAccess;
-                       if (ma != null) {
-                               // TODO: Will conditional access be allowed?
-                               return IsLeftExpressionValid (ma.LeftExpression);
-                       }
-
                        return false;
                }