public static bool TryGetPredefinedComparisonOperator(
this IMethodSymbol symbol,
out PredefinedOperator op
)
{
if (symbol.MethodKind == MethodKind.BuiltinOperator)
{
op = symbol.GetPredefinedOperator();
switch (op)
{
case PredefinedOperator.Equality:
case PredefinedOperator.Inequality:
case PredefinedOperator.GreaterThanOrEqual:
case PredefinedOperator.LessThanOrEqual:
case PredefinedOperator.GreaterThan:
case PredefinedOperator.LessThan:
return(true);
}
}
else
{
op = PredefinedOperator.None;
}
return(false);
}
private static bool IsPotentialReference(
ISyntaxFactsService syntaxFacts,
PredefinedOperator op,
SyntaxToken token)
{
return(syntaxFacts.TryGetPredefinedOperator(token, out var actualOperator) && actualOperator == op);
}
private static Task <ImmutableArray <Document> > FindDocumentsAsync(
Project project,
IImmutableSet <Document>?documents,
PredefinedOperator op,
CancellationToken cancellationToken)
{
if (op == PredefinedOperator.None)
{
return(SpecializedTasks.EmptyImmutableArray <Document>());
}
return(FindDocumentsWithPredicateAsync(
project, documents, static (index, op) => index.ContainsPredefinedOperator(op), op, cancellationToken));
protected static Task<ImmutableArray<Document>> FindDocumentsAsync(
Project project,
IImmutableSet<Document>? documents,
PredefinedOperator op,
CancellationToken cancellationToken)
{
if (op == PredefinedOperator.None)
return SpecializedTasks.EmptyImmutableArray<Document>();
return FindDocumentsAsync(project, documents, async (d, c) =>
{
var info = await SyntaxTreeIndex.GetRequiredIndexAsync(d, c).ConfigureAwait(false);
return info.ContainsPredefinedOperator(op);
}, cancellationToken);
}
protected async Task <ImmutableArray <Document> > FindDocumentsAsync(
Project project,
IImmutableSet <Document> documents,
PredefinedOperator op,
CancellationToken cancellationToken)
{
if (op == PredefinedOperator.None)
{
return(ImmutableArray <Document> .Empty);
}
return(await FindDocumentsAsync(project, documents, async (d, c) =>
{
var info = await SyntaxTreeIndex.GetIndexAsync(d, c).ConfigureAwait(false);
return info.ContainsPredefinedOperator(op);
}, cancellationToken).ConfigureAwait(false));
}
protected async Task <IEnumerable <Document> > FindDocumentsAsync(
Project project,
IImmutableSet <Document> documents,
PredefinedOperator op,
CancellationToken cancellationToken)
{
if (op == PredefinedOperator.None)
{
return(SpecializedCollections.EmptyEnumerable <Document>());
}
return(await FindDocumentsAsync(project, documents, async (d, c) =>
{
var info = await SyntaxTreeInfo.GetContextInfoAsync(d, c).ConfigureAwait(false);
return info.ContainsPredefinedOperator(op);
}, cancellationToken).ConfigureAwait(false));
}
public bool IsPredefinedOperator(SyntaxToken token, PredefinedOperator op)
{
PredefinedOperator actualOperator;
return TryGetPredefinedOperator(token, out actualOperator) && actualOperator == op;
}
public bool TryGetPredefinedOperator(SyntaxToken token, out PredefinedOperator op)
{
throw new NotImplementedException();
}
public static bool TryGetPredefinedComparisonOperator(this IMethodSymbol symbol, out PredefinedOperator op)
{
if (symbol.MethodKind == MethodKind.BuiltinOperator)
{
op = symbol.GetPredefinedOperator();
switch (op)
{
case PredefinedOperator.Equality:
case PredefinedOperator.Inequality:
case PredefinedOperator.GreaterThanOrEqual:
case PredefinedOperator.LessThanOrEqual:
case PredefinedOperator.GreaterThan:
case PredefinedOperator.LessThan:
return true;
}
}
else
{
op = PredefinedOperator.None;
}
return false;
}
public bool ContainsPredefinedOperator(PredefinedOperator op) => _contextInfo.ContainsPredefinedOperator(op);
public bool ContainsPredefinedOperator(PredefinedOperator op)
{
return((_predefinedOperators & (int)op) == (int)op);
}
public bool TryGetPredefinedOperator(SyntaxToken token, out PredefinedOperator op)
{
throw new NotImplementedException();
}
public bool TryGetPredefinedOperator(SyntaxToken token, out PredefinedOperator op)
{
op = GetPredefinedOperator(token);
return(op != PredefinedOperator.None);
}
public bool TryGetPredefinedOperator(SyntaxToken token, out PredefinedOperator op)
{
op = GetPredefinedOperator(token);
return op != PredefinedOperator.None;
}
public PredefinedOperator ResolveBetterOperator (ResolveContext ec, PredefinedOperator best_operator)
{
int result = 0;
if (left != null && best_operator.left != null) {
result = MethodGroupExpr.BetterTypeConversion (ec, best_operator.left, left);
}
//
// When second arguments are same as the first one, the result is same
//
if (right != null && (left != right || best_operator.left != best_operator.right)) {
result |= MethodGroupExpr.BetterTypeConversion (ec, best_operator.right, right);
}
if (result == 0 || result > 2)
return null;
return result == 1 ? best_operator : this;
}
protected async Task<ImmutableArray<Document>> FindDocumentsAsync(
Project project,
IImmutableSet<Document> documents,
PredefinedOperator op,
CancellationToken cancellationToken)
{
if (op == PredefinedOperator.None)
{
return ImmutableArray<Document>.Empty;
}
return await FindDocumentsAsync(project, documents, async (d, c) =>
{
var info = await SyntaxTreeInfo.GetContextInfoAsync(d, c).ConfigureAwait(false);
return info.ContainsPredefinedOperator(op);
}, cancellationToken).ConfigureAwait(false);
}
//
// Build-in operators method overloading
//
protected virtual Expression ResolveOperatorPredefined (ResolveContext ec, PredefinedOperator [] operators, bool primitives_only, Type enum_type)
{
PredefinedOperator best_operator = null;
Type l = left.Type;
Type r = right.Type;
Operator oper_mask = oper & ~Operator.ValuesOnlyMask;
foreach (PredefinedOperator po in operators) {
if ((po.OperatorsMask & oper_mask) == 0)
continue;
if (primitives_only) {
if (!po.IsPrimitiveApplicable (l, r))
continue;
} else {
if (!po.IsApplicable (ec, left, right))
continue;
}
if (best_operator == null) {
best_operator = po;
if (primitives_only)
break;
continue;
}
best_operator = po.ResolveBetterOperator (ec, best_operator);
if (best_operator == null) {
ec.Report.Error (34, loc, "Operator `{0}' is ambiguous on operands of type `{1}' and `{2}'",
OperName (oper), left.GetSignatureForError (), right.GetSignatureForError ());
best_operator = po;
break;
}
}
if (best_operator == null)
return null;
Expression expr = best_operator.ConvertResult (ec, this);
if (enum_type == null)
return expr;
//
// HACK: required by enum_conversion
//
expr.Type = enum_type;
return EmptyCast.Create (expr, enum_type);
}
public bool IsPredefinedOperator(SyntaxToken token, PredefinedOperator op)
{
PredefinedOperator actualOperator;
return(TryGetPredefinedOperator(token, out actualOperator) && actualOperator == op);
}
public bool ContainsPredefinedOperator(PredefinedOperator op) => (_predefinedOperators & (int)op) == (int)op;
public bool ContainsPredefinedOperator(PredefinedOperator op)
{
return (_predefinedOperators & (int)op) == (int)op;
}
public bool ContainsPredefinedOperator(PredefinedOperator op) => _contextInfo.ContainsPredefinedOperator(op);
