private static object GetValue(
EnumMemberDeclarationSyntax enumMember,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
IFieldSymbol fieldSymbol = semanticModel.GetDeclaredSymbol(enumMember, cancellationToken);
INamedTypeSymbol enumSymbol = fieldSymbol.ContainingType;
if (SymbolUtility.IsEnumWithFlagsAttribute(enumSymbol, semanticModel))
{
return(GetFlagsValue(enumMember, enumSymbol, semanticModel, cancellationToken));
}
else
{
return(fieldSymbol.ConstantValue);
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, EnumDeclarationSyntax enumDeclaration)
{
EnumMemberDeclarationSyntax[] selectedMembers = GetSelectedMembers(enumDeclaration, context.Span).ToArray();
if (selectedMembers.Length > 1)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
INamedTypeSymbol enumSymbol = semanticModel.GetDeclaredSymbol(enumDeclaration, context.CancellationToken);
if (enumSymbol != null &&
SymbolUtility.IsEnumWithFlagsAttribute(enumSymbol, semanticModel))
{
IFieldSymbol[] fieldSymbols = selectedMembers
.Select(f => semanticModel.GetDeclaredSymbol(f, context.CancellationToken))
.ToArray();
object[] constantValues = fieldSymbols
.Where(f => f.HasConstantValue)
.Select(f => f.ConstantValue)
.ToArray();
object combinedValue = GetCombinedValue(constantValues, enumSymbol);
if (combinedValue != null &&
!EnumHelper.IsValueDefined(enumSymbol, combinedValue))
{
SeparatedSyntaxList <EnumMemberDeclarationSyntax> enumMembers = enumDeclaration.Members;
string name = Identifier.EnsureUniqueEnumMemberName(
enumSymbol,
string.Concat(selectedMembers.Select(f => f.Identifier.ValueText)));
EnumMemberDeclarationSyntax newEnumMember = CreateEnumMember(name, selectedMembers);
int insertIndex = enumMembers.IndexOf(selectedMembers.Last()) + 1;
context.RegisterRefactoring(
$"Generate enum member '{name}'",
cancellationToken => RefactorAsync(context.Document, enumDeclaration, newEnumMember, insertIndex, cancellationToken));
}
}
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, EnumDeclarationSyntax enumDeclaration)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var enumSymbol = semanticModel.GetDeclaredSymbol(enumDeclaration, context.CancellationToken) as INamedTypeSymbol;
if (SymbolUtility.IsEnumWithFlagsAttribute(enumSymbol, semanticModel))
{
SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members;
if (members.Any(f => f.EqualsValue == null))
{
SpecialType specialType = enumSymbol.EnumUnderlyingType.SpecialType;
List <object> values = GenerateEnumHelper.GetExplicitValues(enumDeclaration, semanticModel, context.CancellationToken);
Optional <object> optional = EnumHelper.GetUniquePowerOfTwo(specialType, values);
if (optional.HasValue)
{
context.RegisterRefactoring(
"Generate enum values",
cancellationToken => RefactorAsync(context.Document, enumDeclaration, enumSymbol, startFromHighestExistingValue: false, cancellationToken: cancellationToken));
if (members.Any(f => f.EqualsValue != null))
{
Optional <object> optional2 = EnumHelper.GetUniquePowerOfTwo(specialType, values, startFromHighestExistingValue: true);
if (optional2.HasValue &&
!optional.Value.Equals(optional2.Value))
{
context.RegisterRefactoring(
$"Generate enum values (starting from {optional2.Value})",
cancellationToken => RefactorAsync(context.Document, enumDeclaration, enumSymbol, startFromHighestExistingValue: true, cancellationToken: cancellationToken));
}
}
}
}
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, EnumDeclarationSyntax enumDeclaration)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var enumSymbol = semanticModel.GetDeclaredSymbol(enumDeclaration, context.CancellationToken) as INamedTypeSymbol;
if (SymbolUtility.IsEnumWithFlagsAttribute(enumSymbol, semanticModel))
{
object[] values = EnumHelper.GetValues(enumSymbol).ToArray();
SpecialType specialType = enumSymbol.EnumUnderlyingType.SpecialType;
Optional <object> optional = EnumHelper.GetUniquePowerOfTwo(specialType, values);
if (optional.HasValue)
{
context.RegisterRefactoring(
"Generate enum member",
cancellationToken => RefactorAsync(context.Document, enumDeclaration, enumSymbol, optional.Value, cancellationToken));
Optional <object> optional2 = EnumHelper.GetUniquePowerOfTwo(specialType, values, startFromHighestExistingValue: true);
if (optional2.HasValue &&
!optional.Value.Equals(optional2.Value))
{
context.RegisterRefactoring(
$"Generate enum member (with value {optional2.Value})",
cancellationToken => RefactorAsync(context.Document, enumDeclaration, enumSymbol, optional2.Value, cancellationToken));
}
}
}
else
{
context.RegisterRefactoring(
"Generate enum member",
cancellationToken => RefactorAsync(context.Document, enumDeclaration, enumSymbol, null, cancellationToken));
}
}
private static object GetValue(
EnumMemberDeclarationSyntax enumMember,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
IFieldSymbol fieldSymbol = semanticModel.GetDeclaredSymbol(enumMember, cancellationToken);
INamedTypeSymbol enumSymbol = fieldSymbol.ContainingType;
if (SymbolUtility.IsEnumWithFlagsAttribute(enumSymbol, semanticModel))
{
var enumDeclaration = (EnumDeclarationSyntax)enumMember.Parent;
object[] values = GetExplicitValues(enumDeclaration, semanticModel, cancellationToken).ToArray();
SpecialType specialType = enumSymbol.EnumUnderlyingType.SpecialType;
Optional <object> optional = EnumHelper.GetUniquePowerOfTwo(
specialType,
values,
startFromHighestExistingValue: false);
Debug.Assert(optional.HasValue, "");
if (optional.HasValue)
{
object value = optional.Value;
SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members;
int index = members.IndexOf(enumMember);
int count = members.Take(index).Count(f => HasImplicitValue(f, semanticModel, cancellationToken));
switch (specialType)
{
case SpecialType.System_SByte:
return(GetUniquePowerOfTwo((sbyte)value, count, values.Cast <sbyte>().ToArray()));
case SpecialType.System_Byte:
return(GetUniquePowerOfTwo((byte)value, count, values.Cast <byte>().ToArray()));
case SpecialType.System_Int16:
return(GetUniquePowerOfTwo((short)value, count, values.Cast <short>().ToArray()));
case SpecialType.System_UInt16:
return(GetUniquePowerOfTwo((ushort)value, count, values.Cast <ushort>().ToArray()));
case SpecialType.System_Int32:
return(GetUniquePowerOfTwo((int)value, count, values.Cast <int>().ToArray()));
case SpecialType.System_UInt32:
return(GetUniquePowerOfTwo((uint)value, count, values.Cast <uint>().ToArray()));
case SpecialType.System_Int64:
return(GetUniquePowerOfTwo((long)value, count, values.Cast <long>().ToArray()));
case SpecialType.System_UInt64:
return(GetUniquePowerOfTwo((ulong)value, count, values.Cast <ulong>().ToArray()));
}
}
}
else
{
return(fieldSymbol.ConstantValue);
}
return(null);
}