private void BinaryOperatorEasyOut(BinaryOperatorKind kind, BoundExpression left, BoundExpression right, BinaryOperatorOverloadResolutionResult result)
{
var leftType = left.Type;
if ((object)leftType == null)
{
return;
}
var rightType = right.Type;
if ((object)rightType == null)
{
return;
}
if (PossiblyUnusualConstantOperation(left, right))
{
return;
}
var easyOut = BinopEasyOut.OpKind(kind, leftType, rightType);
if (easyOut == BinaryOperatorKind.Error)
{
return;
}
BinaryOperatorSignature signature = this.Compilation.builtInOperators.GetSignature(easyOut);
Conversion leftConversion = Conversions.FastClassifyConversion(left.Type, signature.LeftType);
Conversion rightConversion = Conversions.FastClassifyConversion(right.Type, signature.RightType);
Debug.Assert(leftConversion.Exists && leftConversion.IsImplicit);
Debug.Assert(rightConversion.Exists && rightConversion.IsImplicit);
result.Results.Add(BinaryOperatorAnalysisResult.Applicable(signature, leftConversion, rightConversion));
}
public BoundCompoundAssignmentOperator(
SyntaxNode syntax,
BinaryOperatorSignature @operator,
BoundExpression left,
BoundExpression right,
Conversion leftConversion,
Conversion finalConversion,
LookupResultKind resultKind,
ImmutableArray <MethodSymbol> originalUserDefinedOperatorsOpt,
TypeSymbol type,
bool hasErrors = false)
: this(
syntax,
@operator,
left,
right,
leftConversion,
finalConversion,
resultKind,
type,
hasErrors)
{
this.OriginalUserDefinedOperatorsOpt = originalUserDefinedOperatorsOpt;
}
public static BinaryOperatorAnalysisResult Inapplicable(BinaryOperatorSignature signature, Conversion leftConversion, Conversion rightConversion)
{
return(new BinaryOperatorAnalysisResult(OperatorAnalysisResultKind.Inapplicable, signature, leftConversion, rightConversion));
}
