Only search for member types in Microsoft.CSharp member lookup. (#26633)

As opposed to nested classes, or type parameters.

Fixes #26632

Author: JonHanna

src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/MemberLookup.cs

@@ -112,44 +112,24 @@ private bool SearchSingleType(AggregateType typeCur, out bool pfHideByName)
 
             // Loop through symbols.
             Symbol symCur;
-            for (symCur = GetSymbolLoader().LookupAggMember(_name, typeCur.OwningAggregate, symbmask_t.MASK_ALL);
+            for (symCur = GetSymbolLoader().LookupAggMember(_name, typeCur.OwningAggregate, symbmask_t.MASK_Member);
                  symCur != null;
-                 symCur = SymbolLoader.LookupNextSym(symCur, typeCur.OwningAggregate, symbmask_t.MASK_ALL))
+                 symCur = SymbolLoader.LookupNextSym(symCur, typeCur.OwningAggregate, symbmask_t.MASK_Member))
             {
+                Debug.Assert(!(symCur is AggregateSymbol));
                 // Check for arity.
-                switch (symCur.getKind())
+                // For non-zero arity, only methods of the correct arity are considered.
+                // For zero arity, don't filter out any methods since we do type argument
+                // inferencing.
+                // All others are only considered when arity is zero.
+                if (_arity > 0 && (!(symCur is MethodSymbol curMeth) || curMeth.typeVars.Count != _arity))
                 {
-                    case SYMKIND.SK_MethodSymbol:
-                        // For non-zero arity, only methods of the correct arity are considered.
-                        // For zero arity, don't filter out any methods since we do type argument
-                        // inferencing.
-                        if (_arity > 0 && ((MethodSymbol)symCur).typeVars.Count != _arity)
-                        {
-                            if (!_swtBadArity)
-                                _swtBadArity.Set(symCur, typeCur);
-                            continue;
-                        }
-                        break;
-
-                    case SYMKIND.SK_AggregateSymbol:
-                        // For types, always filter on arity.
-                        if (((AggregateSymbol)symCur).GetTypeVars().Count != _arity)
-                        {
-                            if (!_swtBadArity)
-                                _swtBadArity.Set(symCur, typeCur);
-                            continue;
-                        }
-                        break;
+                    if (!_swtBadArity)
+                    {
+                        _swtBadArity.Set(symCur, typeCur);
+                    }
 
-                    default:
-                        // All others are only considered when arity is zero.
-                        if (_arity > 0)
-                        {
-                            if (!_swtBadArity)
-                                _swtBadArity.Set(symCur, typeCur);
-                            continue;
-                        }
-                        break;
+                    continue;
                 }
 
                 // Check for user callability.
@@ -672,23 +652,15 @@ public Exception ReportErrors()
 
             if (_swtBadArity)
             {
-                int cvar;
-
-                switch (_swtBadArity.Sym.getKind())
+                Debug.Assert(_arity != 0);
+                Debug.Assert(!(_swtBadArity.Sym is AggregateSymbol));
+                if (_swtBadArity.Sym is MethodSymbol badMeth)
                 {
-                    case SYMKIND.SK_MethodSymbol:
-                        Debug.Assert(_arity != 0);
-                        cvar = ((MethodSymbol)_swtBadArity.Sym).typeVars.Count;
-                        return GetErrorContext().Error(cvar > 0 ? ErrorCode.ERR_BadArity : ErrorCode.ERR_HasNoTypeVars, _swtBadArity, new ErrArgSymKind(_swtBadArity.Sym), cvar);
-
-                    case SYMKIND.SK_AggregateSymbol:
-                        cvar = ((AggregateSymbol)_swtBadArity.Sym).GetTypeVars().Count;
-                        return GetErrorContext().Error(cvar > 0 ? ErrorCode.ERR_BadArity : ErrorCode.ERR_HasNoTypeVars, _swtBadArity, new ErrArgSymKind(_swtBadArity.Sym), cvar);
-
-                    default:
-                        Debug.Assert(_arity != 0);
-                        return GetErrorContext().Error(ErrorCode.ERR_TypeArgsNotAllowed, _swtBadArity, new ErrArgSymKind(_swtBadArity.Sym));
+                    int cvar = badMeth.typeVars.Count;
+                    return GetErrorContext().Error(cvar > 0 ? ErrorCode.ERR_BadArity : ErrorCode.ERR_HasNoTypeVars, _swtBadArity, new ErrArgSymKind(_swtBadArity.Sym), cvar);
                 }
+
+                return GetErrorContext().Error(ErrorCode.ERR_TypeArgsNotAllowed, _swtBadArity, new ErrArgSymKind(_swtBadArity.Sym));
             }
 
             return GetErrorContext().Error(ErrorCode.ERR_NoSuchMember, _typeSrc, _name);

src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Symbols/SymbolMask.cs

@@ -17,5 +17,6 @@ internal enum symbmask_t : long
         MASK_PropertySymbol = 1 << SYMKIND.SK_PropertySymbol,
         MASK_EventSymbol = 1 << SYMKIND.SK_EventSymbol,
         MASK_ALL = ~0,
+        MASK_Member = MASK_FieldSymbol | MASK_MethodSymbol | MASK_PropertySymbol | MASK_EventSymbol
     }
 }

