private bool bindImplicitConversionToBase(AggregateType pSource)
{
// 13.1.4 Implicit reference conversions
//
// * From any reference-type to object.
// * From any class-type S to any class-type T, provided S is derived from T.
// * From any class-type S to any interface-type T, provided S implements T.
// * From any interface-type S to any interface-type T, provided S is derived from T.
// * From any delegate-type to System.Delegate.
// * From any delegate-type to System.ICloneable.
if (!typeDest.IsAggregateType() || !GetSymbolLoader().HasBaseConversion(pSource, typeDest))
{
return(false);
}
EXPRFLAG flags = 0x00;
if (pSource.getAggregate().IsStruct() && typeDest.fundType() == FUNDTYPE.FT_REF)
{
flags = EXPRFLAG.EXF_BOX | EXPRFLAG.EXF_CANTBENULL;
}
else if (exprSrc != null)
{
flags = exprSrc.flags & EXPRFLAG.EXF_CANTBENULL;
}
if (needsExprDest)
{
binder.bindSimpleCast(exprSrc, exprTypeDest, out exprDest, flags);
}
return(true);
}
public ImplicitConversion(ExpressionBinder binder, Expr exprSrc, CType typeSrc, CType typeDest, bool needsExprDest, CONVERTTYPE flags)
{
_binder = binder;
_exprSrc = exprSrc;
_typeSrc = typeSrc;
_typeDest = typeDest;
_needsExprDest = needsExprDest;
_flags = flags;
_exprDest = null;
}
public ImplicitConversion(ExpressionBinder binder, EXPR exprSrc, CType typeSrc, EXPRTYPEORNAMESPACE typeDest, bool needsExprDest, CONVERTTYPE flags)
{
_binder = binder;
_exprSrc = exprSrc;
_typeSrc = typeSrc;
_typeDest = typeDest.TypeOrNamespace.AsType();
_exprTypeDest = typeDest;
_needsExprDest = needsExprDest;
_flags = flags;
_exprDest = null;
}
public ImplicitConversion(ExpressionBinder binder, EXPR exprSrc, CType typeSrc, EXPRTYPEORNAMESPACE typeDest, bool needsExprDest, CONVERTTYPE flags)
{
_binder = binder;
_exprSrc = exprSrc;
_typeSrc = typeSrc;
_typeDest = typeDest.TypeOrNamespace.AsType();
_exprTypeDest = typeDest;
_needsExprDest = needsExprDest;
_flags = flags;
_exprDest = null;
}
// ----------------------------------------------------------------------------
// BindExplicitConversion
// ----------------------------------------------------------------------------
public ExplicitConversion(ExpressionBinder binder, Expr exprSrc, CType typeSrc, ExprClass typeDest, CType pDestinationTypeForLambdaErrorReporting, bool needsExprDest, CONVERTTYPE flags)
{
_binder = binder;
_exprSrc = exprSrc;
_typeSrc = typeSrc;
_typeDest = typeDest.Type;
_pDestinationTypeForLambdaErrorReporting = pDestinationTypeForLambdaErrorReporting;
_exprTypeDest = typeDest;
_needsExprDest = needsExprDest;
_flags = flags;
_exprDest = null;
}
// ----------------------------------------------------------------------------
// BindExplicitConversion
// ----------------------------------------------------------------------------
public ExplicitConversion(ExpressionBinder binder, EXPR exprSrc, CType typeSrc, EXPRTYPEORNAMESPACE typeDest, CType pDestinationTypeForLambdaErrorReporting, bool needsExprDest, CONVERTTYPE flags)
{
_binder = binder;
_exprSrc = exprSrc;
_typeSrc = typeSrc;
_typeDest = typeDest.TypeOrNamespace.AsType();
_pDestinationTypeForLambdaErrorReporting = pDestinationTypeForLambdaErrorReporting;
_exprTypeDest = typeDest;
_needsExprDest = needsExprDest;
_flags = flags;
_exprDest = null;
}
// ----------------------------------------------------------------------------
// BindExplicitConversion
// ----------------------------------------------------------------------------
public ExplicitConversion(ExpressionBinder binder, EXPR exprSrc, CType typeSrc, EXPRTYPEORNAMESPACE typeDest, CType pDestinationTypeForLambdaErrorReporting, bool needsExprDest, CONVERTTYPE flags)
{
_binder = binder;
_exprSrc = exprSrc;
_typeSrc = typeSrc;
_typeDest = typeDest.TypeOrNamespace.AsType();
_pDestinationTypeForLambdaErrorReporting = pDestinationTypeForLambdaErrorReporting;
_exprTypeDest = typeDest;
_needsExprDest = needsExprDest;
_flags = flags;
_exprDest = null;
}
/*
* BindImplicitConversion
*
* This is a complex routine with complex parameters. Generally, this should
* be called through one of the helper methods that insulates you
* from the complexity of the interface. This routine handles all the logic
* associated with implicit conversions.
*
* exprSrc - the expression being converted. Can be null if only type conversion
* info is being supplied.
* typeSrc - type of the source
* typeDest - type of the destination
* exprDest - returns an expression of the src converted to the dest. If null, we
* only care about whether the conversion can be attempted, not the
* expression tree.
* flags - flags possibly customizing the conversions allowed. E.g., can suppress
* user-defined conversions.
*
* returns true if the conversion can be made, false if not.
*/
public bool Bind()
{
// 13.1 Implicit conversions
//
// The following conversions are classified as implicit conversions:
//
// * Identity conversions
// * Implicit numeric conversions
// * Implicit enumeration conversions
// * Implicit reference conversions
// * Boxing conversions
// * Implicit type parameter conversions
// * Implicit constant expression conversions
// * User-defined implicit conversions
// * Implicit conversions from an anonymous method expression to a compatible delegate type
// * Implicit conversion from a method group to a compatible delegate type
// * Conversions from the null type (11.2.7) to any nullable type
// * Implicit nullable conversions
// * Lifted user-defined implicit conversions
//
// Implicit conversions can occur in a variety of situations, including function member invocations
// (14.4.3), cast expressions (14.6.6), and assignments (14.14).
// Can't convert to or from the error type.
if (_typeSrc == null || _typeDest == null || _typeDest.IsNeverSameType())
{
return(false);
}
Debug.Assert(_typeSrc != null && _typeDest != null); // types must be supplied.
Debug.Assert(_exprSrc == null || _typeSrc == _exprSrc.Type); // type of source should be correct if source supplied
Debug.Assert(!_needsExprDest || _exprSrc != null); // need source expr to create dest expr
switch (_typeDest.GetTypeKind())
{
case TypeKind.TK_ErrorType:
Debug.Assert(((ErrorType)_typeDest).HasParent);
if (_typeSrc != _typeDest)
{
return(false);
}
if (_needsExprDest)
{
_exprDest = _exprSrc;
}
return(true);
case TypeKind.TK_NullType:
// Can only convert to the null type if src is null.
if (!(_typeSrc is NullType))
{
return(false);
}
if (_needsExprDest)
{
_exprDest = _exprSrc;
}
return(true);
case TypeKind.TK_MethodGroupType:
Debug.Fail("Something is wrong with Type.IsNeverSameType()");
return(false);
case TypeKind.TK_ArgumentListType:
return(_typeSrc == _typeDest);
case TypeKind.TK_VoidType:
return(false);
default:
break;
}
if (_typeSrc is ErrorType)
{
Debug.Assert(!(_typeDest is ErrorType));
return(false);
}
// 13.1.1 Identity conversion
//
// An identity conversion converts from any type to the same type. This conversion exists only
// such that an entity that already has a required type can be said to be convertible to that type.
if (_typeSrc == _typeDest &&
((_flags & CONVERTTYPE.ISEXPLICIT) == 0 || (!_typeSrc.isPredefType(PredefinedType.PT_FLOAT) && !_typeSrc.isPredefType(PredefinedType.PT_DOUBLE))))
{
if (_needsExprDest)
{
_exprDest = _exprSrc;
}
return(true);
}
if (_typeDest is NullableType nubDest)
{
return(BindNubConversion(nubDest));
}
if (_typeSrc is NullableType nubSrc)
{
return(bindImplicitConversionFromNullable(nubSrc));
}
if ((_flags & CONVERTTYPE.ISEXPLICIT) != 0)
{
_flags |= CONVERTTYPE.NOUDC;
}
// Get the fundamental types of destination.
FUNDTYPE ftDest = _typeDest.fundType();
Debug.Assert(ftDest != FUNDTYPE.FT_NONE || _typeDest is ParameterModifierType);
switch (_typeSrc.GetTypeKind())
{
default:
Debug.Fail($"Bad type symbol kind: {_typeSrc.GetTypeKind()}");
break;
case TypeKind.TK_VoidType:
case TypeKind.TK_ErrorType:
case TypeKind.TK_ParameterModifierType:
case TypeKind.TK_ArgumentListType:
return(false);
case TypeKind.TK_NullType:
if (bindImplicitConversionFromNull())
{
return(true);
}
// If not, try user defined implicit conversions.
break;
case TypeKind.TK_ArrayType:
if (bindImplicitConversionFromArray())
{
return(true);
}
// If not, try user defined implicit conversions.
break;
case TypeKind.TK_PointerType:
if (bindImplicitConversionFromPointer())
{
return(true);
}
// If not, try user defined implicit conversions.
break;
case TypeKind.TK_AggregateType:
if (bindImplicitConversionFromAgg(_typeSrc as AggregateType))
{
return(true);
}
// If not, try user defined implicit conversions.
break;
}
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// RUNTIME BINDER ONLY CHANGE
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//
// Every incoming dynamic operand should be implicitly convertible
// to any type that it is an instance of.
object srcRuntimeObject = _exprSrc?.RuntimeObject;
if (srcRuntimeObject != null &&
_typeDest.AssociatedSystemType.IsInstanceOfType(srcRuntimeObject) &&
_binder.GetSemanticChecker().CheckTypeAccess(_typeDest, _binder.Context.ContextForMemberLookup))
{
if (_needsExprDest)
{
_binder.bindSimpleCast(_exprSrc, _typeDest, out _exprDest, _exprSrc.Flags & EXPRFLAG.EXF_CANTBENULL);
}
return(true);
}
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// END RUNTIME BINDER ONLY CHANGE
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// 13.1.8 User-defined implicit conversions
//
// A user-defined implicit conversion consists of an optional standard implicit conversion,
// followed by execution of a user-defined implicit conversion operator, followed by another
// optional standard implicit conversion. The exact rules for evaluating user-defined
// conversions are described in 13.4.3.
if (0 == (_flags & CONVERTTYPE.NOUDC))
{
return(_binder.bindUserDefinedConversion(_exprSrc, _typeSrc, _typeDest, _needsExprDest, out _exprDest, true));
}
// No conversion was found.
return(false);
}
/*
* BindImplicitConversion
*
* This is a complex routine with complex parameters. Generally, this should
* be called through one of the helper methods that insulates you
* from the complexity of the interface. This routine handles all the logic
* associated with implicit conversions.
*
* exprSrc - the expression being converted. Can be null if only type conversion
* info is being supplied.
* typeSrc - type of the source
* typeDest - type of the destination
* exprDest - returns an expression of the src converted to the dest. If null, we
* only care about whether the conversion can be attempted, not the
* expression tree.
* flags - flags possibly customizing the conversions allowed. E.g., can suppress
* user-defined conversions.
*
* returns true if the conversion can be made, false if not.
*/
public bool Bind()
{
// 13.1 Implicit conversions
//
// The following conversions are classified as implicit conversions:
//
// * Identity conversions
// * Implicit numeric conversions
// * Implicit enumeration conversions
// * Implicit reference conversions
// * Boxing conversions
// * Implicit type parameter conversions
// * Implicit constant expression conversions
// * User-defined implicit conversions
// * Implicit conversions from an anonymous method expression to a compatible delegate type
// * Implicit conversion from a method group to a compatible delegate type
// * Conversions from the null type (11.2.7) to any nullable type
// * Implicit nullable conversions
// * Lifted user-defined implicit conversions
//
// Implicit conversions can occur in a variety of situations, including function member invocations
// (14.4.3), cast expressions (14.6.6), and assignments (14.14).
// Can't convert to or from the error type.
if (typeSrc == null || typeDest == null || typeDest.IsNeverSameType())
{
return(false);
}
Debug.Assert(typeSrc != null && typeDest != null); // types must be supplied.
Debug.Assert(exprSrc == null || typeSrc == exprSrc.type); // type of source should be correct if source supplied
Debug.Assert(!needsExprDest || exprSrc != null); // need source expr to create dest expr
switch (typeDest.GetTypeKind())
{
case TypeKind.TK_ErrorType:
Debug.Assert(typeDest.AsErrorType().HasTypeParent() || typeDest.AsErrorType().HasNSParent());
if (typeSrc != typeDest)
{
return(false);
}
if (needsExprDest)
{
exprDest = exprSrc;
}
return(true);
case TypeKind.TK_NullType:
// Can only convert to the null type if src is null.
if (!typeSrc.IsNullType())
{
return(false);
}
if (needsExprDest)
{
exprDest = exprSrc;
}
return(true);
case TypeKind.TK_MethodGroupType:
VSFAIL("Something is wrong with Type.IsNeverSameType()");
return(false);
case TypeKind.TK_NaturalIntegerType:
case TypeKind.TK_ArgumentListType:
return(typeSrc == typeDest);
case TypeKind.TK_VoidType:
return(false);
default:
break;
}
if (typeSrc.IsErrorType())
{
Debug.Assert(!typeDest.IsErrorType());
return(false);
}
// 13.1.1 Identity conversion
//
// An identity conversion converts from any type to the same type. This conversion exists only
// such that an entity that already has a required type can be said to be convertible to that type.
if (typeSrc == typeDest &&
((flags & CONVERTTYPE.ISEXPLICIT) == 0 || (!typeSrc.isPredefType(PredefinedType.PT_FLOAT) && !typeSrc.isPredefType(PredefinedType.PT_DOUBLE))))
{
if (needsExprDest)
{
exprDest = exprSrc;
}
return(true);
}
if (typeDest.IsNullableType())
{
return(BindNubConversion(typeDest.AsNullableType()));
}
if (typeSrc.IsNullableType())
{
return(bindImplicitConversionFromNullable(typeSrc.AsNullableType()));
}
if ((flags & CONVERTTYPE.ISEXPLICIT) != 0)
{
flags |= CONVERTTYPE.NOUDC;
}
// Get the fundamental types of destination.
FUNDTYPE ftDest = typeDest.fundType();
Debug.Assert(ftDest != FUNDTYPE.FT_NONE || typeDest.IsParameterModifierType());
switch (typeSrc.GetTypeKind())
{
default:
VSFAIL("Bad type symbol kind");
break;
case TypeKind.TK_MethodGroupType:
if (exprSrc.isMEMGRP())
{
EXPRCALL outExpr;
bool retVal = binder.BindGrpConversion(exprSrc.asMEMGRP(), typeDest, needsExprDest, out outExpr, false);
exprDest = outExpr;
return(retVal);
}
return(false);
case TypeKind.TK_VoidType:
case TypeKind.TK_ErrorType:
case TypeKind.TK_ParameterModifierType:
case TypeKind.TK_ArgumentListType:
return(false);
case TypeKind.TK_NullType:
if (bindImplicitConversionFromNull())
{
return(true);
}
// If not, try user defined implicit conversions.
break;
case TypeKind.TK_ArrayType:
if (bindImplicitConversionFromArray())
{
return(true);
}
// If not, try user defined implicit conversions.
break;
case TypeKind.TK_PointerType:
if (bindImplicitConversionFromPointer())
{
return(true);
}
// If not, try user defined implicit conversions.
break;
case TypeKind.TK_TypeParameterType:
if (bindImplicitConversionFromTypeVar(typeSrc.AsTypeParameterType()))
{
return(true);
}
// If not, try user defined implicit conversions.
break;
case TypeKind.TK_AggregateType:
// TypeReference and ArgIterator can't be boxed (or converted to anything else)
if (typeSrc.isSpecialByRefType())
{
return(false);
}
if (bindImplicitConversionFromAgg(typeSrc.AsAggregateType()))
{
return(true);
}
// If not, try user defined implicit conversions.
break;
}
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// RUNTIME BINDER ONLY CHANGE
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//
// Every incoming dynamic operand should be implicitly convertible
// to any type that it is an instance of.
if (exprSrc != null &&
exprSrc.RuntimeObject != null &&
typeDest.AssociatedSystemType.IsInstanceOfType(exprSrc.RuntimeObject) &&
binder.GetSemanticChecker().CheckTypeAccess(typeDest, binder.Context.ContextForMemberLookup()))
{
if (needsExprDest)
{
binder.bindSimpleCast(exprSrc, exprTypeDest, out exprDest, exprSrc.flags & EXPRFLAG.EXF_CANTBENULL);
}
return(true);
}
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// END RUNTIME BINDER ONLY CHANGE
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// 13.1.8 User-defined implicit conversions
//
// A user-defined implicit conversion consists of an optional standard implicit conversion,
// followed by execution of a user-defined implicit conversion operator, followed by another
// optional standard implicit conversion. The exact rules for evaluating user-defined
// conversions are described in 13.4.3.
if (0 == (flags & CONVERTTYPE.NOUDC))
{
return(binder.bindUserDefinedConversion(exprSrc, typeSrc, typeDest, needsExprDest, out exprDest, true));
}
// No conversion was found.
return(false);
}
/*
* BindImplicitConversion
*
* This is a complex routine with complex parameters. Generally, this should
* be called through one of the helper methods that insulates you
* from the complexity of the interface. This routine handles all the logic
* associated with implicit conversions.
*
* exprSrc - the expression being converted. Can be null if only type conversion
* info is being supplied.
* typeSrc - type of the source
* typeDest - type of the destination
* exprDest - returns an expression of the src converted to the dest. If null, we
* only care about whether the conversion can be attempted, not the
* expression tree.
* flags - flags possibly customizing the conversions allowed. E.g., can suppress
* user-defined conversions.
*
* returns true if the conversion can be made, false if not.
*/
public bool Bind()
{
// 13.1 Implicit conversions
//
// The following conversions are classified as implicit conversions:
//
// * Identity conversions
// * Implicit numeric conversions
// * Implicit enumeration conversions
// * Implicit reference conversions
// * Boxing conversions
// * Implicit type parameter conversions
// * Implicit constant expression conversions
// * User-defined implicit conversions
// * Implicit conversions from an anonymous method expression to a compatible delegate type
// * Implicit conversion from a method group to a compatible delegate type
// * Conversions from the null type (11.2.7) to any nullable type
// * Implicit nullable conversions
// * Lifted user-defined implicit conversions
//
// Implicit conversions can occur in a variety of situations, including function member invocations
// (14.4.3), cast expressions (14.6.6), and assignments (14.14).
// Can't convert to or from the error type.
if (_typeSrc == null || _typeDest == null || _typeDest.IsNeverSameType())
{
return false;
}
Debug.Assert(_typeSrc != null && _typeDest != null); // types must be supplied.
Debug.Assert(_exprSrc == null || _typeSrc == _exprSrc.type); // type of source should be correct if source supplied
Debug.Assert(!_needsExprDest || _exprSrc != null); // need source expr to create dest expr
switch (_typeDest.GetTypeKind())
{
case TypeKind.TK_ErrorType:
Debug.Assert(_typeDest.AsErrorType().HasTypeParent() || _typeDest.AsErrorType().HasNSParent());
if (_typeSrc != _typeDest)
{
return false;
}
if (_needsExprDest)
{
_exprDest = _exprSrc;
}
return true;
case TypeKind.TK_NullType:
// Can only convert to the null type if src is null.
if (!_typeSrc.IsNullType())
{
return false;
}
if (_needsExprDest)
{
_exprDest = _exprSrc;
}
return true;
case TypeKind.TK_MethodGroupType:
VSFAIL("Something is wrong with Type.IsNeverSameType()");
return false;
case TypeKind.TK_NaturalIntegerType:
case TypeKind.TK_ArgumentListType:
return _typeSrc == _typeDest;
case TypeKind.TK_VoidType:
return false;
default:
break;
}
if (_typeSrc.IsErrorType())
{
Debug.Assert(!_typeDest.IsErrorType());
return false;
}
// 13.1.1 Identity conversion
//
// An identity conversion converts from any type to the same type. This conversion exists only
// such that an entity that already has a required type can be said to be convertible to that type.
if (_typeSrc == _typeDest &&
((_flags & CONVERTTYPE.ISEXPLICIT) == 0 || (!_typeSrc.isPredefType(PredefinedType.PT_FLOAT) && !_typeSrc.isPredefType(PredefinedType.PT_DOUBLE))))
{
if (_needsExprDest)
{
_exprDest = _exprSrc;
}
return true;
}
if (_typeDest.IsNullableType())
{
return BindNubConversion(_typeDest.AsNullableType());
}
if (_typeSrc.IsNullableType())
{
return bindImplicitConversionFromNullable(_typeSrc.AsNullableType());
}
if ((_flags & CONVERTTYPE.ISEXPLICIT) != 0)
{
_flags |= CONVERTTYPE.NOUDC;
}
// Get the fundamental types of destination.
FUNDTYPE ftDest = _typeDest.fundType();
Debug.Assert(ftDest != FUNDTYPE.FT_NONE || _typeDest.IsParameterModifierType());
switch (_typeSrc.GetTypeKind())
{
default:
VSFAIL("Bad type symbol kind");
break;
case TypeKind.TK_MethodGroupType:
if (_exprSrc.isMEMGRP())
{
EXPRCALL outExpr;
bool retVal = _binder.BindGrpConversion(_exprSrc.asMEMGRP(), _typeDest, _needsExprDest, out outExpr, false);
_exprDest = outExpr;
return retVal;
}
return false;
case TypeKind.TK_VoidType:
case TypeKind.TK_ErrorType:
case TypeKind.TK_ParameterModifierType:
case TypeKind.TK_ArgumentListType:
return false;
case TypeKind.TK_NullType:
if (bindImplicitConversionFromNull())
{
return true;
}
// If not, try user defined implicit conversions.
break;
case TypeKind.TK_ArrayType:
if (bindImplicitConversionFromArray())
{
return true;
}
// If not, try user defined implicit conversions.
break;
case TypeKind.TK_PointerType:
if (bindImplicitConversionFromPointer())
{
return true;
}
// If not, try user defined implicit conversions.
break;
case TypeKind.TK_TypeParameterType:
if (bindImplicitConversionFromTypeVar(_typeSrc.AsTypeParameterType()))
{
return true;
}
// If not, try user defined implicit conversions.
break;
case TypeKind.TK_AggregateType:
// TypeReference and ArgIterator can't be boxed (or converted to anything else)
if (_typeSrc.isSpecialByRefType())
{
return false;
}
if (bindImplicitConversionFromAgg(_typeSrc.AsAggregateType()))
{
return true;
}
// If not, try user defined implicit conversions.
break;
}
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// RUNTIME BINDER ONLY CHANGE
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//
// Every incoming dynamic operand should be implicitly convertible
// to any type that it is an instance of.
if (_exprSrc != null
&& _exprSrc.RuntimeObject != null
&& _typeDest.AssociatedSystemType.IsInstanceOfType(_exprSrc.RuntimeObject)
&& _binder.GetSemanticChecker().CheckTypeAccess(_typeDest, _binder.Context.ContextForMemberLookup()))
{
if (_needsExprDest)
{
_binder.bindSimpleCast(_exprSrc, _exprTypeDest, out _exprDest, _exprSrc.flags & EXPRFLAG.EXF_CANTBENULL);
}
return true;
}
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// END RUNTIME BINDER ONLY CHANGE
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// 13.1.8 User-defined implicit conversions
//
// A user-defined implicit conversion consists of an optional standard implicit conversion,
// followed by execution of a user-defined implicit conversion operator, followed by another
// optional standard implicit conversion. The exact rules for evaluating user-defined
// conversions are described in 13.4.3.
if (0 == (_flags & CONVERTTYPE.NOUDC))
{
return _binder.bindUserDefinedConversion(_exprSrc, _typeSrc, _typeDest, _needsExprDest, out _exprDest, true);
}
// No conversion was found.
return false;
}
