private void GetUserDefinedBinaryOperatorsFromType(
NamedTypeSymbol type,
BinaryOperatorKind kind,
string name,
ArrayBuilder<BinaryOperatorSignature> operators)
{
foreach (MethodSymbol op in type.GetOperators(name))
{
// If we're in error recovery, we might have bad operators. Just ignore it.
if (op.ParameterCount != 2 || op.ReturnsVoid)
{
continue;
}
TypeSymbol leftOperandType = op.ParameterTypes[0];
TypeSymbol rightOperandType = op.ParameterTypes[1];
TypeSymbol resultType = op.ReturnType;
operators.Add(new BinaryOperatorSignature(BinaryOperatorKind.UserDefined | kind, leftOperandType, rightOperandType, resultType, op));
LiftingResult lifting = UserDefinedBinaryOperatorCanBeLifted(leftOperandType, rightOperandType, resultType, kind);
if (lifting == LiftingResult.LiftOperandsAndResult)
{
operators.Add(new BinaryOperatorSignature(
BinaryOperatorKind.Lifted | BinaryOperatorKind.UserDefined | kind,
MakeNullable(leftOperandType), MakeNullable(rightOperandType), MakeNullable(resultType), op));
}
else if (lifting == LiftingResult.LiftOperandsButNotResult)
{
operators.Add(new BinaryOperatorSignature(
BinaryOperatorKind.Lifted | BinaryOperatorKind.UserDefined | kind,
MakeNullable(leftOperandType), MakeNullable(rightOperandType), resultType, op));
}
}
}
private bool HasApplicableBooleanOperator(NamedTypeSymbol containingType, string name, TypeSymbol argumentType,
ref HashSet<DiagnosticInfo> useSiteDiagnostics)
{
foreach (var op in containingType.GetOperators(name))
{
if (op.ParameterCount == 1)
{
var conversion = Conversions.ClassifyConversion(argumentType, op.ParameterTypes[0], ref useSiteDiagnostics);
if (conversion.IsImplicit)
{
return true;
}
}
}
return false;
}
private void GetUserDefinedUnaryOperatorsFromType(
NamedTypeSymbol type,
UnaryOperatorKind kind,
string name,
ArrayBuilder<UnaryOperatorSignature> operators)
{
foreach (MethodSymbol op in type.GetOperators(name))
{
// If we're in error recovery, we might have bad operators. Just ignore it.
if (op.ParameterCount != 1 || op.ReturnsVoid)
{
continue;
}
TypeSymbol operandType = op.ParameterTypes[0];
TypeSymbol resultType = op.ReturnType;
operators.Add(new UnaryOperatorSignature(UnaryOperatorKind.UserDefined | kind, operandType, resultType, op));
// SPEC: For the unary operators + ++ - -- ! ~ a lifted form of an operator exists
// SPEC: if the operand and its result types are both non-nullable value types.
// SPEC: The lifted form is constructed by adding a single ? modifier to the
// SPEC: operator and result types.
switch (kind)
{
case UnaryOperatorKind.UnaryPlus:
case UnaryOperatorKind.PrefixDecrement:
case UnaryOperatorKind.PrefixIncrement:
case UnaryOperatorKind.UnaryMinus:
case UnaryOperatorKind.PostfixDecrement:
case UnaryOperatorKind.PostfixIncrement:
case UnaryOperatorKind.LogicalNegation:
case UnaryOperatorKind.BitwiseComplement:
if (operandType.IsValueType && !operandType.IsNullableType() &&
resultType.IsValueType && !resultType.IsNullableType())
{
operators.Add(new UnaryOperatorSignature(
UnaryOperatorKind.Lifted | UnaryOperatorKind.UserDefined | kind,
MakeNullable(operandType), MakeNullable(resultType), op));
}
break;
}
}
}
private void AddUserDefinedConversionsToExplicitCandidateSet(
BoundExpression sourceExpression,
TypeSymbol source,
TypeSymbol target,
ArrayBuilder<UserDefinedConversionAnalysis> u,
NamedTypeSymbol declaringType,
string operatorName,
ref HashSet<DiagnosticInfo> useSiteDiagnostics)
{
Debug.Assert(sourceExpression != null || (object)source != null);
Debug.Assert((object)target != null);
Debug.Assert(u != null);
Debug.Assert((object)declaringType != null);
Debug.Assert(operatorName != 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 or explicit
// SPEC: conversion operators declared by the classes and structs in D that convert
// SPEC: from a type encompassing E or encompassed by S (if it exists) to a type
// SPEC: encompassing or encompassed by 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 the comment regarding bug 17021 in
// UserDefinedImplicitConversions.cs.
if ((object)source != null && source.IsInterfaceType() || target.IsInterfaceType())
{
return;
}
foreach (MethodSymbol op in declaringType.GetOperators(operatorName))
{
// We might have a bad operator and be in an error recovery situation. Ignore it.
if (op.ReturnsVoid || op.ParameterCount != 1 || op.ReturnType.TypeKind == TypeKind.Error)
{
continue;
}
TypeSymbol convertsFrom = op.ParameterTypes[0];
TypeSymbol convertsTo = op.ReturnType;
Conversion fromConversion = EncompassingExplicitConversion(sourceExpression, source, convertsFrom, ref useSiteDiagnostics);
Conversion toConversion = EncompassingExplicitConversion(null, convertsTo, target, ref useSiteDiagnostics);
// We accept candidates for which the parameter type encompasses the *underlying* source type.
if (!fromConversion.Exists &&
(object)source != null &&
source.IsNullableType() &&
EncompassingExplicitConversion(null, source.GetNullableUnderlyingType(), convertsFrom, ref useSiteDiagnostics).Exists)
{
fromConversion = ClassifyConversion(source, convertsFrom, ref useSiteDiagnostics, builtinOnly: true);
}
// As in dev11 (and the revised spec), we also accept candidates for which the return type is encompassed by the *stripped* target type.
if (!toConversion.Exists &&
(object)target != null &&
target.IsNullableType() &&
EncompassingExplicitConversion(null, convertsTo, target.GetNullableUnderlyingType(), ref useSiteDiagnostics).Exists)
{
toConversion = ClassifyConversion(convertsTo, target, ref useSiteDiagnostics, builtinOnly: true);
}
// In the corresponding implicit conversion code we can get away with first
// checking to see if standard implicit conversions exist from the source type
// to the parameter type, and from the return type to the target type. If not,
// then we can check for a lifted operator.
//
// That's not going to cut it in the explicit conversion code. Suppose we have
// a conversion X-->Y and have source type X? and target type Y?. There *are*
// standard explicit conversions from X?-->X and Y?-->Y, but we do not want
// to bind this as an *unlifted* conversion from X? to Y?; we want such a thing
// to be a *lifted* conversion from X? to Y?, that checks for null on the source
// and decides to not call the underlying user-defined conversion if it is null.
//
// We therefore cannot do what we do in the implicit conversions, where we check
// to see if the unlifted conversion works, and if it does, then don't add the lifted
// conversion at all. Rather, we have to see if what we're building here is a
// lifted conversion or not.
//
// Under what circumstances is this conversion a lifted conversion? (In the
// "spec" sense of a lifted conversion; that is, that we check for null
// and skip the user-defined conversion if necessary).
//
// * The source type must be a nullable value type.
// * The parameter type must be a non-nullable value type.
// * The target type must be able to take on a null value.
if (fromConversion.Exists && toConversion.Exists)
{
if ((object)source != null && source.IsNullableType() && convertsFrom.IsNonNullableValueType() && target.CanBeAssignedNull())
{
TypeSymbol nullableFrom = MakeNullableType(convertsFrom);
TypeSymbol nullableTo = convertsTo.IsNonNullableValueType() ? MakeNullableType(convertsTo) : convertsTo;
Conversion liftedFromConversion = EncompassingExplicitConversion(sourceExpression, source, nullableFrom, ref useSiteDiagnostics);
Conversion liftedToConversion = EncompassingExplicitConversion(null, nullableTo, target, ref useSiteDiagnostics);
Debug.Assert(liftedFromConversion.Exists);
Debug.Assert(liftedToConversion.Exists);
u.Add(UserDefinedConversionAnalysis.Lifted(op, liftedFromConversion, liftedToConversion, nullableFrom, nullableTo));
}
else
{
// 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 a set of operators.
//
// Similarly, if we have a conversion from X-->Y and are asked to do
// an explicit conversion from X? to Y then we treat the conversion as
// though it really were X?-->Y for the purposes of determining the best
// source type of a set of operators.
//
// We perpetuate these fictions here.
if (target.IsNullableType() && convertsTo.IsNonNullableValueType())
{
convertsTo = MakeNullableType(convertsTo);
toConversion = EncompassingExplicitConversion(null, convertsTo, target, ref useSiteDiagnostics);
}
if ((object)source != null && source.IsNullableType() && convertsFrom.IsNonNullableValueType())
{
convertsFrom = MakeNullableType(convertsFrom);
fromConversion = EncompassingExplicitConversion(null, convertsFrom, source, ref useSiteDiagnostics);
}
u.Add(UserDefinedConversionAnalysis.Normal(op, fromConversion, toConversion, convertsFrom, convertsTo));
}
}
}
}
