public static void AnalyzeNamedType(SymbolAnalysisContext context, INamedTypeSymbol flagsAttribute)
{
var enumSymbol = (INamedTypeSymbol)context.Symbol;
if (enumSymbol.IsEnum() &&
enumSymbol.HasAttribute(flagsAttribute))
{
var infos = default(ImmutableArray <EnumFieldInfo>);
foreach (ISymbol member in enumSymbol.GetMembers())
{
if (member.IsField())
{
var fieldSymbol = (IFieldSymbol)member;
if (!fieldSymbol.HasConstantValue)
{
break;
}
var info = new EnumFieldInfo(fieldSymbol);
if (info.IsComposite())
{
var declaration = (EnumMemberDeclarationSyntax)info.Symbol.GetSyntax(context.CancellationToken);
ExpressionSyntax valueExpression = declaration.EqualsValue?.Value;
if (valueExpression != null &&
(valueExpression.IsKind(SyntaxKind.NumericLiteralExpression) ||
valueExpression
.DescendantNodes()
.Any(f => f.IsKind(SyntaxKind.NumericLiteralExpression))))
{
if (infos.IsDefault)
{
infos = EnumFieldInfo.CreateRange(enumSymbol);
if (infos.IsDefault)
{
break;
}
}
List <EnumFieldInfo> values = info.Decompose(infos);
if (values?.Count > 1)
{
context.ReportDiagnostic(
DiagnosticDescriptors.DeclareEnumValueAsCombinationOfNames,
valueExpression);
}
}
}
}
}
}
}
public static async Task <Document> RefactorAsync(
Document document,
EnumMemberDeclarationSyntax enumMemberDeclaration,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
IFieldSymbol enumMemberSymbol = semanticModel.GetDeclaredSymbol(enumMemberDeclaration, cancellationToken);
ImmutableArray <EnumFieldInfo> infos = EnumFieldInfo.CreateRange(enumMemberSymbol.ContainingType);
ExpressionSyntax value = enumMemberDeclaration.EqualsValue?.Value;
var info = new EnumFieldInfo(enumMemberSymbol);
List <EnumFieldInfo> values = info.Decompose(infos);
values.Sort((f, g) =>
{
if (f.IsComposite())
{
if (g.IsComposite())
{
return(((IComparable)f.Value).CompareTo((IComparable)g.Value));
}
else
{
return(-1);
}
}
else if (g.IsComposite())
{
return(1);
}
return(((IComparable)f.Value).CompareTo((IComparable)g.Value));
});
BinaryExpressionSyntax newValue = BitwiseOrExpression(values[0].ToIdentifierName(), values[1].ToIdentifierName());
for (int i = 2; i < values.Count; i++)
{
newValue = BitwiseOrExpression(newValue, values[i].ToIdentifierName());
}
newValue = newValue.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(value, newValue, cancellationToken).ConfigureAwait(false));
}
internal static bool TryReadProperty(ref Utf8JsonReader reader, EnumFieldInfo obj, JsonSerializerOptions options)
{
if (reader.ValueTextEquals(nameof(obj.Value)))
{
obj.Value = reader.ReadInt64();
return(true);
}
if (reader.ValueTextEquals(nameof(obj.Name)))
{
obj.Name = reader.ReadString();
return(true);
}
if (reader.ValueTextEquals(nameof(obj.DisplayName)))
{
obj.DisplayName = reader.ReadString();
return(true);
}
return(false);
}
public SDKEnumFieldInfo(IntPtr address, RemoteProcess remoteProcess)
{
EnumFieldInfo typeInfo = remoteProcess.Read <EnumFieldInfo>(address);
EnumFieldInfoData typeInfoData = remoteProcess.Read <EnumFieldInfoData>(typeInfo.m_InfoData);
Name = $"{remoteProcess.ReadString(typeInfoData.m_Name, 255)}";
ThisTypeInfo = address;
Type = typeInfoData.GetNewEntryType();
Flags = typeInfoData.m_Flags;
Alignment = typeInfoData.m_Alignment;
TotalSize = typeInfoData.m_TotalSize;
FieldCount = typeInfoData.m_FieldCount;
RuntimeId = typeInfo.m_RuntimeId;
Next = typeInfo.m_Next;
if (FieldCount > 0)
{
for (int i = 0; i < FieldCount; i++)
{
var fieldInfoData = remoteProcess.Read <FieldInfoData>((IntPtr)((Int64)typeInfoData.m_Fields + (i * 0x18)));
SDKFieldEntry fieldEntry;
fieldEntry.fieldName = remoteProcess.ReadString(fieldInfoData.m_Name, 255);
fieldEntry.fieldType = "";
fieldEntry.fieldInternalType = "";
fieldEntry.fieldBasicType = BasicTypesEnum.kTypeCode_Void;
fieldEntry.fieldOffset = 0;
fieldEntry.fieldSize = 0;
fieldEntry.lastFieldOffset = 0;
fieldEntry.lastFieldSize = 0;
Fields.Add(fieldEntry);
}
}
}
public EditEnumFieldCommand(Lazy <HexBufferFileServiceFactory> hexBufferFileServiceFactory, EnumFieldInfo enumFieldInfo)
: base(hexBufferFileServiceFactory)
{
this.enumFieldInfo = enumFieldInfo;
}
internal static void WriteProperties(Utf8JsonWriter writer, EnumFieldInfo value, JsonSerializerOptions options)
{
writer.WriteNumber(nameof(value.Value), value.Value);
writer.WriteString(nameof(value.Name), value.Name);
writer.WriteString(nameof(value.DisplayName), value.DisplayName);
}
public override QueryPropertyInfo ReadJson(JsonReader reader, Type objectType, QueryPropertyInfo existingValue, bool hasExistingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
else if (reader.TokenType != JsonToken.StartObject)
{
throw new InvalidOperationException();
}
var r = new QueryPropertyInfo();
BooleanQueryPropertyInfo getOrCreateBoolean()
=> (r as BooleanQueryPropertyInfo) ?? (BooleanQueryPropertyInfo)(r = new BooleanQueryPropertyInfo
{
Name = r.Name,
DisplayName = r.DisplayName,
TypeName = r.TypeName,
DefaultOperator = r.DefaultOperator,
});
DateTimeQueryPropertyInfo getOrCreateDateTime()
=> (r as DateTimeQueryPropertyInfo) ?? (DateTimeQueryPropertyInfo)(r = new DateTimeQueryPropertyInfo
{
Name = r.Name,
DisplayName = r.DisplayName,
TypeName = r.TypeName,
DefaultOperator = r.DefaultOperator,
});
EnumQueryPropertyInfo getOrCreateEnum()
=> (r as EnumQueryPropertyInfo) ?? (EnumQueryPropertyInfo)(r = new EnumQueryPropertyInfo
{
Name = r.Name,
DisplayName = r.DisplayName,
TypeName = r.TypeName,
DefaultOperator = r.DefaultOperator,
});
while (reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.EndObject:
return(r);
case JsonToken.PropertyName:
var propertyName = reader.Value?.ToString();
if (!reader.Read())
{
throw new InvalidOperationException();
}
switch (propertyName)
{
case nameof(r.TypeName):
var tn = reader.Value?.ToString();
switch (tn)
{
case nameof(DateTime):
case nameof(DateTimeOffset):
getOrCreateDateTime();
break;
case nameof(Boolean):
getOrCreateBoolean();
break;
case nameof(Enum):
getOrCreateEnum();
break;
}
r.TypeName = tn;
break;
case nameof(r.Name):
r.Name = reader.Value?.ToString();
break;
case nameof(r.DisplayName):
r.DisplayName = reader.Value?.ToString();
break;
case nameof(r.DefaultOperator):
r.DefaultOperator = reader.Value?.ToString();
break;
case nameof(BooleanQueryPropertyInfo.TrueString):
getOrCreateBoolean().TrueString = reader.Value?.ToString();
break;
case nameof(BooleanQueryPropertyInfo.FalseString):
getOrCreateBoolean().FalseString = reader.Value?.ToString();
break;
case nameof(DateTimeQueryPropertyInfo.IsDate):
getOrCreateDateTime().IsDate = reader.Value is bool bds ||
reader.Value is string ds && bool.TryParse(ds, out bds)
? bds : false;
break;
case nameof(EnumQueryPropertyInfo.Fields):
var er = getOrCreateEnum();
if (reader.TokenType == JsonToken.Null)
{
er.Fields = null;
}
else if (reader.TokenType != JsonToken.StartArray)
{
throw new InvalidOperationException();
}
else
{
EnumFieldInfo f = null;
while (reader.Read() && reader.TokenType != JsonToken.EndArray)
{
switch (reader.TokenType)
{
case JsonToken.EndObject:
if (f != null)
{
er.Fields.Add(f);
f = null;
}
break;
case JsonToken.StartObject:
f = new EnumFieldInfo();
break;
case JsonToken.PropertyName:
switch (reader.Value?.ToString())
{
case nameof(f.Name):
f.Name = reader.ReadAsString();
break;
case nameof(f.DisplayName):
f.DisplayName = reader.ReadAsString();
break;
case nameof(f.Value):
f.Value = (long)reader.ReadAsDouble();
break;
default:
if (!reader.Read())
{
throw new InvalidOperationException();
}
break;
}
break;
}
}
}
break;
}
break;
}
}
throw new InvalidOperationException();
}
