private static IList<SyntaxNode> CreateGetHashCodeMethodStatements(
SyntaxGenerator factory,
Compilation compilation,
INamedTypeSymbol containingType,
IList<ISymbol> members,
CancellationToken cancellationToken)
{
const string HashCodeName = "hashCode";
// -1521134295
var permuteValue = factory.NegateExpression(
factory.LiteralExpression(1521134295));
var statements = new List<SyntaxNode>();
var hashCodeNameExpression = factory.IdentifierName(HashCodeName);
var firstHashValue = ComputeHashValue(factory, compilation, members[0]);
if (members.Count == 1)
{
#if false
return this.S1.GetHashCode();
#endif
statements.Add(factory.ReturnStatement(firstHashValue));
}
else
{
#if false
var hashCode = this.S1.GetHashCode();
#endif
statements.Add(factory.LocalDeclarationStatement(HashCodeName, firstHashValue));
for (var i = 1; i < members.Count; i++)
{
#if false
hashCode = hashCode * 0xA5555529 + value
#endif
statements.Add(factory.ExpressionStatement(
factory.AssignmentStatement(hashCodeNameExpression,
factory.AddExpression(
factory.MultiplyExpression(hashCodeNameExpression, permuteValue),
ComputeHashValue(factory, compilation, members[i])))));
}
#if false
return hashCode;
#endif
statements.Add(factory.ReturnStatement(hashCodeNameExpression));
}
return statements;
}
private IFieldSymbol GetExplicitlyAssignedField(IFieldSymbol originalField, SyntaxGenerator syntaxFactoryService)
{
var originalInitializer = GetFieldInitializer(originalField);
if (originalInitializer != null || !originalField.HasConstantValue)
{
return originalField;
}
var constantValueExpression = syntaxFactoryService.LiteralExpression(originalField.ConstantValue);
var newInitializer = CreateConstantValueInitializer(constantValueExpression);
return CodeGenerationSymbolFactory.CreateFieldSymbol(originalField.GetAttributes(), originalField.DeclaredAccessibility, originalField.GetSymbolModifiers(),
originalField.Type, originalField.Name, originalField.HasConstantValue, originalField.ConstantValue, newInitializer);
}
private IList<ISymbol> GetNewFieldsForRuleNameNoZeroValue(INamedTypeSymbol enumType, SyntaxGenerator syntaxFactoryService)
{
// Diagnostic: Add a member to '{0}' that has a value of zero with a suggested name of 'None'.
// Fix: Add a zero-valued member 'None' to enum.
var newFields = new List<ISymbol>();
var constantValueExpression = syntaxFactoryService.LiteralExpression(0);
var newInitializer = CreateConstantValueInitializer(constantValueExpression);
var newField = CodeGenerationSymbolFactory.CreateFieldSymbol(SpecializedCollections.EmptyList<AttributeData>(), Accessibility.Public,
default(SymbolModifiers), enumType.EnumUnderlyingType, "None", true, 0, newInitializer);
newFields.Add(newField);
foreach (var member in enumType.GetMembers())
{
if (!CA1008DiagnosticAnalyzer.IsMemberNamedNone(member))
{
newFields.Add(member);
}
}
return newFields;
}
private IList<ISymbol> GetNewFieldsForRuleNameMultipleZero(INamedTypeSymbol enumType, IEnumerable<IFieldSymbol> zeroValuedFields, SyntaxGenerator syntaxFactoryService)
{
// Diagnostic: Remove all members that have the value zero from '{0}' except for one member that is named 'None'.
// Fix: Remove all members that have the value zero except for one member that is named 'None'.
bool needsNewZeroValuedNoneField = true;
var set = zeroValuedFields.ToSet();
bool makeNextFieldExplicit = false;
var newFields = new List<ISymbol>();
foreach (IFieldSymbol field in enumType.GetMembers().Where(m => m.Kind == SymbolKind.Field))
{
var isZeroValued = set.Contains(field);
var isZeroValuedNamedNone = isZeroValued && CA1008DiagnosticAnalyzer.IsMemberNamedNone(field);
if (!isZeroValued || isZeroValuedNamedNone)
{
var newField = field;
if (makeNextFieldExplicit)
{
newField = GetExplicitlyAssignedField(field, syntaxFactoryService);
makeNextFieldExplicit = false;
}
newFields.Add(newField);
if (isZeroValuedNamedNone)
{
needsNewZeroValuedNoneField = false;
}
}
else
{
makeNextFieldExplicit = true;
}
}
if (needsNewZeroValuedNoneField)
{
var firstZeroValuedField = zeroValuedFields.First();
var constantValueExpression = syntaxFactoryService.LiteralExpression(firstZeroValuedField.ConstantValue);
var newInitializer = CreateConstantValueInitializer(constantValueExpression);
var newField = CodeGenerationSymbolFactory.CreateFieldSymbol(firstZeroValuedField.GetAttributes(), firstZeroValuedField.DeclaredAccessibility, firstZeroValuedField.GetSymbolModifiers(),
firstZeroValuedField.Type, "None", firstZeroValuedField.HasConstantValue, firstZeroValuedField.ConstantValue, newInitializer);
newFields.Insert(0, newField);
}
return newFields;
}
