// It would be nice to make this a virtual method on typeSym.
public AggregateType GetAggTypeSym(CType typeSym)
{
Debug.Assert(typeSym != null);
Debug.Assert(typeSym.IsAggregateType() ||
typeSym.IsTypeParameterType() ||
typeSym.IsArrayType() ||
typeSym.IsNullableType());
switch (typeSym.GetTypeKind())
{
case TypeKind.TK_AggregateType:
return(typeSym.AsAggregateType());
case TypeKind.TK_ArrayType:
return(GetReqPredefType(PredefinedType.PT_ARRAY));
case TypeKind.TK_TypeParameterType:
return(typeSym.AsTypeParameterType().GetEffectiveBaseClass());
case TypeKind.TK_NullableType:
return(typeSym.AsNullableType().GetAts(ErrorContext));
}
Debug.Assert(false, "Bad typeSym!");
return(null);
}
////////////////////////////////////////////////////////////////////////////////
// Determine whether the arg type satisfies the typeBnd constraint. Note that
// typeBnd could be just about any type (since we added naked type parameter
// constraints).
private static bool SatisfiesBound(CSemanticChecker checker, CType arg, CType typeBnd)
{
if (typeBnd == arg)
{
return(true);
}
switch (typeBnd.GetTypeKind())
{
default:
Debug.Assert(false, "Unexpected type.");
return(false);
case TypeKind.TK_VoidType:
case TypeKind.TK_PointerType:
case TypeKind.TK_ErrorType:
return(false);
case TypeKind.TK_ArrayType:
case TypeKind.TK_TypeParameterType:
break;
case TypeKind.TK_NullableType:
typeBnd = typeBnd.AsNullableType().GetAts(checker.GetErrorContext());
if (null == typeBnd)
{
return(true);
}
break;
case TypeKind.TK_AggregateType:
break;
}
Debug.Assert(typeBnd.IsAggregateType() || typeBnd.IsTypeParameterType() || typeBnd.IsArrayType());
switch (arg.GetTypeKind())
{
default:
return(false);
case TypeKind.TK_ErrorType:
case TypeKind.TK_PointerType:
return(false);
case TypeKind.TK_NullableType:
arg = arg.AsNullableType().GetAts(checker.GetErrorContext());
if (null == arg)
{
return(true);
}
// Fall through.
goto case TypeKind.TK_TypeParameterType;
case TypeKind.TK_TypeParameterType:
case TypeKind.TK_ArrayType:
case TypeKind.TK_AggregateType:
return(checker.GetSymbolLoader().HasBaseConversion(arg, typeBnd));
}
}
public bool DependsOn(TypeParameterType pType)
{
Debug.Assert(pType != null);
// * If a type parameter T is used as a constraint for type parameter S
// then S depends on T.
// * If a type parameter S depends on a type parameter T and T depends on
// U then S depends on U.
TypeArray pConstraints = GetBounds();
for (int iConstraint = 0; iConstraint < pConstraints.Count; ++iConstraint)
{
CType pConstraint = pConstraints[iConstraint];
if (pConstraint == pType)
{
return(true);
}
if (pConstraint.IsTypeParameterType() &&
pConstraint.AsTypeParameterType().DependsOn(pType))
{
return(true);
}
}
return(false);
}
public virtual bool CheckTypeAccess(CType type, Symbol symWhere)
{
Debug.Assert(type != null);
// Array, Ptr, Nub, etc don't matter.
type = type.GetNakedType(true);
if (!type.IsAggregateType())
{
Debug.Assert(type.IsVoidType() || type.IsErrorType() || type.IsTypeParameterType());
return(true);
}
for (AggregateType ats = type.AsAggregateType(); ats != null; ats = ats.outerType)
{
if (ACCESSERROR.ACCESSERROR_NOERROR != CheckAccessCore(ats.GetOwningAggregate(), ats.outerType, symWhere, null))
{
return(false);
}
}
TypeArray typeArgs = type.AsAggregateType().GetTypeArgsAll();
for (int i = 0; i < typeArgs.size; i++)
{
if (!CheckTypeAccess(typeArgs.Item(i), symWhere))
{
return(false);
}
}
return(true);
}
public virtual ACCESSERROR CheckAccess2(Symbol symCheck, AggregateType atsCheck, Symbol symWhere, CType typeThru)
{
Debug.Assert(symCheck != null);
Debug.Assert(atsCheck == null || symCheck.parent == atsCheck.getAggregate());
Debug.Assert(typeThru == null ||
typeThru.IsAggregateType() ||
typeThru.IsTypeParameterType() ||
typeThru.IsArrayType() ||
typeThru.IsNullableType() ||
typeThru.IsErrorType());
#if DEBUG
switch (symCheck.getKind())
{
default:
break;
case SYMKIND.SK_MethodSymbol:
case SYMKIND.SK_PropertySymbol:
case SYMKIND.SK_FieldSymbol:
case SYMKIND.SK_EventSymbol:
Debug.Assert(atsCheck != null);
break;
}
#endif // DEBUG
ACCESSERROR error = CheckAccessCore(symCheck, atsCheck, symWhere, typeThru);
if (ACCESSERROR.ACCESSERROR_NOERROR != error)
{
return error;
}
// Check the accessibility of the return CType.
CType CType = symCheck.getType();
if (CType == null)
{
return ACCESSERROR.ACCESSERROR_NOERROR;
}
// For members of AGGSYMs, atsCheck should always be specified!
Debug.Assert(atsCheck != null);
if (atsCheck.getAggregate().IsSource())
{
// We already check the "at least as accessible as" rules.
// Does this always work for generics?
// Could we get a bad CType argument in typeThru?
// Maybe call CheckTypeAccess on typeThru?
return ACCESSERROR.ACCESSERROR_NOERROR;
}
// Substitute on the CType.
if (atsCheck.GetTypeArgsAll().size > 0)
{
CType = SymbolLoader.GetTypeManager().SubstType(CType, atsCheck);
}
return CheckTypeAccess(CType, symWhere) ? ACCESSERROR.ACCESSERROR_NOERROR : ACCESSERROR.ACCESSERROR_NOACCESS;
}
public virtual ACCESSERROR CheckAccess2(Symbol symCheck, AggregateType atsCheck, Symbol symWhere, CType typeThru)
{
Debug.Assert(symCheck != null);
Debug.Assert(atsCheck == null || symCheck.parent == atsCheck.getAggregate());
Debug.Assert(typeThru == null ||
typeThru.IsAggregateType() ||
typeThru.IsTypeParameterType() ||
typeThru.IsArrayType() ||
typeThru.IsNullableType() ||
typeThru.IsErrorType());
#if DEBUG
switch (symCheck.getKind())
{
default:
break;
case SYMKIND.SK_MethodSymbol:
case SYMKIND.SK_PropertySymbol:
case SYMKIND.SK_FieldSymbol:
case SYMKIND.SK_EventSymbol:
Debug.Assert(atsCheck != null);
break;
}
#endif // DEBUG
ACCESSERROR error = CheckAccessCore(symCheck, atsCheck, symWhere, typeThru);
if (ACCESSERROR.ACCESSERROR_NOERROR != error)
{
return(error);
}
// Check the accessibility of the return CType.
CType CType = symCheck.getType();
if (CType == null)
{
return(ACCESSERROR.ACCESSERROR_NOERROR);
}
// For members of AGGSYMs, atsCheck should always be specified!
Debug.Assert(atsCheck != null);
if (atsCheck.getAggregate().IsSource())
{
// We already check the "at least as accessible as" rules.
// Does this always work for generics?
// Could we get a bad CType argument in typeThru?
// Maybe call CheckTypeAccess on typeThru?
return(ACCESSERROR.ACCESSERROR_NOERROR);
}
// Substitute on the CType.
if (atsCheck.GetTypeArgsAll().size > 0)
{
CType = SymbolLoader.GetTypeManager().SubstType(CType, atsCheck);
}
return(CheckTypeAccess(CType, symWhere) ? ACCESSERROR.ACCESSERROR_NOERROR : ACCESSERROR.ACCESSERROR_NOACCESS);
}
private bool bindExplicitConversionToTypeVar()
{
// 13.2.3 Explicit reference conversions
//
// For a type-parameter T that is known to be a reference type (25.7), the following
// explicit reference conversions exist:
//
// * From the effective base class C of T to T and from any base class of C to T.
// * From any interface-type to T.
// * From a type-parameter U to T provided that T depends on U (25.7).
Debug.Assert(_typeSrc != null);
Debug.Assert(_typeDest != null);
// NOTE: for the flags, we have to use EXPRFLAG.EXF_FORCE_UNBOX (not EXPRFLAG.EXF_REFCHECK) even when
// we know that the type is a reference type. The verifier expects all code for
// type parameters to behave as if the type parameter is a value type.
// The jitter should be smart about it....
if (_typeSrc.isInterfaceType() || _binder.canConvert(_typeDest, _typeSrc, CONVERTTYPE.NOUDC))
{
if (!_needsExprDest)
{
return(true);
}
// There is an explicit, possibly unboxing, conversion from Object or any interface to
// a type variable. This will involve a type check and possibly an unbox.
// There is an explicit conversion from non-interface X to the type var iff there is an
// implicit conversion from the type var to X.
if (_typeSrc.IsTypeParameterType())
{
// Need to box first before unboxing.
Expr exprT;
ExprClass exprObj = GetExprFactory().MakeClass(_binder.GetReqPDT(PredefinedType.PT_OBJECT));
_binder.bindSimpleCast(_exprSrc, exprObj, out exprT, EXPRFLAG.EXF_FORCE_BOX);
_exprSrc = exprT;
}
if (_needsExprDest)
{
_binder.bindSimpleCast(_exprSrc, _exprTypeDest, out _exprDest, EXPRFLAG.EXF_FORCE_UNBOX);
}
return(true);
}
return(false);
}
public bool HasBaseConversion(CType pSource, CType pDest)
{
// By a "base conversion" we mean:
//
// * an identity conversion
// * an implicit reference conversion
// * an implicit boxing conversion
// * an implicit type parameter conversion
//
// In other words, these are conversions that can be made to a base
// class, base interface or co/contravariant type without any change in
// representation other than boxing. A conversion from, say, int to double,
// is NOT a "base conversion", because representation is changed. A conversion
// from, say, lambda to expression tree is not a "base conversion" because
// do not have a type.
//
// The existence of a base conversion depends solely upon the source and
// destination types, not the source expression.
//
// This notion is not found in the spec but it is useful in the implementation.
if (pSource.IsAggregateType() && pDest.isPredefType(PredefinedType.PT_OBJECT))
{
// If we are going from any aggregate type (class, struct, interface, enum or delegate)
// to object, we immediately return true. This may seem like a mere optimization --
// after all, if we have an aggregate then we have some kind of implicit conversion
// to object.
//
// However, it is not a mere optimization; this introduces a control flow change
// in error reporting scenarios for unresolved type forwarders. If a type forwarder
// cannot be resolved then the resulting type symbol will be an aggregate, but
// we will not be able to classify it into class, struct, etc.
//
// We know that we will have an error in this case; we do not wish to compound
// that error by giving a spurious "you cannot convert this thing to object"
// error, which, after all, will go away when the type forwarding problem is
// fixed.
return(true);
}
if (HasIdentityOrImplicitReferenceConversion(pSource, pDest))
{
return(true);
}
if (HasImplicitBoxingConversion(pSource, pDest))
{
return(true);
}
if (pSource.IsTypeParameterType() &&
HasImplicitTypeParameterBaseConversion(pSource.AsTypeParameterType(), pDest))
{
return(true);
}
return(false);
}
private bool HasImplicitReferenceTypeParameterConversion(
TypeParameterType pSource, CType pDest)
{
Debug.Assert(pSource != null);
Debug.Assert(pDest != null);
if (!pSource.IsRefType())
{
// Not a reference conversion.
return(false);
}
// The following implicit conversions exist for a given type parameter T:
//
// * From T to its effective base class C.
AggregateType pEBC = pSource.GetEffectiveBaseClass();
if (pDest == pEBC)
{
return(true);
}
// * From T to any base class of C.
if (IsBaseClass(pEBC, pDest))
{
return(true);
}
// * From T to any interface implemented by C.
if (IsBaseInterface(pEBC, pDest))
{
return(true);
}
// * From T to any interface type I in T's effective interface set, and
// from T to any base interface of I.
TypeArray pInterfaces = pSource.GetInterfaceBounds();
for (int i = 0; i < pInterfaces.Count; ++i)
{
if (pInterfaces[i] == pDest)
{
return(true);
}
}
// * From T to a type parameter U, provided T depends on U.
if (pDest.IsTypeParameterType() && pSource.DependsOn(pDest.AsTypeParameterType()))
{
return(true);
}
return(false);
}
public bool HasImplicitBoxingConversion(CType pSource, CType pDest)
{
Debug.Assert(pSource != null);
Debug.Assert(pDest != null);
// Certain type parameter conversions are classified as boxing conversions.
if (pSource.IsTypeParameterType() &&
HasImplicitBoxingTypeParameterConversion(pSource.AsTypeParameterType(), pDest))
{
return(true);
}
// The rest of the boxing conversions only operate when going from a value type
// to a reference type.
if (!pSource.IsValType() || !pDest.IsRefType())
{
return(false);
}
// A boxing conversion exists from a nullable type to a reference type
// if and only if a boxing conversion exists from the underlying type.
if (pSource.IsNullableType())
{
return(HasImplicitBoxingConversion(pSource.AsNullableType().GetUnderlyingType(), pDest));
}
// A boxing conversion exists from any non-nullable value type to object,
// to System.ValueType, and to any interface type implemented by the
// non-nullable value type. Furthermore, an enum type can be converted
// to the type System.Enum.
// We set the base class of the structs to System.ValueType, System.Enum, etc,
// so we can just check here.
if (IsBaseClass(pSource, pDest))
{
return(true);
}
if (HasAnyBaseInterfaceConversion(pSource, pDest))
{
return(true);
}
return(false);
}
private bool HasImplicitTypeParameterBaseConversion(
TypeParameterType pSource, CType pDest)
{
Debug.Assert(pSource != null);
Debug.Assert(pDest != null);
if (HasImplicitReferenceTypeParameterConversion(pSource, pDest))
{
return(true);
}
if (HasImplicitBoxingTypeParameterConversion(pSource, pDest))
{
return(true);
}
if (pDest.IsTypeParameterType() && pSource.DependsOn(pDest.AsTypeParameterType()))
{
return(true);
}
return(false);
}
public static IEnumerable <CType> AllPossibleInterfaces(this CType type)
{
Debug.Assert(type != null);
if (type.IsAggregateType())
{
foreach (CType t in type.AsAggregateType().TypeAndBaseClassInterfaces())
{
yield return(t);
}
}
else if (type.IsTypeParameterType())
{
foreach (CType t in type.AsTypeParameterType().GetEffectiveBaseClass().TypeAndBaseClassInterfaces())
{
yield return(t);
}
foreach (CType t in type.AsTypeParameterType().GetInterfaceBounds().AllConstraintInterfaces())
{
yield return(t);
}
}
}
public BetterType CompareTypes(TypeArray ta1, TypeArray ta2)
{
if (ta1 == ta2)
{
return(BetterType.Same);
}
if (ta1.Size != ta2.Size)
{
// The one with more parameters is more specific.
return(ta1.Size > ta2.Size ? BetterType.Left : BetterType.Right);
}
BetterType nTot = BetterType.Neither;
for (int i = 0; i < ta1.Size; i++)
{
CType type1 = ta1.Item(i);
CType type2 = ta2.Item(i);
BetterType nParam = BetterType.Neither;
LAgain:
if (type1.GetTypeKind() != type2.GetTypeKind())
{
if (type1.IsTypeParameterType())
{
nParam = BetterType.Right;
}
else if (type2.IsTypeParameterType())
{
nParam = BetterType.Left;
}
}
else
{
switch (type1.GetTypeKind())
{
default:
Debug.Assert(false, "Bad kind in CompareTypes");
break;
case TypeKind.TK_TypeParameterType:
case TypeKind.TK_ErrorType:
break;
case TypeKind.TK_PointerType:
case TypeKind.TK_ParameterModifierType:
case TypeKind.TK_ArrayType:
case TypeKind.TK_NullableType:
type1 = type1.GetBaseOrParameterOrElementType();
type2 = type2.GetBaseOrParameterOrElementType();
goto LAgain;
case TypeKind.TK_AggregateType:
nParam = CompareTypes(type1.AsAggregateType().GetTypeArgsAll(), type2.AsAggregateType().GetTypeArgsAll());
break;
}
}
if (nParam == BetterType.Right || nParam == BetterType.Left)
{
if (nTot == BetterType.Same || nTot == BetterType.Neither)
{
nTot = nParam;
}
else if (nParam != nTot)
{
return(BetterType.Neither);
}
}
}
return(nTot);
}
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// RUNTIME BINDER ONLY CHANGE
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
internal bool GetBestAccessibleType(CSemanticChecker semanticChecker, BindingContext bindingContext, CType typeSrc, out CType typeDst)
{
// 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
// to fix type arguments to types that are accessible.
// The new type is returned in an out parameter. The result will be true (and the out param
// non-null) only when the algorithm could find a suitable accessible type.
Debug.Assert(semanticChecker != null);
Debug.Assert(bindingContext != null);
Debug.Assert(typeSrc != null);
typeDst = null;
if (semanticChecker.CheckTypeAccess(typeSrc, bindingContext.ContextForMemberLookup()))
{
// If we already have an accessible type, then use it. This is the terminal point of the recursion.
typeDst = typeSrc;
return true;
}
// These guys have no accessibility concerns.
Debug.Assert(!typeSrc.IsVoidType() && !typeSrc.IsErrorType() && !typeSrc.IsTypeParameterType());
if (typeSrc.IsParameterModifierType() || typeSrc.IsPointerType())
{
// We cannot vary these.
return false;
}
CType intermediateType;
if ((typeSrc.isInterfaceType() || typeSrc.isDelegateType()) && TryVarianceAdjustmentToGetAccessibleType(semanticChecker, bindingContext, typeSrc.AsAggregateType(), out intermediateType))
{
// 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;
Debug.Assert(semanticChecker.CheckTypeAccess(typeDst, bindingContext.ContextForMemberLookup()));
return true;
}
if (typeSrc.IsArrayType() && TryArrayVarianceAdjustmentToGetAccessibleType(semanticChecker, bindingContext, typeSrc.AsArrayType(), 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;
Debug.Assert(semanticChecker.CheckTypeAccess(typeDst, bindingContext.ContextForMemberLookup()));
return true;
}
if (typeSrc.IsNullableType())
{
// We have an inaccessible nullable type, which means that the best we can do is System.ValueType.
typeDst = this.GetOptPredefAgg(PredefinedType.PT_VALUE).getThisType();
Debug.Assert(semanticChecker.CheckTypeAccess(typeDst, bindingContext.ContextForMemberLookup()));
return true;
}
if (typeSrc.IsArrayType())
{
// 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 = this.GetReqPredefAgg(PredefinedType.PT_ARRAY).getThisType();
Debug.Assert(semanticChecker.CheckTypeAccess(typeDst, bindingContext.ContextForMemberLookup()));
return true;
}
Debug.Assert(typeSrc.IsAggregateType());
if (typeSrc.IsAggregateType())
{
// We have an AggregateType, so recurse on its base class.
AggregateType aggType = typeSrc.AsAggregateType();
AggregateType baseType = aggType.GetBaseClass();
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 = this.GetReqPredefAgg(PredefinedType.PT_OBJECT).getThisType();
}
return GetBestAccessibleType(semanticChecker, bindingContext, baseType, out typeDst);
}
return false;
}
/***************************************************************************************************
Determine whether there is an explicit or implicit reference conversion (or identity conversion)
from typeSrc to typeDst. This is when:
13.2.3 Explicit reference conversions
The explicit reference conversions are:
* From object to any reference-type.
* From any class-type S to any class-type T, provided S is a base class of T.
* From any class-type S to any interface-type T, provided S is not sealed and provided S does not implement T.
* From any interface-type S to any class-type T, provided T is not sealed or provided T implements S.
* From any interface-type S to any interface-type T, provided S is not derived from T.
* From an array-type S with an element type SE to an array-type T with an element type TE, provided all of the following are true:
o S and T differ only in element type. (In other words, S and T have the same number of dimensions.)
o An explicit reference conversion exists from SE to TE.
* From System.Array and the interfaces it implements, to any array-type.
* From System.Delegate and the interfaces it implements, to any delegate-type.
* From a one-dimensional array-type S[] to System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyList<T> and their base interfaces, provided there is an explicit reference conversion from S to T.
* From a generic delegate type S to generic delegate type T, provided all of the follow are true:
o Both types are constructed generic types of the same generic delegate type, D<X1,... Xk>.That is,
S is D<S1,... Sk> and T is D<T1,... Tk>.
o S is not compatible with or identical to T.
o If type parameter Xi is declared to be invariant then Si must be identical to Ti.
o If type parameter Xi is declared to be covariant ("out") then Si must be convertible
to Ti via an identify conversion, implicit reference conversion, or explicit reference conversion.
o If type parameter Xi is declared to be contravariant ("in") then either Si must be identical to Ti,
or Si and Ti must both be reference types.
* From System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyList<T> and their base interfaces to a one-dimensional array-type S[], provided there is an implicit or explicit reference conversion from S[] to System.Collections.Generic.IList<T> or System.Collections.Generic.IReadOnlyList<T>. This is precisely when either S and T are the same type or there is an implicit or explicit reference conversion from S to T.
For a type-parameter T that is known to be a reference type (§25.7), the following explicit reference conversions exist:
* From the effective base class C of T to T and from any base class of C to T.
* From any interface-type to T.
* From T to any interface-type I provided there isn’t already an implicit reference conversion from T to I.
* From a type-parameter U to T provided that T depends on U (§25.7). [Note: Since T is known to be a reference type, within the scope of T, the run-time type of U will always be a reference type, even if U is not known to be a reference type at compile-time. end note]
* Both src and dst are reference types and there is a builtin explicit conversion from
src to dst.
* Or src is a reference type and dst is a base type of src (in which case the conversion is
implicit as well).
* Or dst is a reference type and src is a base type of dst.
The latter two cases can happen with type variables even though the other type variable is not
a reference type.
***************************************************************************************************/
public static bool FExpRefConv(SymbolLoader loader, CType typeSrc, CType typeDst)
{
Debug.Assert(typeSrc != null);
Debug.Assert(typeDst != null);
if (typeSrc.IsRefType() && typeDst.IsRefType())
{
// is there an implicit reference conversion in either direction?
// this handles the bulk of the cases ...
if (loader.HasIdentityOrImplicitReferenceConversion(typeSrc, typeDst) ||
loader.HasIdentityOrImplicitReferenceConversion(typeDst, typeSrc))
{
return true;
}
// For a type-parameter T that is known to be a reference type (§25.7), the following explicit reference conversions exist:
// • From any interface-type to T.
// • From T to any interface-type I provided there isn’t already an implicit reference conversion from T to I.
if (typeSrc.isInterfaceType() && typeDst.IsTypeParameterType())
{
return true;
}
if (typeSrc.IsTypeParameterType() && typeDst.isInterfaceType())
{
return true;
}
// * From any class-type S to any interface-type T, provided S is not sealed
// * From any interface-type S to any class-type T, provided T is not sealed
// * From any interface-type S to any interface-type T, provided S is not derived from T.
if (typeSrc.IsAggregateType() && typeDst.IsAggregateType())
{
AggregateSymbol aggSrc = typeSrc.AsAggregateType().getAggregate();
AggregateSymbol aggDest = typeDst.AsAggregateType().getAggregate();
if ((aggSrc.IsClass() && !aggSrc.IsSealed() && aggDest.IsInterface()) ||
(aggSrc.IsInterface() && aggDest.IsClass() && !aggDest.IsSealed()) ||
(aggSrc.IsInterface() && aggDest.IsInterface()))
{
return true;
}
}
// * From an array-type S with an element type SE to an array-type T with an element type TE, provided all of the following are true:
// o S and T differ only in element type. (In other words, S and T have the same number of dimensions.)
// o An explicit reference conversion exists from SE to TE.
if (typeSrc.IsArrayType() && typeDst.IsArrayType())
{
return typeSrc.AsArrayType().rank == typeDst.AsArrayType().rank && FExpRefConv(loader, typeSrc.AsArrayType().GetElementType(), typeDst.AsArrayType().GetElementType());
}
// * From a one-dimensional array-type S[] to System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyList<T>
// and their base interfaces, provided there is an explicit reference conversion from S to T.
if (typeSrc.IsArrayType())
{
if (typeSrc.AsArrayType().rank != 1 ||
!typeDst.isInterfaceType() || typeDst.AsAggregateType().GetTypeArgsAll().Size != 1)
{
return false;
}
AggregateSymbol aggIList = loader.GetOptPredefAgg(PredefinedType.PT_G_ILIST);
AggregateSymbol aggIReadOnlyList = loader.GetOptPredefAgg(PredefinedType.PT_G_IREADONLYLIST);
if ((aggIList == null ||
!loader.IsBaseAggregate(aggIList, typeDst.AsAggregateType().getAggregate())) &&
(aggIReadOnlyList == null ||
!loader.IsBaseAggregate(aggIReadOnlyList, typeDst.AsAggregateType().getAggregate())))
{
return false;
}
return FExpRefConv(loader, typeSrc.AsArrayType().GetElementType(), typeDst.AsAggregateType().GetTypeArgsAll().Item(0));
}
if (typeDst.IsArrayType() && typeSrc.IsAggregateType())
{
// * From System.Array and the interfaces it implements, to any array-type.
if (loader.HasIdentityOrImplicitReferenceConversion(loader.GetReqPredefType(PredefinedType.PT_ARRAY), typeSrc))
{
return true;
}
// * From System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyList<T> and their base interfaces to a
// one-dimensional array-type S[], provided there is an implicit or explicit reference conversion from S[] to
// System.Collections.Generic.IList<T> or System.Collections.Generic.IReadOnlyList<T>. This is precisely when either S and T
// are the same type or there is an implicit or explicit reference conversion from S to T.
ArrayType arrayDest = typeDst.AsArrayType();
AggregateType aggtypeSrc = typeSrc.AsAggregateType();
if (arrayDest.rank != 1 || !typeSrc.isInterfaceType() ||
aggtypeSrc.GetTypeArgsAll().Size != 1)
{
return false;
}
AggregateSymbol aggIList = loader.GetOptPredefAgg(PredefinedType.PT_G_ILIST);
AggregateSymbol aggIReadOnlyList = loader.GetOptPredefAgg(PredefinedType.PT_G_IREADONLYLIST);
if ((aggIList == null ||
!loader.IsBaseAggregate(aggIList, aggtypeSrc.getAggregate())) &&
(aggIReadOnlyList == null ||
!loader.IsBaseAggregate(aggIReadOnlyList, aggtypeSrc.getAggregate())))
{
return false;
}
CType typeArr = arrayDest.GetElementType();
CType typeLst = aggtypeSrc.GetTypeArgsAll().Item(0);
Debug.Assert(!typeArr.IsNeverSameType());
return typeArr == typeLst || FExpRefConv(loader, typeArr, typeLst);
}
if (HasGenericDelegateExplicitReferenceConversion(loader, typeSrc, typeDst))
{
return true;
}
}
else if (typeSrc.IsRefType())
{
// conversion of T . U, where T : class, U
// .. these constraints implies where U : class
return loader.HasIdentityOrImplicitReferenceConversion(typeSrc, typeDst);
}
else if (typeDst.IsRefType())
{
// conversion of T . U, where U : class, T
// .. these constraints implies where T : class
return loader.HasIdentityOrImplicitReferenceConversion(typeDst, typeSrc);
}
return false;
}
public bool HasBaseConversion(CType pSource, CType pDest)
{
// By a "base conversion" we mean:
//
// * an identity conversion
// * an implicit reference conversion
// * an implicit boxing conversion
// * an implicit type parameter conversion
//
// In other words, these are conversions that can be made to a base
// class, base interface or co/contravariant type without any change in
// representation other than boxing. A conversion from, say, int to double,
// is NOT a "base conversion", because representation is changed. A conversion
// from, say, lambda to expression tree is not a "base conversion" because
// do not have a type.
//
// The existence of a base conversion depends solely upon the source and
// destination types, not the source expression.
//
// This notion is not found in the spec but it is useful in the implementation.
if (pSource.IsAggregateType() && pDest.isPredefType(PredefinedType.PT_OBJECT))
{
// If we are going from any aggregate type (class, struct, interface, enum or delegate)
// to object, we immediately return true. This may seem like a mere optimization --
// after all, if we have an aggregate then we have some kind of implicit conversion
// to object.
//
// However, it is not a mere optimization; this introduces a control flow change
// in error reporting scenarios for unresolved type forwarders. If a type forwarder
// cannot be resolved then the resulting type symbol will be an aggregate, but
// we will not be able to classify it into class, struct, etc.
//
// We know that we will have an error in this case; we do not wish to compound
// that error by giving a spurious "you cannot convert this thing to object"
// error, which, after all, will go away when the type forwarding problem is
// fixed.
return true;
}
if (HasIdentityOrImplicitReferenceConversion(pSource, pDest))
{
return true;
}
if (HasImplicitBoxingConversion(pSource, pDest))
{
return true;
}
if (pSource.IsTypeParameterType() &&
HasImplicitTypeParameterBaseConversion(pSource.AsTypeParameterType(), pDest))
{
return true;
}
return false;
}
private static bool CheckSingleConstraint(CSemanticChecker checker, ErrorHandling errHandling, Symbol symErr, TypeParameterType var, CType arg, TypeArray typeArgsCls, TypeArray typeArgsMeth, CheckConstraintsFlags flags)
{
bool fReportErrors = 0 == (flags & CheckConstraintsFlags.NoErrors);
if (arg.IsOpenTypePlaceholderType())
{
return(true);
}
if (arg.IsErrorType())
{
// Error should have been reported previously.
return(false);
}
if (checker.CheckBogus(arg))
{
if (fReportErrors)
{
errHandling.ErrorRef(ErrorCode.ERR_BogusType, arg);
}
return(false);
}
if (arg.IsPointerType() || arg.isSpecialByRefType())
{
if (fReportErrors)
{
errHandling.Error(ErrorCode.ERR_BadTypeArgument, arg);
}
return(false);
}
if (arg.isStaticClass())
{
if (fReportErrors)
{
checker.ReportStaticClassError(null, arg, ErrorCode.ERR_GenericArgIsStaticClass);
}
return(false);
}
bool fError = false;
if (var.HasRefConstraint() && !arg.IsRefType())
{
if (fReportErrors)
{
errHandling.ErrorRef(ErrorCode.ERR_RefConstraintNotSatisfied, symErr, new ErrArgNoRef(var), arg);
}
fError = true;
}
TypeArray bnds = checker.GetSymbolLoader().GetTypeManager().SubstTypeArray(var.GetBounds(), typeArgsCls, typeArgsMeth);
int itypeMin = 0;
if (var.HasValConstraint())
{
// If we have a type variable that is constrained to a value type, then we
// want to check if its a nullable type, so that we can report the
// constraint error below. In order to do this however, we need to check
// that either the type arg is not a value type, or it is a nullable type.
//
// To check whether or not its a nullable type, we need to get the resolved
// bound from the type argument and check against that.
bool bIsValueType = arg.IsValType();
bool bIsNullable = arg.IsNullableType();
if (bIsValueType && arg.IsTypeParameterType())
{
TypeArray pArgBnds = arg.AsTypeParameterType().GetBounds();
if (pArgBnds.Count > 0)
{
bIsNullable = pArgBnds[0].IsNullableType();
}
}
if (!bIsValueType || bIsNullable)
{
if (fReportErrors)
{
errHandling.ErrorRef(ErrorCode.ERR_ValConstraintNotSatisfied, symErr, new ErrArgNoRef(var), arg);
}
fError = true;
}
// Since FValCon() is set it is redundant to check System.ValueType as well.
if (bnds.Count != 0 && bnds[0].isPredefType(PredefinedType.PT_VALUE))
{
itypeMin = 1;
}
}
for (int j = itypeMin; j < bnds.Count; j++)
{
CType typeBnd = bnds[j];
if (!SatisfiesBound(checker, arg, typeBnd))
{
if (fReportErrors)
{
// The bound isn't satisfied because of a constraint type. Explain to the user why not.
// There are 4 main cases, based on the type of the supplied type argument:
// - reference type, or type parameter known to be a reference type
// - nullable type, from which there is a boxing conversion to the constraint type(see below for details)
// - type variable
// - value type
// These cases are broken out because: a) The sets of conversions which can be used
// for constraint satisfaction is different based on the type argument supplied,
// and b) Nullable is one funky type, and user's can use all the help they can get
// when using it.
ErrorCode error;
if (arg.IsRefType())
{
// A reference type can only satisfy bounds to types
// to which they have an implicit reference conversion
error = ErrorCode.ERR_GenericConstraintNotSatisfiedRefType;
}
else if (arg.IsNullableType() && checker.GetSymbolLoader().HasBaseConversion(arg.AsNullableType().GetUnderlyingType(), typeBnd)) // This is inlining FBoxingConv
{
// nullable types do not satisfy bounds to every type that they are boxable to
// They only satisfy bounds of object and ValueType
if (typeBnd.isPredefType(PredefinedType.PT_ENUM) || arg.AsNullableType().GetUnderlyingType() == typeBnd)
{
// Nullable types don't satisfy bounds of EnumType, or the underlying type of the enum
// even though the conversion from Nullable to these types is a boxing conversion
// This is a rare case, because these bounds can never be directly stated ...
// These bounds can only occur when one type paramter is constrained to a second type parameter
// and the second type parameter is instantiated with Enum or the underlying type of the first type
// parameter
error = ErrorCode.ERR_GenericConstraintNotSatisfiedNullableEnum;
}
else
{
// Nullable types don't satisfy the bounds of any interface type
// even when there is a boxing conversion from the Nullable type to
// the interface type. This will be a relatively common scenario
// so we cal it out separately from the previous case.
Debug.Assert(typeBnd.isInterfaceType());
error = ErrorCode.ERR_GenericConstraintNotSatisfiedNullableInterface;
}
}
else if (arg.IsTypeParameterType())
{
// Type variables can satisfy bounds through boxing and type variable conversions
Debug.Assert(!arg.IsRefType());
error = ErrorCode.ERR_GenericConstraintNotSatisfiedTyVar;
}
else
{
// Value types can only satisfy bounds through boxing conversions.
// Note that the exceptional case of Nullable types and boxing is handled above.
error = ErrorCode.ERR_GenericConstraintNotSatisfiedValType;
}
errHandling.Error(error, new ErrArgRef(symErr), new ErrArg(typeBnd, ErrArgFlags.Unique), var, new ErrArgRef(arg, ErrArgFlags.Unique));
}
fError = true;
}
}
// Check the newable constraint.
if (!var.HasNewConstraint() || arg.IsValType())
{
return(!fError);
}
if (arg.isClassType())
{
AggregateSymbol agg = arg.AsAggregateType().getAggregate();
// Due to late binding nature of IDE created symbols, the AggregateSymbol might not
// have all the information necessary yet, if it is not fully bound.
// by calling LookupAggMember, it will ensure that we will update all the
// information necessary at least for the given method.
checker.GetSymbolLoader().LookupAggMember(checker.GetNameManager().GetPredefName(PredefinedName.PN_CTOR), agg, symbmask_t.MASK_ALL);
if (agg.HasPubNoArgCtor() && !agg.IsAbstract())
{
return(!fError);
}
}
else if (arg.IsTypeParameterType() && arg.AsTypeParameterType().HasNewConstraint())
{
return(!fError);
}
if (fReportErrors)
{
errHandling.ErrorRef(ErrorCode.ERR_NewConstraintNotSatisfied, symErr, new ErrArgNoRef(var), arg);
}
return(false);
}
////////////////////////////////////////////////////////////////////////////////
private bool UpperBoundTypeParameterInference(CType pSource, CType pDest)
{
// SPEC: If V is one of the unfixed Xi then U is added to the set of upper bounds
// SPEC: for Xi.
if (pDest.IsTypeParameterType())
{
TypeParameterType pTPType = pDest.AsTypeParameterType();
if (pTPType.IsMethodTypeParameter() && IsUnfixed(pTPType))
{
AddUpperBound(pTPType, pSource);
return true;
}
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
private bool LowerBoundClassInference(CType pSource, AggregateType pDest)
{
if (!pDest.isClassType())
{
return false;
}
// SPEC: Otherwise, if V is a class CType C<V1...Vk> and U is a class CType which
// SPEC: inherits directly or indirectly from C<U1...Uk>
// SPEC: then an exact inference is made from each Ui to the corresponding Vi.
// SPEC: Otherwise, if V is a class CType C<V1...Vk> and U is a CType parameter
// SPEC: with effective base class C<U1...Uk>
// SPEC: then an exact inference is made from each Ui to the corresponding Vi.
// SPEC: Otherwise, if V is a class CType C<V1...Vk> and U is a CType parameter
// SPEC: with an effective base class which inherits directly or indirectly from
// SPEC: C<U1...Uk> then an exact inference is made
// SPEC: from each Ui to the corresponding Vi.
AggregateType pSourceBase = null;
if (pSource.isClassType())
{
pSourceBase = pSource.AsAggregateType().GetBaseClass();
}
else if (pSource.IsTypeParameterType())
{
pSourceBase = pSource.AsTypeParameterType().GetEffectiveBaseClass();
}
while (pSourceBase != null)
{
if (pSourceBase.GetOwningAggregate() == pDest.GetOwningAggregate())
{
ExactTypeArgumentInference(pSourceBase, pDest);
return true;
}
pSourceBase = pSourceBase.GetBaseClass();
}
return false;
}
public bool HasImplicitReferenceConversion(CType pSource, CType pDest)
{
Debug.Assert(pSource != null);
Debug.Assert(pDest != null);
// The implicit reference conversions are:
// * From any reference type to Object.
if (pSource.IsRefType() && pDest.isPredefType(PredefinedType.PT_OBJECT))
{
return true;
}
// * From any class type S to any class type T provided S is derived from T.
if (pSource.isClassType() && pDest.isClassType() && IsBaseClass(pSource, pDest))
{
return true;
}
// ORIGINAL RULES:
// // * From any class type S to any interface type T provided S implements T.
// if (pSource.isClassType() && pDest.isInterfaceType() && IsBaseInterface(pSource, pDest))
// {
// return true;
// }
// // * from any interface type S to any interface type T, provided S is derived from T.
// if (pSource.isInterfaceType() && pDest.isInterfaceType() && IsBaseInterface(pSource, pDest))
// {
// return true;
// }
// VARIANCE EXTENSIONS:
// * From any class type S to any interface type T provided S implements an interface
// convertible to T.
// * From any interface type S to any interface type T provided S implements an interface
// convertible to T.
// * From any interface type S to any interface type T provided S is not T and S is
// an interface convertible to T.
if (pSource.isClassType() && pDest.isInterfaceType() && HasAnyBaseInterfaceConversion(pSource, pDest))
{
return true;
}
if (pSource.isInterfaceType() && pDest.isInterfaceType() && HasAnyBaseInterfaceConversion(pSource, pDest))
{
return true;
}
if (pSource.isInterfaceType() && pDest.isInterfaceType() && pSource != pDest &&
HasInterfaceConversion(pSource.AsAggregateType(), pDest.AsAggregateType()))
{
return true;
}
// * From an array type S with an element type SE to an array type T with element type TE
// provided that all of the following are true:
// * S and T differ only in element type. In other words, S and T have the same number of dimensions.
// * Both SE and TE are reference types.
// * An implicit reference conversion exists from SE to TE.
if (pSource.IsArrayType() && pDest.IsArrayType() &&
HasCovariantArrayConversion(pSource.AsArrayType(), pDest.AsArrayType()))
{
return true;
}
// * From any array type to System.Array or any interface implemented by System.Array.
if (pSource.IsArrayType() && (pDest.isPredefType(PredefinedType.PT_ARRAY) ||
IsBaseInterface(GetReqPredefType(PredefinedType.PT_ARRAY, false), pDest)))
{
return true;
}
// * From a single-dimensional array type S[] to IList<T> and its base
// interfaces, provided that there is an implicit identity or reference
// conversion from S to T.
if (pSource.IsArrayType() && HasArrayConversionToInterface(pSource.AsArrayType(), pDest))
{
return true;
}
// * From any delegate type to System.Delegate
//
// SPEC OMISSION:
//
// The spec should actually say
//
// * From any delegate type to System.Delegate
// * From any delegate type to System.MulticastDelegate
// * From any delegate type to any interface implemented by System.MulticastDelegate
if (pSource.isDelegateType() &&
(pDest.isPredefType(PredefinedType.PT_MULTIDEL) ||
pDest.isPredefType(PredefinedType.PT_DELEGATE) ||
IsBaseInterface(GetReqPredefType(PredefinedType.PT_MULTIDEL, false), pDest)))
{
return true;
}
// VARIANCE EXTENSION:
// * From any delegate type S to a delegate type T provided S is not T and
// S is a delegate convertible to T
if (pSource.isDelegateType() && pDest.isDelegateType() &&
HasDelegateConversion(pSource.AsAggregateType(), pDest.AsAggregateType()))
{
return true;
}
// * From the null literal to any reference type
// NOTE: We extend the specification here. The C# 3.0 spec does not describe
// a "null type". Rather, it says that the null literal is typeless, and is
// convertible to any reference or nullable type. However, the C# 2.0 and 3.0
// implementations have a "null type" which some expressions other than the
// null literal may have. (For example, (null??null), which is also an
// extension to the specification.)
if (pSource.IsNullType() && pDest.IsRefType())
{
return true;
}
if (pSource.IsNullType() && pDest.IsNullableType())
{
return true;
}
// * Implicit conversions involving type parameters that are known to be reference types.
if (pSource.IsTypeParameterType() &&
HasImplicitReferenceTypeParameterConversion(pSource.AsTypeParameterType(), pDest))
{
return true;
}
return false;
}
private bool HasImplicitReferenceConversion(CType pSource, CType pDest)
{
Debug.Assert(pSource != null);
Debug.Assert(pDest != null);
// The implicit reference conversions are:
// * From any reference type to Object.
if (pSource.IsRefType() && pDest.isPredefType(PredefinedType.PT_OBJECT))
{
return(true);
}
// * From any class type S to any class type T provided S is derived from T.
if (pSource.isClassType() && pDest.isClassType() && IsBaseClass(pSource, pDest))
{
return(true);
}
// ORIGINAL RULES:
// // * From any class type S to any interface type T provided S implements T.
// if (pSource.isClassType() && pDest.isInterfaceType() && IsBaseInterface(pSource, pDest))
// {
// return true;
// }
// // * from any interface type S to any interface type T, provided S is derived from T.
// if (pSource.isInterfaceType() && pDest.isInterfaceType() && IsBaseInterface(pSource, pDest))
// {
// return true;
// }
// VARIANCE EXTENSIONS:
// * From any class type S to any interface type T provided S implements an interface
// convertible to T.
// * From any interface type S to any interface type T provided S implements an interface
// convertible to T.
// * From any interface type S to any interface type T provided S is not T and S is
// an interface convertible to T.
if (pSource.isClassType() && pDest.isInterfaceType() && HasAnyBaseInterfaceConversion(pSource, pDest))
{
return(true);
}
if (pSource.isInterfaceType() && pDest.isInterfaceType() && HasAnyBaseInterfaceConversion(pSource, pDest))
{
return(true);
}
if (pSource.isInterfaceType() && pDest.isInterfaceType() && pSource != pDest &&
HasInterfaceConversion(pSource.AsAggregateType(), pDest.AsAggregateType()))
{
return(true);
}
// * From an array type S with an element type SE to an array type T with element type TE
// provided that all of the following are true:
// * S and T differ only in element type. In other words, S and T have the same number of dimensions.
// * Both SE and TE are reference types.
// * An implicit reference conversion exists from SE to TE.
if (pSource.IsArrayType() && pDest.IsArrayType() &&
HasCovariantArrayConversion(pSource.AsArrayType(), pDest.AsArrayType()))
{
return(true);
}
// * From any array type to System.Array or any interface implemented by System.Array.
if (pSource.IsArrayType() && (pDest.isPredefType(PredefinedType.PT_ARRAY) ||
IsBaseInterface(GetReqPredefType(PredefinedType.PT_ARRAY, false), pDest)))
{
return(true);
}
// * From a single-dimensional array type S[] to IList<T> and its base
// interfaces, provided that there is an implicit identity or reference
// conversion from S to T.
if (pSource.IsArrayType() && HasArrayConversionToInterface(pSource.AsArrayType(), pDest))
{
return(true);
}
// * From any delegate type to System.Delegate
//
// SPEC OMISSION:
//
// The spec should actually say
//
// * From any delegate type to System.Delegate
// * From any delegate type to System.MulticastDelegate
// * From any delegate type to any interface implemented by System.MulticastDelegate
if (pSource.isDelegateType() &&
(pDest.isPredefType(PredefinedType.PT_MULTIDEL) ||
pDest.isPredefType(PredefinedType.PT_DELEGATE) ||
IsBaseInterface(GetReqPredefType(PredefinedType.PT_MULTIDEL, false), pDest)))
{
return(true);
}
// VARIANCE EXTENSION:
// * From any delegate type S to a delegate type T provided S is not T and
// S is a delegate convertible to T
if (pSource.isDelegateType() && pDest.isDelegateType() &&
HasDelegateConversion(pSource.AsAggregateType(), pDest.AsAggregateType()))
{
return(true);
}
// * From the null literal to any reference type
// NOTE: We extend the specification here. The C# 3.0 spec does not describe
// a "null type". Rather, it says that the null literal is typeless, and is
// convertible to any reference or nullable type. However, the C# 2.0 and 3.0
// implementations have a "null type" which some expressions other than the
// null literal may have. (For example, (null??null), which is also an
// extension to the specification.)
if (pSource.IsNullType() && pDest.IsRefType())
{
return(true);
}
if (pSource.IsNullType() && pDest.IsNullableType())
{
return(true);
}
// * Implicit conversions involving type parameters that are known to be reference types.
if (pSource.IsTypeParameterType() &&
HasImplicitReferenceTypeParameterConversion(pSource.AsTypeParameterType(), pDest))
{
return(true);
}
return(false);
}
private bool HasImplicitReferenceTypeParameterConversion(
TypeParameterType pSource, CType pDest)
{
Debug.Assert(pSource != null);
Debug.Assert(pDest != null);
if (!pSource.IsRefType())
{
// Not a reference conversion.
return false;
}
// The following implicit conversions exist for a given type parameter T:
//
// * From T to its effective base class C.
AggregateType pEBC = pSource.GetEffectiveBaseClass();
if (pDest == pEBC)
{
return true;
}
// * From T to any base class of C.
if (IsBaseClass(pEBC, pDest))
{
return true;
}
// * From T to any interface implemented by C.
if (IsBaseInterface(pEBC, pDest))
{
return true;
}
// * From T to any interface type I in T's effective interface set, and
// from T to any base interface of I.
TypeArray pInterfaces = pSource.GetInterfaceBounds();
for (int i = 0; i < pInterfaces.Size; ++i)
{
if (pInterfaces.Item(i) == pDest)
{
return true;
}
}
// * From T to a type parameter U, provided T depends on U.
if (pDest.IsTypeParameterType() && pSource.DependsOn(pDest.AsTypeParameterType()))
{
return true;
}
return false;
}
private bool HasImplicitTypeParameterBaseConversion(
TypeParameterType pSource, CType pDest)
{
Debug.Assert(pSource != null);
Debug.Assert(pDest != null);
if (HasImplicitReferenceTypeParameterConversion(pSource, pDest))
{
return true;
}
if (HasImplicitBoxingTypeParameterConversion(pSource, pDest))
{
return true;
}
if (pDest.IsTypeParameterType() && pSource.DependsOn(pDest.AsTypeParameterType()))
{
return true;
}
return false;
}
/***************************************************************************************************
* Determine whether there is an explicit or implicit reference conversion (or identity conversion)
* from typeSrc to typeDst. This is when:
*
* 13.2.3 Explicit reference conversions
*
* The explicit reference conversions are:
* From object to any reference-type.
* From any class-type S to any class-type T, provided S is a base class of T.
* From any class-type S to any interface-type T, provided S is not sealed and provided S does not implement T.
* From any interface-type S to any class-type T, provided T is not sealed or provided T implements S.
* From any interface-type S to any interface-type T, provided S is not derived from T.
* From an array-type S with an element type SE to an array-type T with an element type TE, provided all of the following are true:
* o S and T differ only in element type. (In other words, S and T have the same number of dimensions.)
* o An explicit reference conversion exists from SE to TE.
* From System.Array and the interfaces it implements, to any array-type.
* From System.Delegate and the interfaces it implements, to any delegate-type.
* From a one-dimensional array-type S[] to System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyList<T> and their base interfaces, provided there is an explicit reference conversion from S to T.
* From a generic delegate type S to generic delegate type T, provided all of the follow are true:
* o Both types are constructed generic types of the same generic delegate type, D<X1,... Xk>.That is,
* S is D<S1,... Sk> and T is D<T1,... Tk>.
* o S is not compatible with or identical to T.
* o If type parameter Xi is declared to be invariant then Si must be identical to Ti.
* o If type parameter Xi is declared to be covariant ("out") then Si must be convertible
* to Ti via an identify conversion, implicit reference conversion, or explicit reference conversion.
* o If type parameter Xi is declared to be contravariant ("in") then either Si must be identical to Ti,
* or Si and Ti must both be reference types.
* From System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyList<T> and their base interfaces to a one-dimensional array-type S[], provided there is an implicit or explicit reference conversion from S[] to System.Collections.Generic.IList<T> or System.Collections.Generic.IReadOnlyList<T>. This is precisely when either S and T are the same type or there is an implicit or explicit reference conversion from S to T.
*
* For a type-parameter T that is known to be a reference type (§25.7), the following explicit reference conversions exist:
* From the effective base class C of T to T and from any base class of C to T.
* From any interface-type to T.
* From T to any interface-type I provided there isn’t already an implicit reference conversion from T to I.
* From a type-parameter U to T provided that T depends on U (§25.7). [Note: Since T is known to be a reference type, within the scope of T, the run-time type of U will always be a reference type, even if U is not known to be a reference type at compile-time. end note]
*
* Both src and dst are reference types and there is a builtin explicit conversion from
* src to dst.
* Or src is a reference type and dst is a base type of src (in which case the conversion is
* implicit as well).
* Or dst is a reference type and src is a base type of dst.
*
* The latter two cases can happen with type variables even though the other type variable is not
* a reference type.
***************************************************************************************************/
public static bool FExpRefConv(SymbolLoader loader, CType typeSrc, CType typeDst)
{
Debug.Assert(typeSrc != null);
Debug.Assert(typeDst != null);
if (typeSrc.IsRefType() && typeDst.IsRefType())
{
// is there an implicit reference conversion in either direction?
// this handles the bulk of the cases ...
if (loader.HasIdentityOrImplicitReferenceConversion(typeSrc, typeDst) ||
loader.HasIdentityOrImplicitReferenceConversion(typeDst, typeSrc))
{
return(true);
}
// For a type-parameter T that is known to be a reference type (§25.7), the following explicit reference conversions exist:
// • From any interface-type to T.
// • From T to any interface-type I provided there isn’t already an implicit reference conversion from T to I.
if (typeSrc.isInterfaceType() && typeDst.IsTypeParameterType())
{
return(true);
}
if (typeSrc.IsTypeParameterType() && typeDst.isInterfaceType())
{
return(true);
}
// * From any class-type S to any interface-type T, provided S is not sealed
// * From any interface-type S to any class-type T, provided T is not sealed
// * From any interface-type S to any interface-type T, provided S is not derived from T.
if (typeSrc.IsAggregateType() && typeDst.IsAggregateType())
{
AggregateSymbol aggSrc = typeSrc.AsAggregateType().getAggregate();
AggregateSymbol aggDest = typeDst.AsAggregateType().getAggregate();
if ((aggSrc.IsClass() && !aggSrc.IsSealed() && aggDest.IsInterface()) ||
(aggSrc.IsInterface() && aggDest.IsClass() && !aggDest.IsSealed()) ||
(aggSrc.IsInterface() && aggDest.IsInterface()))
{
return(true);
}
}
// * From an array-type S with an element type SE to an array-type T with an element type TE, provided all of the following are true:
// o S and T differ only in element type. (In other words, S and T have the same number of dimensions.)
// o An explicit reference conversion exists from SE to TE.
if (typeSrc.IsArrayType() && typeDst.IsArrayType())
{
return(typeSrc.AsArrayType().rank == typeDst.AsArrayType().rank&& FExpRefConv(loader, typeSrc.AsArrayType().GetElementType(), typeDst.AsArrayType().GetElementType()));
}
// * From a one-dimensional array-type S[] to System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyList<T>
// and their base interfaces, provided there is an explicit reference conversion from S to T.
if (typeSrc.IsArrayType())
{
if (typeSrc.AsArrayType().rank != 1 ||
!typeDst.isInterfaceType() || typeDst.AsAggregateType().GetTypeArgsAll().Size != 1)
{
return(false);
}
AggregateSymbol aggIList = loader.GetOptPredefAgg(PredefinedType.PT_G_ILIST);
AggregateSymbol aggIReadOnlyList = loader.GetOptPredefAgg(PredefinedType.PT_G_IREADONLYLIST);
if ((aggIList == null ||
!loader.IsBaseAggregate(aggIList, typeDst.AsAggregateType().getAggregate())) &&
(aggIReadOnlyList == null ||
!loader.IsBaseAggregate(aggIReadOnlyList, typeDst.AsAggregateType().getAggregate())))
{
return(false);
}
return(FExpRefConv(loader, typeSrc.AsArrayType().GetElementType(), typeDst.AsAggregateType().GetTypeArgsAll().Item(0)));
}
if (typeDst.IsArrayType() && typeSrc.IsAggregateType())
{
// * From System.Array and the interfaces it implements, to any array-type.
if (loader.HasIdentityOrImplicitReferenceConversion(loader.GetReqPredefType(PredefinedType.PT_ARRAY), typeSrc))
{
return(true);
}
// * From System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyList<T> and their base interfaces to a
// one-dimensional array-type S[], provided there is an implicit or explicit reference conversion from S[] to
// System.Collections.Generic.IList<T> or System.Collections.Generic.IReadOnlyList<T>. This is precisely when either S and T
// are the same type or there is an implicit or explicit reference conversion from S to T.
ArrayType arrayDest = typeDst.AsArrayType();
AggregateType aggtypeSrc = typeSrc.AsAggregateType();
if (arrayDest.rank != 1 || !typeSrc.isInterfaceType() ||
aggtypeSrc.GetTypeArgsAll().Size != 1)
{
return(false);
}
AggregateSymbol aggIList = loader.GetOptPredefAgg(PredefinedType.PT_G_ILIST);
AggregateSymbol aggIReadOnlyList = loader.GetOptPredefAgg(PredefinedType.PT_G_IREADONLYLIST);
if ((aggIList == null ||
!loader.IsBaseAggregate(aggIList, aggtypeSrc.getAggregate())) &&
(aggIReadOnlyList == null ||
!loader.IsBaseAggregate(aggIReadOnlyList, aggtypeSrc.getAggregate())))
{
return(false);
}
CType typeArr = arrayDest.GetElementType();
CType typeLst = aggtypeSrc.GetTypeArgsAll().Item(0);
Debug.Assert(!typeArr.IsNeverSameType());
return(typeArr == typeLst || FExpRefConv(loader, typeArr, typeLst));
}
if (HasGenericDelegateExplicitReferenceConversion(loader, typeSrc, typeDst))
{
return(true);
}
}
else if (typeSrc.IsRefType())
{
// conversion of T . U, where T : class, U
// .. these constraints implies where U : class
return(loader.HasIdentityOrImplicitReferenceConversion(typeSrc, typeDst));
}
else if (typeDst.IsRefType())
{
// conversion of T . U, where U : class, T
// .. these constraints implies where T : class
return(loader.HasIdentityOrImplicitReferenceConversion(typeDst, typeSrc));
}
return(false);
}
private bool bindImplicitConversionFromTypeVar(TypeParameterType tyVarSrc)
{
// 13.1.4
//
// For a type-parameter T that is known to be a reference type (25.7), the following implicit
// reference conversions exist:
//
// * From T to its effective base class C, from T to any base class of C, and from T to any
// interface implemented by C.
// * From T to an interface-type I in T's effective interface set and from T to any base
// interface of I.
// * From T to a type parameter U provided that T depends on U (25.7). [Note: Since T is known
// to be a reference type, within the scope of T, the run-time type of U will always be a
// reference type, even if U is not known to be a reference type at compile-time.]
// * From the null type (11.2.7) to T.
//
// 13.1.5
//
// For a type-parameter T that is not known to be a reference type (25.7), the following conversions
// involving T are considered to be boxing conversions at compile-time. At run-time, if T is a value
// type, the conversion is executed as a boxing conversion. At run-time, if T is a reference type,
// the conversion is executed as an implicit reference conversion or identity conversion.
//
// * From T to its effective base class C, from T to any base class of C, and from T to any
// interface implemented by C. [Note: C will be one of the types System.Object, System.ValueType,
// or System.Enum (otherwise T would be known to be a reference type and 13.1.4 would apply
// instead of this clause).]
// * From T to an interface-type I in T's effective interface set and from T to any base
// interface of I.
//
// 13.1.6 Implicit type parameter conversions
//
// This clause details implicit conversions involving type parameters that are not classified as
// implicit reference conversions or implicit boxing conversions.
//
// For a type-parameter T that is not known to be a reference type, there is an implicit conversion
// from T to a type parameter U provided T depends on U. At run-time, if T is a value type and U is
// a reference type, the conversion is executed as a boxing conversion. At run-time, if both T and U
// are value types, then T and U are necessarily the same type and no conversion is performed. At
// run-time, if T is a reference type, then U is necessarily also a reference type and the conversion
// is executed as an implicit reference conversion or identity conversion (25.7).
CType typeTmp = tyVarSrc.GetEffectiveBaseClass();
TypeArray bnds = tyVarSrc.GetBounds();
int itype = -1;
for (; ;)
{
if (binder.canConvert(typeTmp, typeDest, flags | CONVERTTYPE.NOUDC))
{
if (!needsExprDest)
{
return(true);
}
if (typeDest.IsTypeParameterType())
{
// For a type var destination we need to cast to object then to the other type var.
EXPR exprT;
EXPRCLASS exprObj = GetExprFactory().MakeClass(binder.GetReqPDT(PredefinedType.PT_OBJECT));
binder.bindSimpleCast(exprSrc, exprObj, out exprT, EXPRFLAG.EXF_FORCE_BOX);
binder.bindSimpleCast(exprT, exprTypeDest, out exprDest, EXPRFLAG.EXF_FORCE_UNBOX);
}
else
{
binder.bindSimpleCast(exprSrc, exprTypeDest, out exprDest, EXPRFLAG.EXF_FORCE_BOX);
}
return(true);
}
do
{
if (++itype >= bnds.Size)
{
return(false);
}
typeTmp = bnds.Item(itype);
}while (!typeTmp.isInterfaceType() && !typeTmp.IsTypeParameterType());
}
}
// It would be nice to make this a virtual method on typeSym.
public AggregateType GetAggTypeSym(CType typeSym)
{
Debug.Assert(typeSym != null);
Debug.Assert(typeSym.IsAggregateType() ||
typeSym.IsTypeParameterType() ||
typeSym.IsArrayType() ||
typeSym.IsNullableType());
switch (typeSym.GetTypeKind())
{
case TypeKind.TK_AggregateType:
return typeSym.AsAggregateType();
case TypeKind.TK_ArrayType:
return GetReqPredefType(PredefinedType.PT_ARRAY);
case TypeKind.TK_TypeParameterType:
return typeSym.AsTypeParameterType().GetEffectiveBaseClass();
case TypeKind.TK_NullableType:
return typeSym.AsNullableType().GetAts(ErrorContext);
}
Debug.Assert(false, "Bad typeSym!");
return null;
}
////////////////////////////////////////////////////////////////////////////////
private bool LowerBoundArrayInference(CType pSource, CType pDest)
{
// SPEC: Otherwise, if U is an array CType Ue[...] and V is either an array
// SPEC: CType Ve[...] of the same rank, or if U is a one-dimensional array
// SPEC: CType Ue[] and V is one of IEnumerable<Ve>, ICollection<Ve>,
// SPEC: IList<Ve>, IReadOnlyCollection<Ve> or IReadOnlyList<Ve> then
// SPEC: if Ue is known to be a reference CType then a lower-bound inference
// SPEC: from Ue to Ve is made.
// SPEC: otherwise an exact inference from Ue to Ve is made.
// Consider the following:
//
// abstract class B<T> { public abstract M<U>(U u) : where U : T; }
// class D : B<int[]> {
// static void M<X>(X[] x) { }
// public override M<U>(U u) { M(u); } // should infer M<int>
// }
if (pSource.IsTypeParameterType())
{
pSource = pSource.AsTypeParameterType().GetEffectiveBaseClass();
}
if (!pSource.IsArrayType())
{
return false;
}
ArrayType pArraySource = pSource.AsArrayType();
CType pElementSource = pArraySource.GetElementType();
CType pElementDest = null;
if (pDest.IsArrayType())
{
ArrayType pArrayDest = pDest.AsArrayType();
if (pArrayDest.rank != pArraySource.rank)
{
return false;
}
pElementDest = pArrayDest.GetElementType();
}
else if (pDest.isPredefType(PredefinedType.PT_G_IENUMERABLE) ||
pDest.isPredefType(PredefinedType.PT_G_ICOLLECTION) ||
pDest.isPredefType(PredefinedType.PT_G_ILIST) ||
pDest.isPredefType(PredefinedType.PT_G_IREADONLYCOLLECTION) ||
pDest.isPredefType(PredefinedType.PT_G_IREADONLYLIST))
{
if (pArraySource.rank != 1)
{
return false;
}
AggregateType pAggregateDest = pDest.AsAggregateType();
pElementDest = pAggregateDest.GetTypeArgsThis().Item(0);
}
else
{
return false;
}
if (pElementSource.IsRefType())
{
LowerBoundInference(pElementSource, pElementDest);
}
else
{
ExactInference(pElementSource, pElementDest);
}
return true;
}
//
// SymbolLoader forwarders (end)
/////////////////////////////////////////////////////////////////////////////////
//
// Utility methods
//
protected ACCESSERROR CheckAccessCore(Symbol symCheck, AggregateType atsCheck, Symbol symWhere, CType typeThru)
{
Debug.Assert(symCheck != null);
Debug.Assert(atsCheck == null || symCheck.parent == atsCheck.getAggregate());
Debug.Assert(typeThru == null ||
typeThru.IsAggregateType() ||
typeThru.IsTypeParameterType() ||
typeThru.IsArrayType() ||
typeThru.IsNullableType() ||
typeThru.IsErrorType());
switch (symCheck.GetAccess())
{
default:
throw Error.InternalCompilerError();
//return ACCESSERROR.ACCESSERROR_NOACCESS;
case ACCESS.ACC_UNKNOWN:
return(ACCESSERROR.ACCESSERROR_NOACCESS);
case ACCESS.ACC_PUBLIC:
return(ACCESSERROR.ACCESSERROR_NOERROR);
case ACCESS.ACC_PRIVATE:
case ACCESS.ACC_PROTECTED:
if (symWhere == null)
{
return(ACCESSERROR.ACCESSERROR_NOACCESS);
}
break;
case ACCESS.ACC_INTERNAL:
case ACCESS.ACC_INTERNALPROTECTED: // Check internal, then protected.
if (symWhere == null)
{
return(ACCESSERROR.ACCESSERROR_NOACCESS);
}
if (symWhere.SameAssemOrFriend(symCheck))
{
return(ACCESSERROR.ACCESSERROR_NOERROR);
}
if (symCheck.GetAccess() == ACCESS.ACC_INTERNAL)
{
return(ACCESSERROR.ACCESSERROR_NOACCESS);
}
break;
}
// Should always have atsCheck for private and protected access check.
// We currently don't need it since access doesn't respect instantiation.
// We just use symWhere.parent.AsAggregateSymbol() instead.
AggregateSymbol aggCheck = symCheck.parent.AsAggregateSymbol();
// Find the inner-most enclosing AggregateSymbol.
AggregateSymbol aggWhere = null;
for (Symbol symT = symWhere; symT != null; symT = symT.parent)
{
if (symT.IsAggregateSymbol())
{
aggWhere = symT.AsAggregateSymbol();
break;
}
if (symT.IsAggregateDeclaration())
{
aggWhere = symT.AsAggregateDeclaration().Agg();
break;
}
}
if (aggWhere == null)
{
return(ACCESSERROR.ACCESSERROR_NOACCESS);
}
// First check for private access.
for (AggregateSymbol agg = aggWhere; agg != null; agg = agg.GetOuterAgg())
{
if (agg == aggCheck)
{
return(ACCESSERROR.ACCESSERROR_NOERROR);
}
}
if (symCheck.GetAccess() == ACCESS.ACC_PRIVATE)
{
return(ACCESSERROR.ACCESSERROR_NOACCESS);
}
// Handle the protected case - which is the only real complicated one.
Debug.Assert(symCheck.GetAccess() == ACCESS.ACC_PROTECTED || symCheck.GetAccess() == ACCESS.ACC_INTERNALPROTECTED);
// Check if symCheck is in aggWhere or a base of aggWhere,
// or in an outer agg of aggWhere or a base of an outer agg of aggWhere.
AggregateType atsThru = null;
if (typeThru != null && !symCheck.isStatic)
{
atsThru = SymbolLoader.GetAggTypeSym(typeThru);
}
// Look for aggCheck among the base classes of aggWhere and outer aggs.
bool found = false;
for (AggregateSymbol agg = aggWhere; agg != null; agg = agg.GetOuterAgg())
{
Debug.Assert(agg != aggCheck); // We checked for this above.
// Look for aggCheck among the base classes of agg.
if (agg.FindBaseAgg(aggCheck))
{
found = true;
// aggCheck is a base class of agg. Check atsThru.
// For non-static protected access to be legal, atsThru must be an instantiation of
// agg or a CType derived from an instantiation of agg. In this case
// all that matters is that agg is in the base AggregateSymbol chain of atsThru. The
// actual AGGTYPESYMs involved don't matter.
if (atsThru == null || atsThru.getAggregate().FindBaseAgg(agg))
{
return(ACCESSERROR.ACCESSERROR_NOERROR);
}
}
}
// the CType in whice the method is being called has no relationship with the
// CType on which the method is defined surely this is NOACCESS and not NOACCESSTHRU
if (found == false)
{
return(ACCESSERROR.ACCESSERROR_NOACCESS);
}
return((atsThru == null) ? ACCESSERROR.ACCESSERROR_NOACCESS : ACCESSERROR.ACCESSERROR_NOACCESSTHRU);
}
////////////////////////////////////////////////////////////////////////////////
private bool LowerBoundInterfaceInference(CType pSource, AggregateType pDest)
{
if (!pDest.isInterfaceType())
{
return false;
}
// SPEC: Otherwise, if V is an interface CType C<V1...Vk> and U is a class CType
// SPEC: or struct CType and there is a unique set U1...Uk such that U directly
// SPEC: or indirectly implements C<U1...Uk> then an
// SPEC: exact, upper-bound, or lower-bound inference ...
// SPEC: ... and U is an interface CType ...
// SPEC: ... and U is a CType parameter ...
//TypeArray pInterfaces = null;
if (!pSource.isStructType() && !pSource.isClassType() &&
!pSource.isInterfaceType() && !pSource.IsTypeParameterType())
{
return false;
}
var interfaces = pSource.AllPossibleInterfaces();
AggregateType pInterface = null;
foreach (AggregateType pCurrent in interfaces)
{
if (pCurrent.GetOwningAggregate() == pDest.GetOwningAggregate())
{
if (pInterface == null)
{
pInterface = pCurrent;
}
else if (pInterface != pCurrent)
{
// Not unique. Bail out.
return false;
}
}
}
if (pInterface == null)
{
return false;
}
LowerBoundTypeArgumentInference(pInterface, pDest);
return true;
}
private static bool CheckSingleConstraint(CSemanticChecker checker, ErrorHandling errHandling, Symbol symErr, TypeParameterType var, CType arg, TypeArray typeArgsCls, TypeArray typeArgsMeth, CheckConstraintsFlags flags)
{
bool fReportErrors = 0 == (flags & CheckConstraintsFlags.NoErrors);
if (arg.IsOpenTypePlaceholderType())
{
return true;
}
if (arg.IsErrorType())
{
// Error should have been reported previously.
return false;
}
if (checker.CheckBogus(arg))
{
if (fReportErrors)
{
errHandling.ErrorRef(ErrorCode.ERR_BogusType, arg);
}
return false;
}
if (arg.IsPointerType() || arg.isSpecialByRefType())
{
if (fReportErrors)
{
errHandling.Error(ErrorCode.ERR_BadTypeArgument, arg);
}
return false;
}
if (arg.isStaticClass())
{
if (fReportErrors)
{
checker.ReportStaticClassError(null, arg, ErrorCode.ERR_GenericArgIsStaticClass);
}
return false;
}
bool fError = false;
if (var.HasRefConstraint() && !arg.IsRefType())
{
if (fReportErrors)
{
errHandling.ErrorRef(ErrorCode.ERR_RefConstraintNotSatisfied, symErr, new ErrArgNoRef(var), arg);
}
fError = true;
}
TypeArray bnds = checker.GetSymbolLoader().GetTypeManager().SubstTypeArray(var.GetBounds(), typeArgsCls, typeArgsMeth);
int itypeMin = 0;
if (var.HasValConstraint())
{
// If we have a type variable that is constrained to a value type, then we
// want to check if its a nullable type, so that we can report the
// constraint error below. In order to do this however, we need to check
// that either the type arg is not a value type, or it is a nullable type.
//
// To check whether or not its a nullable type, we need to get the resolved
// bound from the type argument and check against that.
bool bIsValueType = arg.IsValType();
bool bIsNullable = arg.IsNullableType();
if (bIsValueType && arg.IsTypeParameterType())
{
TypeArray pArgBnds = arg.AsTypeParameterType().GetBounds();
if (pArgBnds.size > 0)
{
bIsNullable = pArgBnds.Item(0).IsNullableType();
}
}
if (!bIsValueType || bIsNullable)
{
if (fReportErrors)
{
errHandling.ErrorRef(ErrorCode.ERR_ValConstraintNotSatisfied, symErr, new ErrArgNoRef(var), arg);
}
fError = true;
}
// Since FValCon() is set it is redundant to check System.ValueType as well.
if (bnds.size != 0 && bnds.Item(0).isPredefType(PredefinedType.PT_VALUE))
{
itypeMin = 1;
}
}
for (int j = itypeMin; j < bnds.size; j++)
{
CType typeBnd = bnds.Item(j);
if (!SatisfiesBound(checker, arg, typeBnd))
{
if (fReportErrors)
{
// The bound isn't satisfied because of a constaint type. Explain to the user why not.
// There are 4 main cases, based on the type of the supplied type argument:
// - reference type, or type parameter known to be a reference type
// - nullable type, from which there is a boxing conversion to the constraint type(see below for details)
// - type varaiable
// - value type
// These cases are broken out because: a) The sets of conversions which can be used
// for constraint satisfaction is different based on the type argument supplied,
// and b) Nullable is one funky type, and user's can use all the help they can get
// when using it.
ErrorCode error;
if (arg.IsRefType())
{
// A reference type can only satisfy bounds to types
// to which they have an implicit reference conversion
error = ErrorCode.ERR_GenericConstraintNotSatisfiedRefType;
}
else if (arg.IsNullableType() && checker.GetSymbolLoader().HasBaseConversion(arg.AsNullableType().GetUnderlyingType(), typeBnd)) // This is inlining FBoxingConv
{
// nullable types do not satisfy bounds to every type that they are boxable to
// They only satisfy bounds of object and ValueType
if (typeBnd.isPredefType(PredefinedType.PT_ENUM) || arg.AsNullableType().GetUnderlyingType() == typeBnd)
{
// Nullable types don't satisfy bounds of EnumType, or the underlying type of the enum
// even though the conversion from Nullable to these types is a boxing conversion
// This is a rare case, because these bounds can never be directly stated ...
// These bounds can only occur when one type paramter is constrained to a second type parameter
// and the second type parameter is instantiated with Enum or the underlying type of the first type
// parameter
error = ErrorCode.ERR_GenericConstraintNotSatisfiedNullableEnum;
}
else
{
// Nullable types don't satisfy the bounds of any interface type
// even when there is a boxing conversion from the Nullable type to
// the interface type. This will be a relatively common scenario
// so we cal it out separately from the previous case.
Debug.Assert(typeBnd.isInterfaceType());
error = ErrorCode.ERR_GenericConstraintNotSatisfiedNullableInterface;
}
}
else if (arg.IsTypeParameterType())
{
// Type variables can satisfy bounds through boxing and type variable conversions
Debug.Assert(!arg.IsRefType());
error = ErrorCode.ERR_GenericConstraintNotSatisfiedTyVar;
}
else
{
// Value types can only satisfy bounds through boxing conversions.
// Note that the exceptional case of Nullable types and boxing is handled above.
error = ErrorCode.ERR_GenericConstraintNotSatisfiedValType;
}
errHandling.Error(error, new ErrArgRef(symErr), new ErrArg(typeBnd, ErrArgFlags.Unique), var, new ErrArgRef(arg, ErrArgFlags.Unique));
}
fError = true;
}
}
// Check the newable constraint.
if (!var.HasNewConstraint() || arg.IsValType())
{
return !fError;
}
if (arg.isClassType())
{
AggregateSymbol agg = arg.AsAggregateType().getAggregate();
// Due to late binding nature of IDE created symbols, the AggregateSymbol might not
// have all the information necessary yet, if it is not fully bound.
// by calling LookupAggMember, it will ensure that we will update all the
// information necessary at least for the given method.
checker.GetSymbolLoader().LookupAggMember(checker.GetNameManager().GetPredefName(PredefinedName.PN_CTOR), agg, symbmask_t.MASK_ALL);
if (agg.HasPubNoArgCtor() && !agg.IsAbstract())
{
return !fError;
}
}
else if (arg.IsTypeParameterType() && arg.AsTypeParameterType().HasNewConstraint())
{
return !fError;
}
if (fReportErrors)
{
errHandling.ErrorRef(ErrorCode.ERR_NewConstraintNotSatisfied, symErr, new ErrArgNoRef(var), arg);
}
return false;
}
//
// SymbolLoader forwarders (end)
/////////////////////////////////////////////////////////////////////////////////
//
// Utility methods
//
protected ACCESSERROR CheckAccessCore(Symbol symCheck, AggregateType atsCheck, Symbol symWhere, CType typeThru)
{
Debug.Assert(symCheck != null);
Debug.Assert(atsCheck == null || symCheck.parent == atsCheck.getAggregate());
Debug.Assert(typeThru == null ||
typeThru.IsAggregateType() ||
typeThru.IsTypeParameterType() ||
typeThru.IsArrayType() ||
typeThru.IsNullableType() ||
typeThru.IsErrorType());
switch (symCheck.GetAccess())
{
default:
throw Error.InternalCompilerError();
//return ACCESSERROR.ACCESSERROR_NOACCESS;
case ACCESS.ACC_UNKNOWN:
return ACCESSERROR.ACCESSERROR_NOACCESS;
case ACCESS.ACC_PUBLIC:
return ACCESSERROR.ACCESSERROR_NOERROR;
case ACCESS.ACC_PRIVATE:
case ACCESS.ACC_PROTECTED:
if (symWhere == null)
{
return ACCESSERROR.ACCESSERROR_NOACCESS;
}
break;
case ACCESS.ACC_INTERNAL:
case ACCESS.ACC_INTERNALPROTECTED: // Check internal, then protected.
if (symWhere == null)
{
return ACCESSERROR.ACCESSERROR_NOACCESS;
}
if (symWhere.SameAssemOrFriend(symCheck))
{
return ACCESSERROR.ACCESSERROR_NOERROR;
}
if (symCheck.GetAccess() == ACCESS.ACC_INTERNAL)
{
return ACCESSERROR.ACCESSERROR_NOACCESS;
}
break;
}
// Should always have atsCheck for private and protected access check.
// We currently don't need it since access doesn't respect instantiation.
// We just use symWhere.parent.AsAggregateSymbol() instead.
AggregateSymbol aggCheck = symCheck.parent.AsAggregateSymbol();
// Find the inner-most enclosing AggregateSymbol.
AggregateSymbol aggWhere = null;
for (Symbol symT = symWhere; symT != null; symT = symT.parent)
{
if (symT.IsAggregateSymbol())
{
aggWhere = symT.AsAggregateSymbol();
break;
}
if (symT.IsAggregateDeclaration())
{
aggWhere = symT.AsAggregateDeclaration().Agg();
break;
}
}
if (aggWhere == null)
{
return ACCESSERROR.ACCESSERROR_NOACCESS;
}
// First check for private access.
for (AggregateSymbol agg = aggWhere; agg != null; agg = agg.GetOuterAgg())
{
if (agg == aggCheck)
{
return ACCESSERROR.ACCESSERROR_NOERROR;
}
}
if (symCheck.GetAccess() == ACCESS.ACC_PRIVATE)
{
return ACCESSERROR.ACCESSERROR_NOACCESS;
}
// Handle the protected case - which is the only real complicated one.
Debug.Assert(symCheck.GetAccess() == ACCESS.ACC_PROTECTED || symCheck.GetAccess() == ACCESS.ACC_INTERNALPROTECTED);
// Check if symCheck is in aggWhere or a base of aggWhere,
// or in an outer agg of aggWhere or a base of an outer agg of aggWhere.
AggregateType atsThru = null;
if (typeThru != null && !symCheck.isStatic)
{
atsThru = SymbolLoader.GetAggTypeSym(typeThru);
}
// Look for aggCheck among the base classes of aggWhere and outer aggs.
bool found = false;
for (AggregateSymbol agg = aggWhere; agg != null; agg = agg.GetOuterAgg())
{
Debug.Assert(agg != aggCheck); // We checked for this above.
// Look for aggCheck among the base classes of agg.
if (agg.FindBaseAgg(aggCheck))
{
found = true;
// aggCheck is a base class of agg. Check atsThru.
// For non-static protected access to be legal, atsThru must be an instantiation of
// agg or a CType derived from an instantiation of agg. In this case
// all that matters is that agg is in the base AggregateSymbol chain of atsThru. The
// actual AGGTYPESYMs involved don't matter.
if (atsThru == null || atsThru.getAggregate().FindBaseAgg(agg))
{
return ACCESSERROR.ACCESSERROR_NOERROR;
}
}
}
// the CType in which the method is being called has no relationship with the
// CType on which the method is defined surely this is NOACCESS and not NOACCESSTHRU
if (found == false)
return ACCESSERROR.ACCESSERROR_NOACCESS;
return (atsThru == null) ? ACCESSERROR.ACCESSERROR_NOACCESS : ACCESSERROR.ACCESSERROR_NOACCESSTHRU;
}
////////////////////////////////////////////////////////////////////////////////
// Determine whether the arg type satisfies the typeBnd constraint. Note that
// typeBnd could be just about any type (since we added naked type parameter
// constraints).
private static bool SatisfiesBound(CSemanticChecker checker, CType arg, CType typeBnd)
{
if (typeBnd == arg)
return true;
switch (typeBnd.GetTypeKind())
{
default:
Debug.Assert(false, "Unexpected type.");
return false;
case TypeKind.TK_VoidType:
case TypeKind.TK_PointerType:
case TypeKind.TK_ErrorType:
return false;
case TypeKind.TK_ArrayType:
case TypeKind.TK_TypeParameterType:
break;
case TypeKind.TK_NullableType:
typeBnd = typeBnd.AsNullableType().GetAts(checker.GetErrorContext());
if (null == typeBnd)
return true;
break;
case TypeKind.TK_AggregateType:
break;
}
Debug.Assert(typeBnd.IsAggregateType() || typeBnd.IsTypeParameterType() || typeBnd.IsArrayType());
switch (arg.GetTypeKind())
{
default:
return false;
case TypeKind.TK_ErrorType:
case TypeKind.TK_PointerType:
return false;
case TypeKind.TK_NullableType:
arg = arg.AsNullableType().GetAts(checker.GetErrorContext());
if (null == arg)
return true;
// Fall through.
goto case TypeKind.TK_TypeParameterType;
case TypeKind.TK_TypeParameterType:
case TypeKind.TK_ArrayType:
case TypeKind.TK_AggregateType:
return checker.GetSymbolLoader().HasBaseConversion(arg, typeBnd);
}
}
public virtual bool CheckTypeAccess(CType type, Symbol symWhere)
{
Debug.Assert(type != null);
// Array, Ptr, Nub, etc don't matter.
type = type.GetNakedType(true);
if (!type.IsAggregateType())
{
Debug.Assert(type.IsVoidType() || type.IsErrorType() || type.IsTypeParameterType());
return true;
}
for (AggregateType ats = type.AsAggregateType(); ats != null; ats = ats.outerType)
{
if (ACCESSERROR.ACCESSERROR_NOERROR != CheckAccessCore(ats.GetOwningAggregate(), ats.outerType, symWhere, null))
{
return false;
}
}
TypeArray typeArgs = type.AsAggregateType().GetTypeArgsAll();
for (int i = 0; i < typeArgs.size; i++)
{
if (!CheckTypeAccess(typeArgs.Item(i), symWhere))
return false;
}
return true;
}
public bool HasImplicitBoxingConversion(CType pSource, CType pDest)
{
Debug.Assert(pSource != null);
Debug.Assert(pDest != null);
// Certain type parameter conversions are classified as boxing conversions.
if (pSource.IsTypeParameterType() &&
HasImplicitBoxingTypeParameterConversion(pSource.AsTypeParameterType(), pDest))
{
return true;
}
// The rest of the boxing conversions only operate when going from a value type
// to a reference type.
if (!pSource.IsValType() || !pDest.IsRefType())
{
return false;
}
// A boxing conversion exists from a nullable type to a reference type
// if and only if a boxing conversion exists from the underlying type.
if (pSource.IsNullableType())
{
return HasImplicitBoxingConversion(pSource.AsNullableType().GetUnderlyingType(), pDest);
}
// A boxing conversion exists from any non-nullable value type to object,
// to System.ValueType, and to any interface type implemented by the
// non-nullable value type. Furthermore, an enum type can be converted
// to the type System.Enum.
// We set the base class of the structs to System.ValueType, System.Enum, etc,
// so we can just check here.
if (IsBaseClass(pSource, pDest))
{
return true;
}
if (HasAnyBaseInterfaceConversion(pSource, pDest))
{
return true;
}
return false;
}
/***************************************************************************************************
* Lookup must be called before anything else can be called.
*
* typeSrc - Must be an AggregateType or TypeParameterType.
* obj - the expression through which the member is being accessed. This is used for accessibility
* of protected members and for constructing a MEMGRP from the results of the lookup.
* It is legal for obj to be an EK_CLASS, in which case it may be used for accessibility, but
* will not be used for MEMGRP construction.
* symWhere - the symbol from with the name is being accessed (for checking accessibility).
* name - the name to look for.
* arity - the number of type args specified. Only members that support this arity are found.
* Note that when arity is zero, all methods are considered since we do type argument
* inferencing.
*
* flags - See MemLookFlags.
* TypeVarsAllowed only applies to the most derived type (not base types).
***************************************************************************************************/
public bool Lookup(CSemanticChecker checker, CType typeSrc, EXPR obj, ParentSymbol symWhere, Name name, int arity, MemLookFlags flags)
{
Debug.Assert((flags & ~MemLookFlags.All) == 0);
Debug.Assert(obj == null || obj.type != null);
Debug.Assert(typeSrc.IsAggregateType() || typeSrc.IsTypeParameterType());
Debug.Assert(checker != null);
_prgtype = _rgtypeStart;
// Save the inputs for error handling, etc.
_pSemanticChecker = checker;
_pSymbolLoader = checker.GetSymbolLoader();
_typeSrc = typeSrc;
_obj = (obj != null && !obj.isCLASS()) ? obj : null;
_symWhere = symWhere;
_name = name;
_arity = arity;
_flags = flags;
if ((_flags & MemLookFlags.BaseCall) != 0)
{
_typeQual = null;
}
else if ((_flags & MemLookFlags.Ctor) != 0)
{
_typeQual = _typeSrc;
}
else if (obj != null)
{
_typeQual = (CType)obj.type;
}
else
{
_typeQual = null;
}
// Determine what to search.
AggregateType typeCls1 = null;
AggregateType typeIface = null;
TypeArray ifaces = BSYMMGR.EmptyTypeArray();
AggregateType typeCls2 = null;
if (typeSrc.IsTypeParameterType())
{
Debug.Assert((_flags & (MemLookFlags.Ctor | MemLookFlags.NewObj | MemLookFlags.Operator | MemLookFlags.BaseCall | MemLookFlags.TypeVarsAllowed)) == 0);
_flags &= ~MemLookFlags.TypeVarsAllowed;
ifaces = typeSrc.AsTypeParameterType().GetInterfaceBounds();
typeCls1 = typeSrc.AsTypeParameterType().GetEffectiveBaseClass();
if (ifaces.size > 0 && typeCls1.isPredefType(PredefinedType.PT_OBJECT))
{
typeCls1 = null;
}
}
else if (!typeSrc.isInterfaceType())
{
typeCls1 = typeSrc.AsAggregateType();
if (typeCls1.IsWindowsRuntimeType())
{
ifaces = typeCls1.GetWinRTCollectionIfacesAll(GetSymbolLoader());
}
}
else
{
Debug.Assert(typeSrc.isInterfaceType());
Debug.Assert((_flags & (MemLookFlags.Ctor | MemLookFlags.NewObj | MemLookFlags.Operator | MemLookFlags.BaseCall)) == 0);
typeIface = typeSrc.AsAggregateType();
ifaces = typeIface.GetIfacesAll();
}
if (typeIface != null || ifaces.size > 0)
{
typeCls2 = GetSymbolLoader().GetReqPredefType(PredefinedType.PT_OBJECT);
}
// Search the class first (except possibly object).
if (typeCls1 == null || LookupInClass(typeCls1, ref typeCls2))
{
// Search the interfaces.
if ((typeIface != null || ifaces.size > 0) && LookupInInterfaces(typeIface, ifaces) && typeCls2 != null)
{
// Search object last.
Debug.Assert(typeCls2 != null && typeCls2.isPredefType(PredefinedType.PT_OBJECT));
AggregateType result = null;
LookupInClass(typeCls2, ref result);
}
}
// if we are requested with extension methods
_results = new CMemberLookupResults(GetAllTypes(), _name);
return(!FError());
}
/***************************************************************************************************
Lookup must be called before anything else can be called.
typeSrc - Must be an AggregateType or TypeParameterType.
obj - the expression through which the member is being accessed. This is used for accessibility
of protected members and for constructing a MEMGRP from the results of the lookup.
It is legal for obj to be an EK_CLASS, in which case it may be used for accessibility, but
will not be used for MEMGRP construction.
symWhere - the symbol from with the name is being accessed (for checking accessibility).
name - the name to look for.
arity - the number of type args specified. Only members that support this arity are found.
Note that when arity is zero, all methods are considered since we do type argument
inferencing.
flags - See MemLookFlags.
TypeVarsAllowed only applies to the most derived type (not base types).
***************************************************************************************************/
public bool Lookup(CSemanticChecker checker, CType typeSrc, EXPR obj, ParentSymbol symWhere, Name name, int arity, MemLookFlags flags)
{
Debug.Assert((flags & ~MemLookFlags.All) == 0);
Debug.Assert(obj == null || obj.type != null);
Debug.Assert(typeSrc.IsAggregateType() || typeSrc.IsTypeParameterType());
Debug.Assert(checker != null);
_prgtype = _rgtypeStart;
// Save the inputs for error handling, etc.
_pSemanticChecker = checker;
_pSymbolLoader = checker.GetSymbolLoader();
_typeSrc = typeSrc;
_obj = (obj != null && !obj.isCLASS()) ? obj : null;
_symWhere = symWhere;
_name = name;
_arity = arity;
_flags = flags;
if ((_flags & MemLookFlags.BaseCall) != 0)
_typeQual = null;
else if ((_flags & MemLookFlags.Ctor) != 0)
_typeQual = _typeSrc;
else if (obj != null)
_typeQual = (CType)obj.type;
else
_typeQual = null;
// Determine what to search.
AggregateType typeCls1 = null;
AggregateType typeIface = null;
TypeArray ifaces = BSYMMGR.EmptyTypeArray();
AggregateType typeCls2 = null;
if (typeSrc.IsTypeParameterType())
{
Debug.Assert((_flags & (MemLookFlags.Ctor | MemLookFlags.NewObj | MemLookFlags.Operator | MemLookFlags.BaseCall | MemLookFlags.TypeVarsAllowed)) == 0);
_flags &= ~MemLookFlags.TypeVarsAllowed;
ifaces = typeSrc.AsTypeParameterType().GetInterfaceBounds();
typeCls1 = typeSrc.AsTypeParameterType().GetEffectiveBaseClass();
if (ifaces.size > 0 && typeCls1.isPredefType(PredefinedType.PT_OBJECT))
typeCls1 = null;
}
else if (!typeSrc.isInterfaceType())
{
typeCls1 = typeSrc.AsAggregateType();
if (typeCls1.IsWindowsRuntimeType())
{
ifaces = typeCls1.GetWinRTCollectionIfacesAll(GetSymbolLoader());
}
}
else
{
Debug.Assert(typeSrc.isInterfaceType());
Debug.Assert((_flags & (MemLookFlags.Ctor | MemLookFlags.NewObj | MemLookFlags.Operator | MemLookFlags.BaseCall)) == 0);
typeIface = typeSrc.AsAggregateType();
ifaces = typeIface.GetIfacesAll();
}
if (typeIface != null || ifaces.size > 0)
typeCls2 = GetSymbolLoader().GetReqPredefType(PredefinedType.PT_OBJECT);
// Search the class first (except possibly object).
if (typeCls1 == null || LookupInClass(typeCls1, ref typeCls2))
{
// Search the interfaces.
if ((typeIface != null || ifaces.size > 0) && LookupInInterfaces(typeIface, ifaces) && typeCls2 != null)
{
// Search object last.
Debug.Assert(typeCls2 != null && typeCls2.isPredefType(PredefinedType.PT_OBJECT));
AggregateType result = null;
LookupInClass(typeCls2, ref result);
}
}
// if we are requested with extension methods
_results = new CMemberLookupResults(GetAllTypes(), _name);
return !FError();
}
