private static Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
TextSpan span,
CancellationToken cancellationToken)
{
SyntaxTrivia trivia = enumDeclaration.FindTrivia(span.Start);
SyntaxToken token = trivia.Token;
EnumMemberDeclarationSyntax enumMemberDeclaration = token
.GetPreviousToken()
.Parent
.FirstAncestorOrSelf <EnumMemberDeclarationSyntax>();
int enumMemberIndex = enumDeclaration.Members.IndexOf(enumMemberDeclaration);
SyntaxTriviaList trailingTrivia = token.TrailingTrivia;
SyntaxToken newToken = token.WithTrailingTrivia(trailingTrivia.Skip(trailingTrivia.IndexOf(trivia) + 1));
EnumDeclarationSyntax newEnumDeclaration = enumDeclaration.ReplaceToken(token, newToken);
var settings = new DocumentationCommentGeneratorSettings(ImmutableArray.Create(_leadingSlashesRegex.Replace(trivia.ToString(), "")));
EnumMemberDeclarationSyntax newEnumMemberDeclaration = newEnumDeclaration.Members[enumMemberIndex].WithNewSingleLineDocumentationComment(settings);
newEnumDeclaration = newEnumDeclaration.WithMembers(newEnumDeclaration.Members.ReplaceAt(enumMemberIndex, newEnumMemberDeclaration));
return(document.ReplaceNodeAsync(enumDeclaration, newEnumDeclaration, cancellationToken));
}
private static Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
SeparatedSyntaxListSelection <EnumMemberDeclarationSyntax> selectedMembers,
string name,
CancellationToken cancellationToken)
{
ExpressionSyntax expression = IdentifierName(selectedMembers.Last().Identifier.WithoutTrivia());
for (int i = selectedMembers.LastIndex - 1; i >= selectedMembers.FirstIndex; i--)
{
expression = BitwiseOrExpression(
IdentifierName(selectedMembers.UnderlyingList[i].Identifier.WithoutTrivia()),
expression);
}
EnumMemberDeclarationSyntax newEnumMember = EnumMemberDeclaration(
Identifier(name).WithRenameAnnotation(),
EqualsValueClause(expression));
EnumDeclarationSyntax newEnumDeclaration = enumDeclaration
.WithMembers(enumDeclaration.Members.Insert(selectedMembers.LastIndex + 1, newEnumMember));
return(document.ReplaceNodeAsync(enumDeclaration, newEnumDeclaration, cancellationToken));
}
private async Task <Document> ReorderEnum(Document document, EnumDeclarationSyntax enumDeclaration, CancellationToken cancellationToken)
{
var oldMembers = enumDeclaration.Members;
var zeroValue = oldMembers.Where(m =>
{
var value = m.EqualsValue?.Value;
if (value != null && value.Kind() == SyntaxKind.NumericLiteralExpression && (int)((LiteralExpressionSyntax)value).Token.Value == 0)
{
return(true);
}
return(false);
}).First();
var newMembers = oldMembers.Remove(zeroValue).Insert(0, zeroValue);
var newEnum = enumDeclaration.WithMembers(newMembers);
var root = await document.GetSyntaxRootAsync();
var newRoot = root.ReplaceNode(enumDeclaration, newEnum);
var newDocument = document.WithSyntaxRoot(newRoot);
return(newDocument);
}
private static async Task <Document> SortByValueAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
ImmutableArray <EnumMemberDeclarationSyntax> selectedMembers,
CancellationToken cancellationToken)
{
SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members;
int firstIndex = members.IndexOf(selectedMembers[0]);
int lastIndex = members.IndexOf(selectedMembers[selectedMembers.Length - 1]);
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var comparer = new EnumMemberDeclarationValueComparer(semanticModel, cancellationToken);
IEnumerable <EnumMemberDeclarationSyntax> sorted = selectedMembers.OrderBy(f => f, comparer);
SeparatedSyntaxList <EnumMemberDeclarationSyntax> newMembers = members
.Take(firstIndex)
.Concat(sorted)
.Concat(members.Skip(lastIndex + 1))
.ToSeparatedSyntaxList();
MemberDeclarationSyntax newNode = enumDeclaration.WithMembers(newMembers);
return(await document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken).ConfigureAwait(false));
}
private static async Task <Document> DeclareExplicitValueAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
INamedTypeSymbol enumSymbol,
ImmutableArray <ulong> values,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
bool isFlags = enumSymbol.HasAttribute(MetadataNames.System_FlagsAttribute);
List <ulong> reservedValues = values.ToList();
SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members;
SeparatedSyntaxList <EnumMemberDeclarationSyntax> newMembers = members;
for (int i = 0; i < members.Count; i++)
{
if (members[i].EqualsValue == null)
{
IFieldSymbol fieldSymbol = semanticModel.GetDeclaredSymbol(members[i], cancellationToken);
ulong?value = null;
if (isFlags)
{
Optional <ulong> optional = FlagsUtility <ulong> .Instance.GetUniquePowerOfTwo(reservedValues);
if (optional.HasValue &&
ConvertHelpers.CanConvert(optional.Value, enumSymbol.EnumUnderlyingType.SpecialType))
{
value = optional.Value;
}
}
else
{
value = SymbolUtility.GetEnumValueAsUInt64(fieldSymbol.ConstantValue, enumSymbol);
}
if (value != null)
{
reservedValues.Add(value.Value);
EqualsValueClauseSyntax equalsValue = EqualsValueClause(NumericLiteralExpression(value.Value, enumSymbol.EnumUnderlyingType.SpecialType));
EnumMemberDeclarationSyntax newMember = members[i].WithEqualsValue(equalsValue);
newMembers = newMembers.ReplaceAt(i, newMember);
}
}
}
EnumDeclarationSyntax newEnumDeclaration = enumDeclaration.WithMembers(newMembers);
return(await document.ReplaceNodeAsync(enumDeclaration, newEnumDeclaration, cancellationToken).ConfigureAwait(false));
}
private static Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
SeparatedSyntaxListSelection <EnumMemberDeclarationSyntax> selectedMembers,
INamedTypeSymbol enumSymbol,
string name,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
ExpressionSyntax expression = null;
EnumMemberDeclarationSyntax lastMember = null;
using (IEnumerator <EnumMemberDeclarationSyntax> en = GetMembersToCombine().GetEnumerator())
{
if (en.MoveNext())
{
lastMember = en.Current;
expression = IdentifierName(en.Current.Identifier.WithoutTrivia());
while (en.MoveNext())
{
expression = BitwiseOrExpression(
IdentifierName(en.Current.Identifier.WithoutTrivia()),
expression);
}
}
}
EnumMemberDeclarationSyntax newEnumMember = EnumMemberDeclaration(
Identifier(name).WithRenameAnnotation(),
EqualsValueClause(expression));
EnumDeclarationSyntax newEnumDeclaration = enumDeclaration
.WithMembers(enumDeclaration.Members.Insert(selectedMembers.UnderlyingList.IndexOf(lastMember) + 1, newEnumMember));
return(document.ReplaceNodeAsync(enumDeclaration, newEnumDeclaration, cancellationToken));
IEnumerable <EnumMemberDeclarationSyntax> GetMembersToCombine()
{
for (int i = selectedMembers.Count - 1; i >= 0; i--)
{
IFieldSymbol symbol = semanticModel.GetDeclaredSymbol(selectedMembers[i], cancellationToken);
if (symbol.HasConstantValue)
{
ulong value = SymbolUtility.GetEnumValueAsUInt64(symbol.ConstantValue, enumSymbol);
if (!FlagsUtility <ulong> .Instance.IsComposite(value))
{
yield return(selectedMembers[i]);
}
}
}
}
}
private static Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
INamedTypeSymbol enumSymbol,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
ulong value = 0;
SpecialType numericType = enumSymbol.EnumUnderlyingType.SpecialType;
IEnumerable <EnumMemberDeclarationSyntax> newMembers = (enumSymbol.HasAttribute(MetadataNames.System_FlagsAttribute))
? enumDeclaration.Members.Select(CreateNewFlagsMember)
: enumDeclaration.Members.Select(CreateNewMember);
EnumDeclarationSyntax newEnumDeclaration = enumDeclaration.WithMembers(newMembers.ToSeparatedSyntaxList());
return(document.ReplaceNodeAsync(enumDeclaration, newEnumDeclaration, cancellationToken));
EnumMemberDeclarationSyntax CreateNewFlagsMember(EnumMemberDeclarationSyntax enumMember)
{
if (!ConvertHelpers.CanConvert(value, numericType))
{
return(enumMember);
}
IFieldSymbol fieldSymbol = semanticModel.GetDeclaredSymbol(enumMember, cancellationToken);
if (fieldSymbol.HasConstantValue &&
FlagsUtility <ulong> .Instance.IsComposite(SymbolUtility.GetEnumValueAsUInt64(fieldSymbol.ConstantValue, enumSymbol)))
{
return(enumMember);
}
EnumMemberDeclarationSyntax newEnumMember = CreateNewEnumMember(enumMember, value, numericType);
value = (value == 0) ? 1 : value * 2;
return(newEnumMember);
}
EnumMemberDeclarationSyntax CreateNewMember(EnumMemberDeclarationSyntax enumMember)
{
if (!ConvertHelpers.CanConvert(value, numericType))
{
return(enumMember);
}
EnumMemberDeclarationSyntax newEnumMember = CreateNewEnumMember(enumMember, value, numericType);
value++;
return(newEnumMember);
}
}
private static Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
EnumMemberDeclarationSyntax newEnumMember,
int insertIndex,
CancellationToken cancellationToken)
{
EnumDeclarationSyntax newNode = enumDeclaration.WithMembers(enumDeclaration.Members.Insert(insertIndex, newEnumMember));
return(document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken));
}
private static async Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
EnumMemberDeclarationSyntax newEnumMember,
int insertIndex,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
EnumDeclarationSyntax newNode = enumDeclaration.WithMembers(enumDeclaration.Members.Insert(insertIndex, newEnumMember));
return(await document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken).ConfigureAwait(false));
}
private static Task <Document> SortByNameAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
SeparatedSyntaxListSelection <EnumMemberDeclarationSyntax> selectedMembers,
CancellationToken cancellationToken)
{
IEnumerable <EnumMemberDeclarationSyntax> sorted = selectedMembers.OrderBy(f => f, EnumMemberDeclarationNameComparer.Instance);
SeparatedSyntaxList <EnumMemberDeclarationSyntax> newMembers = enumDeclaration
.Members
.ReplaceRange(selectedMembers.FirstIndex, selectedMembers.Count, sorted);
MemberDeclarationSyntax newNode = enumDeclaration.WithMembers(newMembers);
return(document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken));
}
private static async Task <Document> SortEnumMembersAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
SpecialType enumSpecialType = semanticModel.GetDeclaredSymbol(enumDeclaration).EnumUnderlyingType.SpecialType;
SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members;
SeparatedSyntaxList <EnumMemberDeclarationSyntax> newMembers = members
.OrderBy(f => GetConstantValue(f, semanticModel, cancellationToken), EnumValueComparer.GetInstance(enumSpecialType))
.ToSeparatedSyntaxList();
if (AreSeparatedWithEmptyLine(members))
{
for (int i = 0; i < newMembers.Count; i++)
{
newMembers = newMembers.ReplaceAt(i, newMembers[i].TrimLeadingTrivia());
}
for (int i = 0; i < newMembers.Count - 1; i++)
{
SyntaxToken separator = newMembers.GetSeparator(i);
newMembers = newMembers.ReplaceSeparator(
separator,
separator.TrimTrailingTrivia().AppendToTrailingTrivia(new SyntaxTrivia[] { NewLine(), NewLine() }));
}
}
if (newMembers.SeparatorCount == members.SeparatorCount - 1)
{
SyntaxNodeOrTokenList newMembersWithSeparators = newMembers.GetWithSeparators();
newMembersWithSeparators = newMembersWithSeparators.Add(CommaToken());
newMembers = newMembersWithSeparators.ToSeparatedSyntaxList <EnumMemberDeclarationSyntax>();
}
MemberDeclarationSyntax newNode = enumDeclaration
.WithMembers(newMembers)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken).ConfigureAwait(false));
}
public static async Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
SeparatedSyntaxList <EnumMemberDeclarationSyntax> newMembers = enumDeclaration.Members
.OrderBy(f => GetConstantValue(f, semanticModel, cancellationToken), EnumMemberValueComparer.Instance)
.ToSeparatedSyntaxList();
MemberDeclarationSyntax newNode = enumDeclaration
.WithMembers(newMembers)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken).ConfigureAwait(false));
}
private static async Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
INamedTypeSymbol enumSymbol,
bool startFromHighestExistingValue,
CancellationToken cancellationToken)
{
SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members;
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
SpecialType specialType = enumSymbol.EnumUnderlyingType.SpecialType;
List <object> values = GetExplicitValues(enumDeclaration, semanticModel, cancellationToken);
for (int i = 0; i < members.Count; i++)
{
if (members[i].EqualsValue == null)
{
Optional <object> optional = FlagsUtility.GetUniquePowerOfTwo(specialType, values, startFromHighestExistingValue);
if (optional.HasValue)
{
values.Add(optional.Value);
EqualsValueClauseSyntax equalsValue = EqualsValueClause(CSharpFactory.LiteralExpression(optional.Value));
EnumMemberDeclarationSyntax newMember = members[i]
.WithEqualsValue(equalsValue)
.WithFormatterAnnotation();
members = members.ReplaceAt(i, newMember);
}
else
{
break;
}
}
}
EnumDeclarationSyntax newNode = enumDeclaration.WithMembers(members);
return(await document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken).ConfigureAwait(false));
}
private static async Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
INamedTypeSymbol enumSymbol,
ImmutableArray <ulong> values,
bool startFromHighestExistingValue,
CancellationToken cancellationToken)
{
SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members;
List <ulong> valuesList = values.ToList();
for (int i = 0; i < members.Count; i++)
{
if (members[i].EqualsValue == null)
{
Optional <ulong> optional = FlagsUtility <ulong> .Instance.GetUniquePowerOfTwo(valuesList, startFromHighestExistingValue);
if (optional.HasValue &&
ConvertHelpers.CanConvertFromUInt64(optional.Value, enumSymbol.EnumUnderlyingType.SpecialType))
{
valuesList.Add(optional.Value);
EqualsValueClauseSyntax equalsValue = EqualsValueClause(
Token(TriviaList(ElasticSpace), SyntaxKind.EqualsToken, TriviaList(ElasticSpace)),
CSharpFactory.NumericLiteralExpression(optional.Value, enumSymbol.EnumUnderlyingType.SpecialType));
EnumMemberDeclarationSyntax newMember = members[i].WithEqualsValue(equalsValue);
members = members.ReplaceAt(i, newMember);
}
else
{
break;
}
}
}
EnumDeclarationSyntax newNode = enumDeclaration.WithMembers(members);
return(await document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken).ConfigureAwait(false));
}
private static async Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
INamedTypeSymbol symbol = semanticModel.GetDeclaredSymbol(enumDeclaration, cancellationToken);
string name = NameGenerator.Default.EnsureUniqueMemberName("None", symbol);
EnumMemberDeclarationSyntax enumMember = EnumMemberDeclaration(
Identifier(name).WithRenameAnnotation(),
NumericLiteralExpression(0));
enumMember = enumMember.WithTrailingTrivia(NewLine());
EnumDeclarationSyntax newNode = enumDeclaration.WithMembers(enumDeclaration.Members.Insert(0, enumMember));
return(await document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken).ConfigureAwait(false));
}
private static Task <Document> SortByNameAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
ImmutableArray <EnumMemberDeclarationSyntax> selectedMembers,
CancellationToken cancellationToken)
{
SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members;
int firstIndex = members.IndexOf(selectedMembers[0]);
int lastIndex = members.IndexOf(selectedMembers[selectedMembers.Length - 1]);
SeparatedSyntaxList <EnumMemberDeclarationSyntax> newMembers = members
.Take(firstIndex)
.Concat(selectedMembers.OrderBy(f => f, EnumMemberDeclarationNameComparer.Instance))
.Concat(members.Skip(lastIndex + 1))
.ToSeparatedSyntaxList();
MemberDeclarationSyntax newNode = enumDeclaration.WithMembers(newMembers);
return(document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken));
}
public static async Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
string value,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
INamedTypeSymbol symbol = semanticModel.GetDeclaredSymbol(enumDeclaration, cancellationToken);
string name = NameGenerator.Default.EnsureUniqueEnumMemberName(DefaultNames.EnumMember, symbol);
EnumMemberDeclarationSyntax enumMember = EnumMemberDeclaration(
Identifier(name).WithRenameAnnotation(),
ParseExpression(value));
enumMember = enumMember.WithTrailingTrivia(NewLine());
EnumDeclarationSyntax newNode = enumDeclaration.WithMembers(enumDeclaration.Members.Add(enumMember));
return(await document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken).ConfigureAwait(false));
}
private static async Task <Document> SortByValueAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
SeparatedSyntaxListSelection <EnumMemberDeclarationSyntax> selectedMembers,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
SpecialType enumSpecialType = semanticModel.GetDeclaredSymbol(enumDeclaration, cancellationToken).EnumUnderlyingType.SpecialType;
var comparer = new EnumMemberDeclarationValueComparer(EnumValueComparer.GetInstance(enumSpecialType), semanticModel, cancellationToken);
IEnumerable <EnumMemberDeclarationSyntax> sorted = selectedMembers.OrderBy(f => f, comparer);
SeparatedSyntaxList <EnumMemberDeclarationSyntax> newMembers = enumDeclaration
.Members
.ReplaceRange(selectedMembers.FirstIndex, selectedMembers.Count, sorted);
MemberDeclarationSyntax newNode = enumDeclaration.WithMembers(newMembers);
return(await document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken).ConfigureAwait(false));
}
private static Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
SeparatedSyntaxListSelection <EnumMemberDeclarationSyntax> selection,
CancellationToken cancellationToken)
{
SeparatedSyntaxList <EnumMemberDeclarationSyntax> newMembers = enumDeclaration.Members.ModifyRange(
selection.FirstIndex,
selection.Count,
enumMember =>
{
return(enumMember
.WithEqualsValue(null)
.WithTrailingTrivia(enumMember.GetTrailingTrivia())
.WithFormatterAnnotation());
})
.ToSeparatedSyntaxList();
EnumDeclarationSyntax newEnumDeclaration = enumDeclaration.WithMembers(newMembers);
return(document.ReplaceNodeAsync(enumDeclaration, newEnumDeclaration, cancellationToken));
}
private static Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
SeparatedSyntaxListSelection <EnumMemberDeclarationSyntax> selection,
CancellationToken cancellationToken)
{
SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members;
SeparatedSyntaxList <EnumMemberDeclarationSyntax> newMembers = members;
for (int i = selection.StartIndex; i <= selection.EndIndex; i++)
{
EnumMemberDeclarationSyntax newMember = members[i]
.WithEqualsValue(null)
.WithTrailingTrivia(members[i].GetTrailingTrivia())
.WithFormatterAnnotation();
newMembers = newMembers.ReplaceAt(i, newMember);
}
EnumDeclarationSyntax newEnumDeclaration = enumDeclaration.WithMembers(newMembers);
return(document.ReplaceNodeAsync(enumDeclaration, newEnumDeclaration, cancellationToken));
}
private EnumDeclarationSyntax AddEnumDocs(EnumDeclarationSyntax enumNode, string summaryText, Dictionary <string, string> memberDocs)
{
if (!summaryText.EndsWith('.'))
{
summaryText += ".";
}
var xmlPad = XmlText(" ");
var xmlNewLine = XmlNewLine("\r\n");
var xmlNewLineNoTrail = XmlText(XmlTextNewLine("\r\n", false));
var seeTag = XmlName("see");
var docs = new XmlNodeSyntax[]
{
xmlPad,
XmlSummaryElement(
xmlNewLine,
xmlPad,
XmlText(summaryText),
xmlNewLine,
xmlPad
),
xmlNewLine,
xmlPad,
XmlRemarksElement(
XmlText($"Autogenerated from "),
XmlSeeHrefElement(_url, $"{enumNode.Identifier.ValueText} docs"),
XmlText($".")
),
xmlNewLineNoTrail
};
XmlElementEndTag(seeTag);
var nodes = enumNode.Members.Select(member => AddEnumMemberDocs(member, memberDocs[member.Identifier.ValueText]));
enumNode = enumNode.WithMembers(SeparatedList(nodes));
return(enumNode.WithLeadingTrivia(Trivia(DocumentationComment(docs))));
}
private static async Task <Document> DeclareExplicitValueAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
INamedTypeSymbol enumSymbol,
bool isFlags,
bool useBitShift,
ImmutableArray <ulong> values,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
List <ulong> reservedValues = values.ToList();
SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members;
SeparatedSyntaxList <EnumMemberDeclarationSyntax> newMembers = members;
for (int i = 0; i < members.Count; i++)
{
if (members[i].EqualsValue == null)
{
IFieldSymbol fieldSymbol = semanticModel.GetDeclaredSymbol(members[i], cancellationToken);
ulong?value = null;
if (isFlags)
{
Optional <ulong> optional = FlagsUtility <ulong> .Instance.GetUniquePowerOfTwo(reservedValues);
if (optional.HasValue &&
ConvertHelpers.CanConvertFromUInt64(optional.Value, enumSymbol.EnumUnderlyingType.SpecialType))
{
value = optional.Value;
}
}
else
{
value = SymbolUtility.GetEnumValueAsUInt64(fieldSymbol.ConstantValue, enumSymbol);
}
if (value != null)
{
reservedValues.Add(value.Value);
ExpressionSyntax expression;
if (useBitShift &&
value.Value > 1)
{
var power = (int)Math.Log(Convert.ToDouble(value.Value), 2);
expression = LeftShiftExpression(NumericLiteralExpression(1), NumericLiteralExpression(power));
}
else
{
expression = NumericLiteralExpression(value.Value, enumSymbol.EnumUnderlyingType.SpecialType);
}
EnumMemberDeclarationSyntax newMember = members[i].Update(
members[i].AttributeLists,
members[i].Modifiers,
members[i].Identifier.WithoutTrailingTrivia(),
EqualsValueClause(expression).WithTrailingTrivia(members[i].Identifier.TrailingTrivia));
newMembers = newMembers.ReplaceAt(i, newMember);
}
}
}
EnumDeclarationSyntax newEnumDeclaration = enumDeclaration.WithMembers(newMembers);
return(await document.ReplaceNodeAsync(enumDeclaration, newEnumDeclaration, cancellationToken).ConfigureAwait(false));
}
public override SyntaxNode VisitEnumDeclaration(EnumDeclarationSyntax node)
{
node = (EnumDeclarationSyntax)base.VisitEnumDeclaration(node);
return(node.WithMembers(SortMembers(node.Members)));
}