private void PrepareBoolConversionAndTruthOperator(TypeSymbol type, BinaryExpressionSyntax node, BinaryOperatorKind binaryOperator, BindingDiagnosticBag diagnostics,
out BoundExpression conversionForBool, out BoundValuePlaceholder conversionForBoolPlaceholder, out UnaryOperatorSignature boolOperator)
{
// Is the operand implicitly convertible to bool?
CompoundUseSiteInfo <AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
TypeSymbol boolean = GetSpecialType(SpecialType.System_Boolean, diagnostics, node);
Conversion conversion = this.Conversions.ClassifyImplicitConversionFromType(type, boolean, ref useSiteInfo);
diagnostics.Add(node, useSiteInfo);
if (conversion.IsImplicit)
{
conversionForBoolPlaceholder = new BoundValuePlaceholder(node, type).MakeCompilerGenerated();
conversionForBool = CreateConversion(node, conversionForBoolPlaceholder, conversion, isCast: false, conversionGroupOpt: null, boolean, diagnostics);
boolOperator = default;
return;
}
// It was not. Does it implement operator true (or false)?
UnaryOperatorKind boolOpKind;
switch (binaryOperator)
{
case BinaryOperatorKind.Equal:
boolOpKind = UnaryOperatorKind.False;
break;
case BinaryOperatorKind.NotEqual:
boolOpKind = UnaryOperatorKind.True;
break;
default:
throw ExceptionUtilities.UnexpectedValue(binaryOperator);
}
LookupResultKind resultKind;
ImmutableArray <MethodSymbol> originalUserDefinedOperators;
BoundExpression comparisonResult = new BoundTupleOperandPlaceholder(node, type);
UnaryOperatorAnalysisResult best = this.UnaryOperatorOverloadResolution(boolOpKind, comparisonResult, node, diagnostics, out resultKind, out originalUserDefinedOperators);
if (best.HasValue)
{
conversionForBoolPlaceholder = new BoundValuePlaceholder(node, type).MakeCompilerGenerated();
conversionForBool = CreateConversion(node, conversionForBoolPlaceholder, best.Conversion, isCast: false, conversionGroupOpt: null, best.Signature.OperandType, diagnostics);
boolOperator = best.Signature;
return;
}
// It did not. Give a "not convertible to bool" error.
GenerateImplicitConversionError(diagnostics, node, conversion, comparisonResult, boolean);
conversionForBoolPlaceholder = null;
conversionForBool = null;
boolOperator = default;
return;
}
/// <summary>
/// Recursively builds a Conversion object with Kind=Deconstruction including information about any necessary
/// Deconstruct method and any element-wise conversion.
///
/// Note that the variables may either be plain or nested variables.
/// The variables may be updated with inferred types if they didn't have types initially.
/// Returns false if there was an error.
/// </summary>
private bool MakeDeconstructionConversion(
TypeSymbol type,
SyntaxNode syntax,
SyntaxNode rightSyntax,
BindingDiagnosticBag diagnostics,
ArrayBuilder <DeconstructionVariable> variables,
out Conversion conversion)
{
Debug.Assert((object)type != null);
ImmutableArray <TypeSymbol> tupleOrDeconstructedTypes;
conversion = Conversion.Deconstruction;
// Figure out the deconstruct method (if one is required) and determine the types we get from the RHS at this level
var deconstructMethod = default(DeconstructMethodInfo);
if (type.IsTupleType)
{
// tuple literal such as `(1, 2)`, `(null, null)`, `(x.P, y.M())`
tupleOrDeconstructedTypes = type.TupleElementTypesWithAnnotations.SelectAsArray(TypeMap.AsTypeSymbol);
SetInferredTypes(variables, tupleOrDeconstructedTypes, diagnostics);
if (variables.Count != tupleOrDeconstructedTypes.Length)
{
Error(diagnostics, ErrorCode.ERR_DeconstructWrongCardinality, syntax, tupleOrDeconstructedTypes.Length, variables.Count);
return(false);
}
}
else
{
if (variables.Count < 2)
{
Error(diagnostics, ErrorCode.ERR_DeconstructTooFewElements, syntax);
return(false);
}
var inputPlaceholder = new BoundDeconstructValuePlaceholder(syntax, this.LocalScopeDepth, type);
BoundExpression deconstructInvocation = MakeDeconstructInvocationExpression(variables.Count,
inputPlaceholder, rightSyntax, diagnostics, outPlaceholders: out ImmutableArray <BoundDeconstructValuePlaceholder> outPlaceholders, out _);
if (deconstructInvocation.HasAnyErrors)
{
return(false);
}
deconstructMethod = new DeconstructMethodInfo(deconstructInvocation, inputPlaceholder, outPlaceholders);
tupleOrDeconstructedTypes = outPlaceholders.SelectAsArray(p => p.Type);
SetInferredTypes(variables, tupleOrDeconstructedTypes, diagnostics);
}
// Figure out whether those types will need conversions, including further deconstructions
bool hasErrors = false;
int count = variables.Count;
var nestedConversions = ArrayBuilder <(BoundValuePlaceholder?, BoundExpression?)> .GetInstance(count);
for (int i = 0; i < count; i++)
{
var variable = variables[i];
Conversion nestedConversion;
if (variable.NestedVariables is object)
{
var elementSyntax = syntax.Kind() == SyntaxKind.TupleExpression ? ((TupleExpressionSyntax)syntax).Arguments[i] : syntax;
hasErrors |= !MakeDeconstructionConversion(tupleOrDeconstructedTypes[i], elementSyntax, rightSyntax, diagnostics,
variable.NestedVariables, out nestedConversion);
Debug.Assert(nestedConversion.Kind == ConversionKind.Deconstruction);
var operandPlaceholder = new BoundValuePlaceholder(syntax, ErrorTypeSymbol.UnknownResultType).MakeCompilerGenerated();
nestedConversions.Add((operandPlaceholder, new BoundConversion(syntax, operandPlaceholder, nestedConversion,
@checked: false, explicitCastInCode: false,
conversionGroupOpt: null, constantValueOpt: null,
#pragma warning disable format
type: ErrorTypeSymbol.UnknownResultType)
{
WasCompilerGenerated = true
}));