src/Microsoft.CSharp/tests/BindingErrors.cs

@@ -428,6 +428,93 @@ public void CannotInferTypeArgument()
             Assert.Throws<RuntimeBinderException>(() => DoStuff(d));
         }
 
+        public class Outer
+        {
+            public class Inner
+            {
+                public void DoNothing()
+                {
+                }
+            }
+        }
+
+        [Fact]
+        public void TryInvokeOrAccessNestedClassAsMember()
+        {
+            dynamic dFirst = new Outer.Inner();
+            dFirst.DoNothing();
+            dynamic d = new Outer();
+            Assert.Throws<RuntimeBinderException>(() => d.Inner<int>());
+            Assert.Throws<RuntimeBinderException>(() => d.Inner());
+            Assert.Throws<RuntimeBinderException>(() => d.Inner = 2);
+            Assert.Throws<RuntimeBinderException>(
+                () =>
+                {
+                    int i = d.Inner<int>();
+                });
+        }
+
+        [Fact]
+        public void TryInvokeTypeParameterAsMember()
+        {
+            dynamic d = new List<int>();
+            Assert.Throws<RuntimeBinderException>(() => d.T);
+            Assert.Throws<RuntimeBinderException>(() => d.T());
+            Assert.Throws<RuntimeBinderException>(() => d.T<int>());
+            Assert.Throws<RuntimeBinderException>(() =>
+            {
+                int i = d.T;
+            });
+        }
+
+        public class BaseForOuterWithMethod
+        {
+            public int Inner() => 42;
+        }
+
+        public class DerivedOuterHidingMethod : BaseForOuterWithMethod
+        {
+            public new class Inner
+            {
+                public void DoNothing()
+                {
+                }
+            }
+        }
+
+        [Fact]
+        public void AccessMethodHiddenByNested()
+        {
+            dynamic dFirst = new DerivedOuterHidingMethod.Inner();
+            dFirst.DoNothing();
+            dynamic d = new DerivedOuterHidingMethod();
+            Assert.Equal(42, d.Inner());
+        }
+
+        public class BaseForOuterWithNested
+        {
+            public class Inner
+            {
+                public void DoNothing()
+                {
+                }
+            }
+        }
+
+        public class DerivedOuterHidingNested : BaseForOuterWithNested
+        {
+            public new int Inner() => 42;
+        }
+
+        [Fact]
+        public void AccessMethodHidingNested()
+        {
+            dynamic dFirst = new BaseForOuterWithNested.Inner();
+            dFirst.DoNothing();
+            dynamic d = new DerivedOuterHidingNested();
+            Assert.Equal(42, d.Inner());
+		}
+
         [Fact]
         public void CannotCallOperatorDirectly()
         {