internal Conversion(ConversionKind kind, DeconstructMethodInfo deconstructMethodInfo, ImmutableArray <Conversion> nestedConversions)
{
Debug.Assert(kind == ConversionKind.Deconstruction);
this._kind = kind;
_uncommonData = new DeconstructionUncommonData(deconstructMethodInfo, nestedConversions);
}
/// <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,
DiagnosticBag 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.TupleElementTypes.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 <Conversion> .GetInstance(count);
for (int i = 0; i < count; i++)
{
var variable = variables[i];
Conversion nestedConversion;
if (variable.HasNestedVariables)
{
var elementSyntax = syntax.Kind() == SyntaxKind.TupleExpression ? ((TupleExpressionSyntax)syntax).Arguments[i] : syntax;
hasErrors |= !MakeDeconstructionConversion(tupleOrDeconstructedTypes[i], syntax, rightSyntax, diagnostics,
variable.NestedVariables, out nestedConversion);
}
else
{
var single = variable.Single;
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
nestedConversion = this.Conversions.ClassifyConversionFromType(tupleOrDeconstructedTypes[i], single.Type, ref useSiteDiagnostics);
diagnostics.Add(single.Syntax, useSiteDiagnostics);
if (!nestedConversion.IsImplicit)
{
hasErrors = true;
GenerateImplicitConversionError(diagnostics, Compilation, single.Syntax, nestedConversion, tupleOrDeconstructedTypes[i], single.Type);
}
}
nestedConversions.Add(nestedConversion);
}
conversion = new Conversion(ConversionKind.Deconstruction, deconstructMethod, nestedConversions.ToImmutableAndFree());
return(!hasErrors);
}
internal DeconstructionUncommonData(DeconstructMethodInfo deconstructMethodInfoOpt, ImmutableArray <Conversion> nestedConversions)
: base(isExtensionMethod: false, isArrayIndex: false, conversionResult: default, conversionMethod: null, nestedConversions)
{
Debug.Assert(!nestedConversions.IsDefaultOrEmpty);
DeconstructMethodInfo = deconstructMethodInfoOpt;
}
