// RUNTIME BINDER ONLY CHANGE
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
- internal bool GetBestAccessibleType(CSemanticChecker semanticChecker, BindingContext bindingContext, CType typeSrc, out CType typeDst)
+ internal CType GetBestAccessibleType(CSemanticChecker semanticChecker, AggregateDeclaration context, CType typeSrc)
{
// This method implements the "best accessible type" algorithm for determining the type
// of untyped arguments in the runtime binder. It is also used in method type inference
// non-null) only when the algorithm could find a suitable accessible type.
Debug.Assert(semanticChecker != null);
- Debug.Assert(bindingContext != null);
Debug.Assert(typeSrc != null);
+ Debug.Assert(!(typeSrc is ParameterModifierType));
+ Debug.Assert(!(typeSrc is PointerType));
- typeDst = null;
-
- if (semanticChecker.CheckTypeAccess(typeSrc, bindingContext.ContextForMemberLookup))
+ if (semanticChecker.CheckTypeAccess(typeSrc, context))
{
- // If we already have an accessible type, then use it. This is the terminal point of the recursion.
- typeDst = typeSrc;
- return true;
+ // If we already have an accessible type, then use it.
+ return typeSrc;
}
// These guys have no accessibility concerns.
Debug.Assert(!(typeSrc is VoidType) && !(typeSrc is TypeParameterType));
- if (typeSrc is ParameterModifierType || typeSrc is PointerType)
- {
- // We cannot vary these.
- return false;
- }
-
- CType intermediateType;
- if (typeSrc is AggregateType aggSrc && (aggSrc.IsInterfaceType || aggSrc.IsDelegateType) && TryVarianceAdjustmentToGetAccessibleType(semanticChecker, bindingContext, aggSrc, out intermediateType))
+ if (typeSrc is AggregateType aggSrc)
{
- // If we have an interface or delegate type, then it can potentially be varied by its type arguments
- // to produce an accessible type, and if that's the case, then return that.
- // Example: IEnumerable<PrivateConcreteFoo> --> IEnumerable<PublicAbstractFoo>
- typeDst = intermediateType;
+ for (;;)
+ {
+ if ((aggSrc.IsInterfaceType || aggSrc.IsDelegateType) && TryVarianceAdjustmentToGetAccessibleType(semanticChecker, context, aggSrc, out CType typeDst))
+ {
+ // If we have an interface or delegate type, then it can potentially be varied by its type arguments
+ // to produce an accessible type, and if that's the case, then return that.
+ // Example: IEnumerable<PrivateConcreteFoo> --> IEnumerable<PublicAbstractFoo>
+ Debug.Assert(semanticChecker.CheckTypeAccess(typeDst, context));
+ return typeDst;
+ }
- Debug.Assert(semanticChecker.CheckTypeAccess(typeDst, bindingContext.ContextForMemberLookup));
- return true;
- }
+ // We have an AggregateType, so recurse on its base class.
+ AggregateType baseType = aggSrc.BaseClass;
+ if (baseType == null)
+ {
+ // This happens with interfaces, for instance. But in that case, the
+ // conversion to object does exist, is an implicit reference conversion,
+ // and is guaranteed to be accessible, so we will use it.
+ return GetPredefAgg(PredefinedType.PT_OBJECT).getThisType();
+ }
- if (typeSrc is ArrayType arrSrc && TryArrayVarianceAdjustmentToGetAccessibleType(semanticChecker, bindingContext, arrSrc, out intermediateType))
- {
- // Similarly to the interface and delegate case, arrays are covariant in their element type and
- // so we can potentially produce an array type that is accessible.
- // Example: PrivateConcreteFoo[] --> PublicAbstractFoo[]
- typeDst = intermediateType;
+ if (semanticChecker.CheckTypeAccess(baseType, context))
+ {
+ return baseType;
+ }
- Debug.Assert(semanticChecker.CheckTypeAccess(typeDst, bindingContext.ContextForMemberLookup));
- return true;
+ // baseType is always an AggregateType, so no need for logic of other types.
+ aggSrc = baseType;
+ }
}
- if (typeSrc is NullableType)
+ if (typeSrc is ArrayType arrSrc)
{
- // We have an inaccessible nullable type, which means that the best we can do is System.ValueType.
- typeDst = GetPredefAgg(PredefinedType.PT_VALUE).getThisType();
-
- Debug.Assert(semanticChecker.CheckTypeAccess(typeDst, bindingContext.ContextForMemberLookup));
- return true;
- }
+ if (TryArrayVarianceAdjustmentToGetAccessibleType(semanticChecker, context, arrSrc, out CType typeDst))
+ {
+ // Similarly to the interface and delegate case, arrays are covariant in their element type and
+ // so we can potentially produce an array type that is accessible.
+ // Example: PrivateConcreteFoo[] --> PublicAbstractFoo[]
+ Debug.Assert(semanticChecker.CheckTypeAccess(typeDst, context));
+ return typeDst;
+ }
- if (typeSrc is ArrayType)
- {
// We have an inaccessible array type for which we could not earlier find a better array type
// with a covariant conversion, so the best we can do is System.Array.
- typeDst = GetPredefAgg(PredefinedType.PT_ARRAY).getThisType();
-
- Debug.Assert(semanticChecker.CheckTypeAccess(typeDst, bindingContext.ContextForMemberLookup));
- return true;
+ return GetPredefAgg(PredefinedType.PT_ARRAY).getThisType();
}
- Debug.Assert(typeSrc is AggregateType);
-
- if (typeSrc is AggregateType aggType)
- {
- // We have an AggregateType, so recurse on its base class.
- AggregateType baseType = aggType.BaseClass;
-
- if (baseType == null)
- {
- // This happens with interfaces, for instance. But in that case, the
- // conversion to object does exist, is an implicit reference conversion,
- // and so we will use it.
- baseType = GetPredefAgg(PredefinedType.PT_OBJECT).getThisType();
- }
+ Debug.Assert(typeSrc is NullableType);
- return GetBestAccessibleType(semanticChecker, bindingContext, baseType, out typeDst);
- }
-
- return false;
+ // We have an inaccessible nullable type, which means that the best we can do is System.ValueType.
+ return GetPredefAgg(PredefinedType.PT_VALUE).getThisType();
}
- private bool TryVarianceAdjustmentToGetAccessibleType(CSemanticChecker semanticChecker, BindingContext bindingContext, AggregateType typeSrc, out CType typeDst)
+ private bool TryVarianceAdjustmentToGetAccessibleType(CSemanticChecker semanticChecker, AggregateDeclaration context, AggregateType typeSrc, out CType typeDst)
{
Debug.Assert(typeSrc != null);
Debug.Assert(typeSrc.IsInterfaceType || typeSrc.IsDelegateType);
AggregateSymbol aggSym = typeSrc.OwningAggregate;
AggregateType aggOpenType = aggSym.getThisType();
- if (!semanticChecker.CheckTypeAccess(aggOpenType, bindingContext.ContextForMemberLookup))
+ if (!semanticChecker.CheckTypeAccess(aggOpenType, context))
{
// if the aggregate symbol itself is not accessible, then forget it, there is no
// variance that will help us arrive at an accessible type.
TypeArray typeParams = aggOpenType.TypeArgsThis;
CType[] newTypeArgsTemp = new CType[typeArgs.Count];
- for (int i = 0; i < typeArgs.Count; i++)
+ for (int i = 0; i < newTypeArgsTemp.Length; i++)
{
- if (semanticChecker.CheckTypeAccess(typeArgs[i], bindingContext.ContextForMemberLookup))
+ CType typeArg = typeArgs[i];
+ if (semanticChecker.CheckTypeAccess(typeArg, context))
{
// we have an accessible argument, this position is not a problem.
- newTypeArgsTemp[i] = typeArgs[i];
+ newTypeArgsTemp[i] = typeArg;
continue;
}
- if (!typeArgs[i].IsReferenceType || !((TypeParameterType)typeParams[i]).Covariant)
+ if (!typeArg.IsReferenceType || !((TypeParameterType)typeParams[i]).Covariant)
{
// This guy is inaccessible, and we are not going to be able to vary him, so we need to fail.
return false;
}
- CType intermediateTypeArg;
- if (GetBestAccessibleType(semanticChecker, bindingContext, typeArgs[i], out intermediateTypeArg))
- {
- // now we either have a value type (which must be accessible due to the above
- // check, OR we have an inaccessible type (which must be a ref type). In either
- // case, the recursion worked out and we are OK to vary this argument.
- newTypeArgsTemp[i] = intermediateTypeArg;
- continue;
- }
- else
- {
- Debug.Assert(false, "GetBestAccessibleType unexpectedly failed on a type that was used as a type parameter");
- return false;
- }
+ newTypeArgsTemp[i] = GetBestAccessibleType(semanticChecker, context, typeArg);
+
+ // now we either have a value type (which must be accessible due to the above
+ // check, OR we have an inaccessible type (which must be a ref type). In either
+ // case, the recursion worked out and we are OK to vary this argument.
}
TypeArray newTypeArgs = semanticChecker.getBSymmgr().AllocParams(typeArgs.Count, newTypeArgsTemp);
- CType intermediateType = this.GetAggregate(aggSym, typeSrc.OuterType, newTypeArgs);
+ CType intermediateType = GetAggregate(aggSym, typeSrc.OuterType, newTypeArgs);
// All type arguments were varied successfully, which means now we must be accessible. But we could
// have violated constraints. Let's check that out.
- if (!TypeBind.CheckConstraints(semanticChecker, null/*ErrorHandling*/, intermediateType, CheckConstraintsFlags.NoErrors))
+ if (!TypeBind.CheckConstraints(semanticChecker, errHandling: null, intermediateType, CheckConstraintsFlags.NoErrors))
{
return false;
}
typeDst = intermediateType;
- Debug.Assert(semanticChecker.CheckTypeAccess(typeDst, bindingContext.ContextForMemberLookup));
+ Debug.Assert(semanticChecker.CheckTypeAccess(typeDst, context));
return true;
}
- private bool TryArrayVarianceAdjustmentToGetAccessibleType(CSemanticChecker semanticChecker, BindingContext bindingContext, ArrayType typeSrc, out CType typeDst)
+ private bool TryArrayVarianceAdjustmentToGetAccessibleType(CSemanticChecker semanticChecker, AggregateDeclaration context, ArrayType typeSrc, out CType typeDst)
{
Debug.Assert(typeSrc != null);
- typeDst = null;
-
// We are here because we have an array type with an inaccessible element type. If possible,
// we should create a new array type that has an accessible element type for which a
// conversion exists.
CType elementType = typeSrc.ElementType;
- if (!elementType.IsReferenceType)
- {
- // Covariant array conversions exist for reference types only.
- return false;
- }
-
- if (GetBestAccessibleType(semanticChecker, bindingContext, elementType, out CType intermediateType))
+ // Covariant array conversions exist for reference types only.
+ if (elementType.IsReferenceType)
{
- typeDst = GetArray(intermediateType, typeSrc.Rank, typeSrc.IsSZArray);
+ CType destElement = GetBestAccessibleType(semanticChecker, context, elementType);
+ typeDst = GetArray(destElement, typeSrc.Rank, typeSrc.IsSZArray);
- Debug.Assert(semanticChecker.CheckTypeAccess(typeDst, bindingContext.ContextForMemberLookup));
+ Debug.Assert(semanticChecker.CheckTypeAccess(typeDst, context));
return true;
}
+ typeDst = null;
return false;
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Xunit;
+
+namespace Microsoft.CSharp.RuntimeBinder.Tests
+{
+ public partial class AccessTests
+ {
+ public abstract class PublicReferenceType
+ {
+ public abstract int IntValueProperty { get; }
+ }
+
+ public interface ITestIFace
+ {
+ }
+
+ public interface ITestIFaceCons<out T> where T : ITestIFace
+ {
+ }
+
+ private static class Container
+ {
+ private abstract class ReferenceTypeIntermediary : PublicReferenceType
+ {
+ }
+
+ private class ReferenceType : ReferenceTypeIntermediary, ITestIFace
+ {
+ public override int IntValueProperty => 23;
+ }
+
+ private struct PrivateValueType
+ {
+ }
+
+ private interface IPrivateInterface
+ {
+ }
+
+ public static dynamic GetReferenceType() => new ReferenceType();
+
+ public static dynamic TenReferenceTypesArray() => new ReferenceType[10];
+
+ public static dynamic TenReferenceTypesRepeat() => Enumerable.Repeat(new ReferenceType(), 10);
+
+ public static dynamic ReferenceTypeDelegate() =>
+ (Func<int, IEnumerable<ReferenceType>>)(i => Enumerable.Repeat(new ReferenceType(), i));
+
+ public static dynamic ValueTypeArray() => new PrivateValueType[2];
+
+ private delegate int PrivateFunc<T>(T arg);
+
+ public static dynamic PrivateDelegateType() => (PrivateFunc<ReferenceType>)(r => r.IntValueProperty);
+
+ public static dynamic ValueTypeDelegate() => (Func<PrivateValueType>)(() => new PrivateValueType());
+
+ public unsafe static dynamic PointerArray() => new PrivateValueType*[4];
+
+ public static dynamic PrivateInterfaceDelegate() => (Func<IPrivateInterface>)(() => null);
+
+ public static dynamic PrivateConstraintInterfaceDelegate() => (Func<ITestIFaceCons<ReferenceType>>)(() => null);
+ }
+
+ [Fact]
+ public void CanGetAccessibleBaseOfInaccessibleType() => Assert.Equal(23, Container.GetReferenceType().IntValueProperty);
+
+ [Fact]
+ public void AccessibleArray() => Assert.Equal(10, Enumerable.Count(Container.TenReferenceTypesArray()));
+
+ [Fact]
+ public void AccessibleInterface() => Assert.Equal(10, Enumerable.Count(Container.TenReferenceTypesRepeat()));
+
+ [Fact]
+ public void AccessCovariantDelegate()
+ {
+ IEnumerable<PublicReferenceType> prts = Container.ReferenceTypeDelegate()(4);
+ Assert.Equal(4, prts.Count());
+ foreach (PublicReferenceType prt in prts)
+ {
+ Assert.Equal(23, prt.IntValueProperty);
+ }
+ }
+
+ [Fact]
+ public void NonCovariantArrayToArrayType() => Assert.Equal(2, Container.ValueTypeArray().Length);
+
+ [Fact]
+ public void NonCovariantArrayNotCastToIndexableType()
+ {
+ dynamic array = Container.ValueTypeArray();
+ Assert.Throws<RuntimeBinderException>(() => array[0]);
+ }
+
+ [Fact]
+ public void PointerArrayToArrayType() => Assert.Equal(4, Container.PointerArray().Length);
+
+ [Fact]
+ public void PointerArrayNotCastToIndexableType()
+ {
+ dynamic array = Container.PointerArray();
+ Assert.Throws<RuntimeBinderException>(() => array[0]);
+ }
+
+ [Fact]
+ public void PrivateDelegateType()
+ {
+ dynamic d = Container.PrivateDelegateType();
+ dynamic a = Container.GetReferenceType();
+ Assert.Throws<RuntimeBinderException>(() => d(a));
+ d.DynamicInvoke(a); // Can use as MulticastDelegate.
+ }
+
+ [Fact]
+ public void PrivateValueTypeDelegateType()
+ {
+ dynamic d = Container.ValueTypeDelegate();
+ Assert.Throws<RuntimeBinderException>(() => d());
+ ValueType result = d.DynamicInvoke(); // Can use as MulticastDelegate.
+ }
+
+ [Fact]
+ public void PrivateIFaceDelegateType()
+ {
+ dynamic d = Container.PrivateInterfaceDelegate();
+ Assert.Null(d());
+ }
+
+ [Fact]
+ public void PrivateInterfaceConstraint()
+ {
+ // Casting Func<ITestIFaceCons<ReferenceType>> to Func<ITestIFaceCons<PublicReferenceType>>
+ // would be illegal because ITestIFaceCons<PublicReferenceType> violates the ITestIFaceCons
+ // constraints, so the binder has to detect that, and cast to Func<object>.
+ dynamic d = Container.PrivateConstraintInterfaceDelegate();
+ Assert.Null(d());
+ }
+
+ private struct SomeValueType
+ {
+ public override string ToString() => "test";
+ }
+
+ [Fact]
+ public void NullableOfInaccessible()
+ {
+ // ValueType members work without access to the type.
+ CallSite<Func<CallSite, SomeValueType?, object>> site =
+ CallSite<Func<CallSite, SomeValueType?, object>>.Create(
+ Binder.InvokeMember(
+ CSharpBinderFlags.None, "ToString", null, null,
+ new[]
+ {
+ CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
+ }));
+ Func<CallSite, SomeValueType?, object> target = site.Target;
+ Assert.Equal("test", target(site, new SomeValueType()));
+
+ // Nullable<T> members work with access to the type.
+ site = CallSite<Func<CallSite, SomeValueType?, object>>.Create(
+ Binder.InvokeMember(
+ CSharpBinderFlags.None, "GetValueOrDefault", null, GetType(),
+ new[]
+ {
+ CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
+ }));
+ target = site.Target;
+ Assert.Equal(new SomeValueType(), target(site, new SomeValueType()));
+
+ // Nullable<T> members don't work without access to the type.
+ site = CallSite<Func<CallSite, SomeValueType?, object>>.Create(
+ Binder.InvokeMember(
+ CSharpBinderFlags.None, "GetValueOrDefault", null, null,
+ new[]
+ {
+ CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
+ }));
+ target = site.Target;
+ Assert.Throws<RuntimeBinderException>(() => target(site, new SomeValueType()));
+ }
+ }
+}
projects / platform / upstream / dotnet / runtime.git / commitdiff