/// <summary>
/// Populates a list of unary operator results with those from any
/// witness in scope at the operator site.
/// </summary>
/// <param name="kind">
/// The unary operator kind of the expression.
/// </param>
/// <param name="operand">
/// The operand expression.
/// </param>
/// <param name="results">
/// The results list to populate.
/// </param>
/// <param name="useSiteDiagnostics">
/// The set of diagnostics to populate with any errors.
/// </param>
/// <returns>
/// True if we managed to find candidate operators from the concept
/// witnesses in scope; false otherwise.
/// </returns>
private bool GetUnaryWitnessOperators(UnaryOperatorKind kind, BoundExpression operand, ArrayBuilder <UnaryOperatorAnalysisResult> results, ref HashSet <DiagnosticInfo> useSiteDiagnostics)
{
Debug.Assert(operand != null);
string name = OperatorFacts.UnaryOperatorNameFromOperatorKind(kind);
var operators = ArrayBuilder <UnaryOperatorSignature> .GetInstance();
foreach (var method in GetWitnessOperators(name, 1, ref useSiteDiagnostics))
{
// TODO: nullability
operators.Add(new UnaryOperatorSignature(UnaryOperatorKind.UserDefined | kind, method.ParameterTypes[0], method.ReturnType, method));
}
bool hasCandidates = CandidateOperators(operators, operand, results, ref useSiteDiagnostics);
operators.Free();
return(hasCandidates);
}
private void GetUserDefinedUnaryOperatorsFromType(
TypeSymbol constrainedToTypeOpt,
NamedTypeSymbol type,
UnaryOperatorKind kind,
bool isChecked,
ArrayBuilder <UnaryOperatorSignature> operators)
{
Debug.Assert(operators.Count == 0);
string name1 = OperatorFacts.UnaryOperatorNameFromOperatorKind(kind, isChecked);
getDeclaredOperators(constrainedToTypeOpt, type, kind, name1, operators);
if (isChecked && SyntaxFacts.IsCheckedOperator(name1))
{
string name2 = OperatorFacts.UnaryOperatorNameFromOperatorKind(kind, isChecked: false);
var operators2 = ArrayBuilder <UnaryOperatorSignature> .GetInstance();
// Add regular operators as well.
getDeclaredOperators(constrainedToTypeOpt, type, kind, name2, operators2);
// Drop operators that have a match among the checked ones.
if (operators.Count != 0)
{
for (int i = operators2.Count - 1; i >= 0; i--)
{
foreach (UnaryOperatorSignature signature1 in operators)
{
if (SourceMemberContainerTypeSymbol.DoOperatorsPair(signature1.Method, operators2[i].Method))
{
operators2.RemoveAt(i);
break;
}
}
}
}
operators.AddRange(operators2);
operators2.Free();
}
addLiftedOperators(constrainedToTypeOpt, kind, operators);
// Returns true if there were any applicable candidates.
private bool GetUserDefinedOperators(UnaryOperatorKind kind, BoundExpression operand, ArrayBuilder <UnaryOperatorAnalysisResult> results, ref HashSet <DiagnosticInfo> useSiteDiagnostics)
{
Debug.Assert(operand != null);
if ((object)operand.Type == null)
{
// If the operand has no type -- because it is a null reference or a lambda or a method group --
// there is no way we can determine what type to search for user-defined operators.
return(false);
}
// Spec 7.3.5 Candidate user-defined operators
// SPEC: Given a type T and an operation op(A) ... the set of candidate user-defined
// SPEC: operators provided by T for op(A) is determined as follows:
// SPEC: If T is a nullable type then T0 is its underlying type; otherwise T0 is T.
// SPEC: For all operator declarations in T0 and all lifted forms of such operators, if
// SPEC: at least one operator is applicable with respect to A then the set of candidate
// SPEC: operators consists of all such applicable operators. Otherwise, if T0 is object
// SPEC: then the set of candidate operators is empty. Otherwise, the set of candidate
// SPEC: operators is the set provided by the direct base class of T0, or the effective
// SPEC: base class of T0 if T0 is a type parameter.
TypeSymbol type0 = operand.Type.StrippedType();
// Searching for user-defined operators is expensive; let's take an early out if we can.
if (OperatorFacts.DefinitelyHasNoUserDefinedOperators(type0))
{
return(false);
}
string name = OperatorFacts.UnaryOperatorNameFromOperatorKind(kind);
var operators = ArrayBuilder <UnaryOperatorSignature> .GetInstance();
bool hadApplicableCandidates = false;
NamedTypeSymbol current = type0 as NamedTypeSymbol;
if ((object)current == null)
{
current = type0.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics);
}
if ((object)current == null && type0.IsTypeParameter())
{
current = ((TypeParameterSymbol)type0).EffectiveBaseClass(ref useSiteDiagnostics);
}
for (; (object)current != null; current = current.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics))
{
operators.Clear();
GetUserDefinedUnaryOperatorsFromType(current, kind, name, operators);
results.Clear();
if (CandidateOperators(operators, operand, results, ref useSiteDiagnostics))
{
hadApplicableCandidates = true;
break;
}
}
operators.Free();
return(hadApplicableCandidates);
}
private bool GetUserDefinedOperators(UnaryOperatorKind kind, BoundExpression operand, ArrayBuilder <UnaryOperatorAnalysisResult> results, ref HashSet <DiagnosticInfo> useSiteDiagnostics)
{
Debug.Assert(operand != null);
if ((object)operand.Type == null)
{
// If the operand has no type -- because it is a null reference or a lambda or a method group --
// there is no way we can determine what type to search for user-defined operators.
return(false);
}
// Spec 7.3.5 Candidate user-defined operators
// SPEC: Given a type T and an operation op(A) ... the set of candidate user-defined
// SPEC: operators provided by T for op(A) is determined as follows:
// SPEC: If T is a nullable type then T0 is its underlying type; otherwise T0 is T.
// SPEC: For all operator declarations in T0 and all lifted forms of such operators, if
// SPEC: at least one operator is applicable with respect to A then the set of candidate
// SPEC: operators consists of all such applicable operators. Otherwise, if T0 is object
// SPEC: then the set of candidate operators is empty. Otherwise, the set of candidate
// SPEC: operators is the set provided by the direct base class of T0, or the effective
// SPEC: base class of T0 if T0 is a type parameter.
// https://github.com/dotnet/roslyn/issues/34451: The spec quote should be adjusted to cover operators from interfaces as well.
// From https://github.com/dotnet/csharplang/blob/master/meetings/2017/LDM-2017-06-27.md:
// - We only even look for operator implementations in interfaces if one of the operands has a type that is an interface or
// a type parameter with a non-empty effective base interface list.
// - The applicable operators from classes / structs shadow those in interfaces.This matters for constrained type parameters:
// the effective base class can shadow operators from effective base interfaces.
// - If we find an applicable candidate in an interface, that candidate shadows all applicable operators in base interfaces:
// we stop looking.
TypeSymbol type0 = operand.Type.StrippedType();
// Searching for user-defined operators is expensive; let's take an early out if we can.
if (OperatorFacts.DefinitelyHasNoUserDefinedOperators(type0))
{
return(false);
}
string name = OperatorFacts.UnaryOperatorNameFromOperatorKind(kind);
var operators = ArrayBuilder <UnaryOperatorSignature> .GetInstance();
bool hadApplicableCandidates = false;
NamedTypeSymbol current = type0 as NamedTypeSymbol;
if ((object)current == null)
{
current = type0.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics);
}
if ((object)current == null && type0.IsTypeParameter())
{
current = ((TypeParameterSymbol)type0).EffectiveBaseClass(ref useSiteDiagnostics);
}
for (; (object)current != null; current = current.BaseTypeWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics))
{
operators.Clear();
GetUserDefinedUnaryOperatorsFromType(current, kind, name, operators);
results.Clear();
if (CandidateOperators(operators, operand, results, ref useSiteDiagnostics))
{
hadApplicableCandidates = true;
break;
}
}
// Look in base interfaces, or effective interfaces for type parameters
if (!hadApplicableCandidates)
{
ImmutableArray <NamedTypeSymbol> interfaces = default;
if (type0.IsInterfaceType())
{
interfaces = type0.AllInterfacesWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics);
}
else if (type0.IsTypeParameter())
{
interfaces = ((TypeParameterSymbol)type0).AllEffectiveInterfacesWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics);
}
if (!interfaces.IsDefaultOrEmpty)
{
var shadowedInterfaces = PooledHashSet <NamedTypeSymbol> .GetInstance();
var resultsFromInterface = ArrayBuilder <UnaryOperatorAnalysisResult> .GetInstance();
results.Clear();
foreach (NamedTypeSymbol @interface in interfaces)
{
if ([email protected])
{
// this code could be reachable in error situations
continue;
}
if (shadowedInterfaces.Contains(@interface))
{
// this interface is "shadowed" by a derived interface
continue;
}
operators.Clear();
resultsFromInterface.Clear();
GetUserDefinedUnaryOperatorsFromType(@interface, kind, name, operators);
if (CandidateOperators(operators, operand, resultsFromInterface, ref useSiteDiagnostics))
{
hadApplicableCandidates = true;
results.AddRange(resultsFromInterface);
// this interface "shadows" all its base interfaces
shadowedInterfaces.AddAll(@interface.AllInterfacesWithDefinitionUseSiteDiagnostics(ref useSiteDiagnostics));
}
}
shadowedInterfaces.Free();
resultsFromInterface.Free();
}
}
operators.Free();
return(hadApplicableCandidates);
}