public int Compare(MemberDeclarationSyntax left, MemberDeclarationSyntax right)
{
if (ReferenceEquals(left, right))
{
return(0);
}
if (left == null)
{
return(1);
}
if (right == null)
{
return(-1);
}
CSharpSyntaxNodeData leftData = nodeData[left];
CSharpSyntaxNodeData rightData = nodeData[right];
for (int i = 0; i < sorters.Count; i++)
{
int comparisonResult = sorters[i].Compare(leftData, rightData);
if (comparisonResult != 0)
{
return(comparisonResult);
}
}
return(0);
}
private static int SortConversionOperator(CSharpSyntaxNodeData leftData, CSharpSyntaxNodeData rightData)
{
int leftSortOrder = leftData.Identifier.Equals("implicit") ? 0 : 1;
int rightSortOrder = rightData.Identifier.Equals("implicit") ? 0 : 1;
return(leftSortOrder < rightSortOrder ? -1 : 1);
}
public override int Compare(CSharpSyntaxNodeData leftData, CSharpSyntaxNodeData rightData)
{
SyntaxKind leftKind = leftData.Kind;
SyntaxKind rightKind = rightData.Kind;
if (leftKind == rightKind)
{
if (Sorters.TryGetValue(leftKind, out Func <CSharpSyntaxNodeData, CSharpSyntaxNodeData, int> comparer))
{
return(comparer(leftData, rightData));
}
return(0);
}
if (!SortConfig.KindSortOrder.TryGetValue(leftKind, out int leftSortOrder))
{
return(1);
}
if (!SortConfig.KindSortOrder.TryGetValue(rightKind, out int rightSortOrder))
{
return(-1);
}
return(leftSortOrder < rightSortOrder ? -1 : 1);
}
public override int Compare(CSharpSyntaxNodeData leftData, CSharpSyntaxNodeData rightData)
{
if (leftData.Access == rightData.Access)
{
return(0);
}
return(SortConfig.AccessModifierSortOrder[leftData.Access] < SortConfig.AccessModifierSortOrder[rightData.Access] ? -1 : 1);
}
public override int Compare(CSharpSyntaxNodeData leftData, CSharpSyntaxNodeData rightData)
{
if (leftData.NumberOfMethodArguments < rightData.NumberOfMethodArguments)
{
return(-1);
}
if (leftData.NumberOfMethodArguments > rightData.NumberOfMethodArguments)
{
return(1);
}
for (int argumentIndex = 0; argumentIndex < leftData.NumberOfMethodArguments; argumentIndex++)
{
ParameterSyntax leftArg = leftData.MethodArguments[argumentIndex];
ParameterSyntax rightArg = rightData.MethodArguments[argumentIndex];
TypeSyntax leftType = leftArg.Type;
TypeSyntax rightType = rightArg.Type;
int predefinedCompareResult = ComparePredefinedArgument(leftType, rightType);
if (predefinedCompareResult != 0)
{
return(predefinedCompareResult);
}
int attributeCompareResult = CompareAttributedArgument(leftArg, rightArg);
if (attributeCompareResult != 0)
{
return(attributeCompareResult);
}
int modifierCompareResult = CompareModifierOnArgument(leftArg, rightArg);
if (modifierCompareResult != 0)
{
return(modifierCompareResult);
}
int arrayCompareResult = CompareArrayArgument(leftType, rightType);
if (arrayCompareResult != 0)
{
return(arrayCompareResult);
}
int genericCompareResult = CompareGenericArgument(leftType, rightType);
if (genericCompareResult != 0)
{
return(genericCompareResult);
}
}
int argumentTypeNameCompareResult = CompareArgumentTypeNames(leftData, rightData);
return(argumentTypeNameCompareResult);
}
private static int CompareArgumentTypeNames(CSharpSyntaxNodeData leftData, CSharpSyntaxNodeData rightData)
{
for (int argumentIndex = 0; argumentIndex < leftData.NumberOfMethodArguments; argumentIndex++)
{
ParameterSyntax leftArg = leftData.MethodArguments[argumentIndex];
ParameterSyntax rightArg = rightData.MethodArguments[argumentIndex];
string leftTypeName = leftArg.Type.ToString();
string rightTypeName = rightArg.Type.ToString();
int comparison = leftTypeName.CompareTo(rightTypeName);
if (comparison != 0)
{
return(comparison);
}
}
return(0);
}
private static int SortOperatorDeclaration(CSharpSyntaxNodeData leftData, CSharpSyntaxNodeData rightData)
{
if (!OperatorSortOrder.TryGetValue(leftData.Identifier, out int leftSortOrder))
{
leftSortOrder = 100;
}
if (!OperatorSortOrder.TryGetValue(rightData.Identifier, out int rightSortOrder))
{
rightSortOrder = 100;
}
if (leftSortOrder == rightSortOrder)
{
int identifierComparison = string.Compare(leftData.Identifier, rightData.Identifier);
return(identifierComparison);
}
return(leftSortOrder < rightSortOrder ? -1 : 1);
}
public override int Compare(CSharpSyntaxNodeData leftData, CSharpSyntaxNodeData rightData)
{
int identifierComparison = string.Compare(leftData.Identifier, rightData.Identifier);
return(identifierComparison);
}
public override int Compare(CSharpSyntaxNodeData leftData, CSharpSyntaxNodeData rightData) => CompareBool(leftData.IsStatic, rightData.IsStatic);
public override int Compare(CSharpSyntaxNodeData leftData, CSharpSyntaxNodeData rightData) => CompareBool(leftData.IsReadonly, rightData.IsReadonly);
public override int Compare(CSharpSyntaxNodeData leftData, CSharpSyntaxNodeData rightData) => CompareBool(leftData.IsConst, rightData.IsConst);
public override int Compare(CSharpSyntaxNodeData leftData, CSharpSyntaxNodeData rightData) => CompareBool(leftData.IsExtern, rightData.IsExtern);
