/// <summary>
/// This method find the set of applicable user-defined and lifted conversion operators, u.
/// The set consists of the user-defined and lifted implicit conversion operators declared by
/// the classes and structs in d that convert from a type encompassing source to a type encompassed by target.
/// However if allowAnyTarget is true, then it considers all operators that convert from a type encompassing source
/// to any target. This flag must be set only if we are computing user defined conversions from a given source
/// type to any target type.
/// </summary>
/// <remarks>
/// Currently allowAnyTarget flag is only set to true by <see cref="AnalyzeImplicitUserDefinedConversionForV6SwitchGoverningType"/>,
/// where we must consider user defined implicit conversions from the type of the switch expression to
/// any of the possible switch governing types.
/// </remarks>
private void ComputeApplicableUserDefinedImplicitConversionSet(
BoundExpression sourceExpression,
TypeSymbol source,
TypeSymbol target,
ArrayBuilder <NamedTypeSymbol> d,
ArrayBuilder <UserDefinedConversionAnalysis> u,
ref HashSet <DiagnosticInfo> useSiteDiagnostics,
bool allowAnyTarget = false)
{
Debug.Assert(sourceExpression != null || (object)source != null);
Debug.Assert(((object)target != null) == !allowAnyTarget);
Debug.Assert(d != null);
Debug.Assert(u != null);
// SPEC: Find the set of applicable user-defined and lifted conversion operators, U.
// SPEC: The set consists of the user-defined and lifted implicit conversion operators
// SPEC: declared by the classes and structs in D that convert from a type encompassing
// SPEC: E to a type encompassed by T. If U is empty, the conversion is undefined and
// SPEC: a compile-time error occurs.
// SPEC: Give a user-defined conversion operator that converts from a non-nullable
// SPEC: value type S to a non-nullable value type T, a lifted conversion operator
// SPEC: exists that converts from S? to T?.
// DELIBERATE SPEC VIOLATION:
//
// The spec here essentially says that we add an applicable "regular" conversion and
// an applicable lifted conversion, if there is one, to the candidate set, and then
// let them duke it out to determine which one is "best".
//
// This is not at all what the native compiler does, and attempting to implement
// the specification, or slight variations on it, produces too many backwards-compatibility
// breaking changes.
//
// The native compiler deviates from the specification in two major ways here.
// First, it does not add *both* the regular and lifted forms to the candidate set.
// Second, the way it characterizes a "lifted" form is very, very different from
// how the specification characterizes a lifted form.
//
// An operation, in this case, X-->Y, is properly said to be "lifted" to X?-->Y? via
// the rule that X?-->Y? matches the behavior of X-->Y for non-null X, and converts
// null X to null Y otherwise.
//
// The native compiler, by contrast, takes the existing operator and "lifts" either
// the operator's parameter type or the operator's return type to nullable. For
// example, a conversion from X?-->Y would be "lifted" to X?-->Y? by making the
// conversion from X? to Y, and then from Y to Y?. No "lifting" semantics
// are imposed; we do not check to see if the X? is null. This operator is not
// actually "lifted" at all; rather, an implicit conversion is applied to the
// output. **The native compiler considers the result type Y? of that standard implicit
// conversion to be the result type of the "lifted" conversion**, rather than
// properly considering Y to be the result type of the conversion for the purposes
// of computing the best output type.
//
// MOREOVER: the native compiler actually *does* implement nullable lifting semantics
// in the case where the input type of the user-defined conversion is a non-nullable
// value type and the output type is a nullable value type **or pointer type, or
// reference type**. This is an enormous departure from the specification; the
// native compiler will take a user-defined conversion from X-->Y? or X-->C and "lift"
// it to a conversion from X?-->Y? or X?-->C that has nullable semantics.
//
// This is quite confusing. In this code we will classify the conversion as either
// "normal" or "lifted" on the basis of *whether or not special lifting semantics
// are to be applied*. That is, whether or not a later rewriting pass is going to
// need to insert a check to see if the source expression is null, and decide
// whether or not to call the underlying unlifted conversion or produce a null
// value without calling the unlifted conversion.
// DELIBERATE SPEC VIOLATION (See bug 17021)
// The specification defines a type U as "encompassing" a type V
// if there is a standard implicit conversion from U to V, and
// neither are interface types.
//
// The intention of this language is to ensure that we do not allow user-defined
// conversions that involve interfaces. We have a reasonable expectation that a
// conversion that involves an interface is one that preserves referential identity,
// and user-defined conversions usually do not.
//
// Now, suppose we have a standard conversion from Alpha to Beta, a user-defined
// conversion from Beta to Gamma, and a standard conversion from Gamma to Delta.
// The specification allows the implicit conversion from Alpha to Delta only if
// Beta encompasses Alpha and Delta encompasses Gamma. And therefore, none of them
// can be interface types, de jure.
//
// However, the dev10 compiler only checks Alpha and Delta to see if they are interfaces,
// and allows Beta and Gamma to be interfaces.
//
// So what's the big deal there? It's not legal to define a user-defined conversion where
// the input or output types are interfaces, right?
//
// It is not legal to define such a conversion, no, but it is legal to create one via generic
// construction. If we have a conversion from T to C<T>, then C<I> has a conversion from I to C<I>.
//
// The dev10 compiler fails to check for this situation. This means that,
// you can convert from int to C<IComparable> because int implements IComparable, but cannot
// convert from IComparable to C<IComparable>!
//
// Unfortunately, we know of several real programs that rely upon this bug, so we are going
// to reproduce it here.
if ((object)source != null && source.IsInterfaceType() || (object)target != null && target.IsInterfaceType())
{
return;
}
foreach (NamedTypeSymbol declaringType in d)
{
foreach (MethodSymbol op in declaringType.GetOperators(WellKnownMemberNames.ImplicitConversionName))
{
// We might have a bad operator and be in an error recovery situation. Ignore it.
if (op.ReturnsVoid || op.ParameterCount != 1)
{
continue;
}
TypeSymbol convertsFrom = op.ParameterTypes[0].TypeSymbol;
TypeSymbol convertsTo = op.ReturnType.TypeSymbol;
Conversion fromConversion = EncompassingImplicitConversion(sourceExpression, source, convertsFrom, ref useSiteDiagnostics);
Conversion toConversion = allowAnyTarget ? Conversion.Identity :
EncompassingImplicitConversion(null, convertsTo, target, ref useSiteDiagnostics);
if (fromConversion.Exists && toConversion.Exists)
{
// There is an additional spec violation in the native compiler. Suppose
// we have a conversion from X-->Y and are asked to do "Y? y = new X();" Clearly
// the intention is to convert from X-->Y via the implicit conversion, and then
// stick a standard implicit conversion from Y-->Y? on the back end. **In this
// situation, the native compiler treats the conversion as though it were
// actually X-->Y? in source for the purposes of determining the best target
// type of an operator.
//
// We perpetuate this fiction here.
if ((object)target != null && target.IsNullableType() && convertsTo.IsNonNullableValueType())
{
convertsTo = MakeNullableType(convertsTo);
toConversion = allowAnyTarget ? Conversion.Identity :
EncompassingImplicitConversion(null, convertsTo, target, ref useSiteDiagnostics);
}
u.Add(UserDefinedConversionAnalysis.Normal(op, fromConversion, toConversion, convertsFrom, convertsTo));
}
else if ((object)source != null && source.IsNullableType() && convertsFrom.IsNonNullableValueType() &&
(allowAnyTarget || target.CanBeAssignedNull()))
{
// As mentioned above, here we diverge from the specification, in two ways.
// First, we only check for the lifted form if the normal form was inapplicable.
// Second, we are supposed to apply lifting semantics only if the conversion
// parameter and return types are *both* non-nullable value types.
//
// In fact the native compiler determines whether to check for a lifted form on
// the basis of:
//
// * Is the type we are ultimately converting from a nullable value type?
// * Is the parameter type of the conversion a non-nullable value type?
// * Is the type we are ultimately converting to a nullable value type,
// pointer type, or reference type?
//
// If the answer to all those questions is "yes" then we lift to nullable
// and see if the resulting operator is applicable.
TypeSymbol nullableFrom = MakeNullableType(convertsFrom);
TypeSymbol nullableTo = convertsTo.IsNonNullableValueType() ? MakeNullableType(convertsTo) : convertsTo;
Conversion liftedFromConversion = EncompassingImplicitConversion(sourceExpression, source, nullableFrom, ref useSiteDiagnostics);
Conversion liftedToConversion = !allowAnyTarget?
EncompassingImplicitConversion(null, nullableTo, target, ref useSiteDiagnostics) :
Conversion.Identity;
if (liftedFromConversion.Exists && liftedToConversion.Exists)
{
u.Add(UserDefinedConversionAnalysis.Lifted(op, liftedFromConversion, liftedToConversion, nullableFrom, nullableTo));
}
}
}
}
}
