private static string GetNewFieldName(IFieldSymbol fieldSymbol)
{
var name = fieldSymbol.Name.Trim('_');
if (name.Length > 2 && char.IsLetter(name[0]) && name[1] == '_')
{
name = name.Substring(2);
}
if (name.Length == 0)
{
return fieldSymbol.Name;
}
if (name.Length > 2 && char.IsUpper(name[0]) && char.IsLower(name[1]))
{
name = char.ToLower(name[0]) + name.Substring(1);
}
if (fieldSymbol.IsStatic)
{
// Check for ThreadStatic private fields.
if (fieldSymbol.GetAttributes().Any(a => a.AttributeClass.Name.Equals("ThreadStaticAttribute", StringComparison.Ordinal)))
{
return "t_" + name;
}
else
{
return "s_" + name;
}
}
return "_" + name;
}
protected static bool FieldIsRelevant(IFieldSymbol fieldSymbol)
{
return fieldSymbol != null &&
!fieldSymbol.IsStatic &&
!fieldSymbol.IsConst &&
fieldSymbol.DeclaredAccessibility == Accessibility.Public;
}
private static bool ContainingTypeImplementsIDisposableAndCallsItOnTheField(SymbolAnalysisContext context, IFieldSymbol fieldSymbol)
{
var containingType = fieldSymbol.ContainingType;
if (containingType == null) return false;
var iDisposableInterface = containingType.AllInterfaces.FirstOrDefault(i => i.ToString() == "System.IDisposable");
if (iDisposableInterface == null) return false;
var disposableMethod = iDisposableInterface.GetMembers("Dispose").OfType<IMethodSymbol>().First(d => d.Arity == 0);
var disposeMethodSymbol = containingType.FindImplementationForInterfaceMember(disposableMethod) as IMethodSymbol;
if (disposeMethodSymbol == null) return false;
if (disposeMethodSymbol.IsAbstract) return true;
foreach (MethodDeclarationSyntax disposeMethod in disposeMethodSymbol.DeclaringSyntaxReferences.Select(sr => sr.GetSyntax()))
{
if (disposeMethod == null) return false;
var semanticModel = context.Compilation.GetSemanticModel(disposeMethod.SyntaxTree);
if (CallsDisposeOnField(fieldSymbol, disposeMethod, semanticModel)) return true;
var invocations = disposeMethod.DescendantNodes().OfKind<InvocationExpressionSyntax>(SyntaxKind.InvocationExpression);
foreach (var invocation in invocations)
{
var invocationExpressionSymbol = semanticModel.GetSymbolInfo(invocation.Expression).Symbol;
if (invocationExpressionSymbol == null
|| invocationExpressionSymbol.Kind != SymbolKind.Method
|| invocationExpressionSymbol.Locations.Any(l => l.Kind != LocationKind.SourceFile)
|| !invocationExpressionSymbol.ContainingType.Equals(containingType)) continue;
foreach (MethodDeclarationSyntax method in invocationExpressionSymbol.DeclaringSyntaxReferences.Select(sr => sr.GetSyntax()))
if (CallsDisposeOnField(fieldSymbol, method, semanticModel)) return true;
}
}
return false;
}
internal static EnumDeclarationSyntax AddEnumMemberTo(EnumDeclarationSyntax destination, IFieldSymbol enumMember, CodeGenerationOptions options)
{
var members = new List<SyntaxNodeOrToken>();
members.AddRange(destination.Members.GetWithSeparators());
var member = GenerateEnumMemberDeclaration(enumMember, destination, options);
if (members.Count == 0)
{
members.Add(member);
}
else if (members.LastOrDefault().CSharpKind() == SyntaxKind.CommaToken)
{
members.Add(member);
members.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
else
{
var lastMember = members.Last();
var trailingTrivia = lastMember.GetTrailingTrivia();
members[members.Count - 1] = lastMember.WithTrailingTrivia();
members.Add(SyntaxFactory.Token(SyntaxKind.CommaToken).WithTrailingTrivia(trailingTrivia));
members.Add(member);
}
return destination.EnsureOpenAndCloseBraceTokens()
.WithMembers(SyntaxFactory.SeparatedList<EnumMemberDeclarationSyntax>(members));
}
private static string GetNewFieldName(IFieldSymbol fieldSymbol)
{
var name = fieldSymbol.Name.Trim('_');
if (name.Length > 2 && char.IsLetter(name[0]) && name[1] == '_')
{
name = name.Substring(2);
}
if (name.Length == 0)
{
return fieldSymbol.Name;
}
if (name.Length > 2 && char.IsUpper(name[0]) && char.IsLower(name[1]))
{
name = char.ToLower(name[0]) + name.Substring(1);
}
if ((fieldSymbol.IsStatic && fieldSymbol.IsReadOnly) || fieldSymbol.IsConst)
{
return ToUppercaseWords(name);
}
return "_" + name;
}
private SDField GetParsedField(IFieldSymbol field)
{
var syntaxReference = field.DeclaringSyntaxReferences.Any() ? field.DeclaringSyntaxReferences.Single() : null;
var sdField = new SDField(field.GetIdentifier())
{
Name = field.Name,
DeclaringType = _typeRefParser.GetParsedTypeReference(field.ContainingType),
Accessibility = field.DeclaredAccessibility.ToString().ToLower(),
ReturnType = _typeRefParser.GetParsedTypeReference(field.Type),
ConstantValue = field.ConstantValue != null ? field.ConstantValue.ToString() : string.Empty,
IsConst = field.IsConst,
IsReadonly = field.IsReadOnly,
Documentations = DocumentationParser.ParseDocumentation(field),
Region = syntaxReference != null ? new SDRegion
{
Start = syntaxReference.Span.Start,
End = syntaxReference.Span.End,
StartLine = syntaxReference.SyntaxTree.GetLineSpan(syntaxReference.Span).StartLinePosition.Line + 1,
EndLine = syntaxReference.SyntaxTree.GetLineSpan(syntaxReference.Span).EndLinePosition.Line + 1,
FilePath = syntaxReference.SyntaxTree.FilePath,
Filename = Path.GetFileName(syntaxReference.SyntaxTree.FilePath)
} : null
};
ParserOptions.SDRepository.AddMember(sdField);
return sdField;
}
private static bool FieldIsRelevant(IFieldSymbol fieldSymbol)
{
return fieldSymbol != null &&
fieldSymbol.IsStatic &&
!fieldSymbol.IsConst &&
!fieldSymbol.IsReadOnly &&
fieldSymbol.DeclaredAccessibility != Accessibility.Private;
}
public static void Attach(
IFieldSymbol field,
bool isUnsafe,
bool isWithEvents,
SyntaxNode initializer)
{
var info = new CodeGenerationFieldInfo(isUnsafe, isWithEvents, initializer);
fieldToInfoMap.Add(field, info);
}
/// <summary>
/// Creates a field declaration matching an existing field symbol.
/// </summary>
public SyntaxNode FieldDeclaration(IFieldSymbol field, SyntaxNode initializer = null)
{
return FieldDeclaration(
field.Name,
TypeExpression(field.Type),
field.DeclaredAccessibility,
SymbolModifiers.From(field),
initializer);
}
private bool IsParentAClass(IFieldSymbol fieldDeclarationSyntax)
{
if (fieldDeclarationSyntax.ContainingSymbol != null &&
fieldDeclarationSyntax.ContainingSymbol.Kind == SymbolKind.NamedType)
{
return ((ITypeSymbol)fieldDeclarationSyntax.ContainingSymbol).TypeKind == TypeKind.Class;
}
return false;
}
private SyntaxNode GetExplicitlyAssignedField(IFieldSymbol originalField, SyntaxNode declaration, SyntaxGenerator generator)
{
SyntaxNode originalInitializer = generator.GetExpression(declaration);
if (originalInitializer != null || !originalField.HasConstantValue)
{
return declaration;
}
return generator.WithExpression(declaration, generator.LiteralExpression(originalField.ConstantValue));
}
internal override SyntaxNode GetFieldInitializer(IFieldSymbol field)
{
if (field.DeclaringSyntaxReferences.Length == 0)
{
return null;
}
var syntax = field.DeclaringSyntaxReferences.First().GetSyntax();
var enumMemberSyntax = syntax as EnumMemberDeclarationSyntax;
return enumMemberSyntax == null ? null : enumMemberSyntax.EqualsValue;
}
private IEnumerable<EncapsulateFieldCodeAction> EncapsulateOneField(Document document, TextSpan span, IFieldSymbol field, int index)
{
var action1Text = string.Format(FeaturesResources.EncapsulateFieldUsages, field.Name);
var action2Text = string.Format(FeaturesResources.EncapsulateField, field.Name);
return new[]
{
new EncapsulateFieldCodeAction(new EncapsulateFieldResult(c => SingleEncapsulateFieldResultAsync(document, span, index, true, c)), action1Text),
new EncapsulateFieldCodeAction(new EncapsulateFieldResult(c => SingleEncapsulateFieldResultAsync(document, span, index, false, c)), action2Text)
};
}
private static void CheckForDiagnostics(SyntaxNodeAnalysisContext context, FieldDeclarationSyntax fieldNode, IFieldSymbol fieldSymbol)
{
var isStatic = fieldSymbol.IsStatic;
var isPublic = fieldSymbol.DeclaredAccessibility.HasFlag(Accessibility.Public);
var isReadOnly = fieldSymbol.IsReadOnly;
if (!isStatic || !isPublic || !isReadOnly)
{
context.ReportDiagnostic(Diagnostic.Create(
EvaluateManagedBackingFieldsAnalayzer.mustBePublicStaticAndReadonlyRule,
fieldNode.GetLocation()));
}
}
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);
}
internal static CompilationUnitSyntax AddFieldTo(
CompilationUnitSyntax destination,
IFieldSymbol field,
CodeGenerationOptions options,
IList<bool> availableIndices)
{
var declaration = GenerateFieldDeclaration(field, CodeGenerationDestination.CompilationUnit, options);
// Place the field after the last field or const, or at the start of the type
// declaration.
var members = Insert(destination.Members, declaration, options, availableIndices,
after: m => LastField(m, declaration), before: FirstMember);
return destination.WithMembers(members.ToSyntaxList());
}
private static bool CallsDisposeOnField(IFieldSymbol fieldSymbol, MethodDeclarationSyntax disposeMethod, SemanticModel semanticModel)
{
var hasDisposeCall = disposeMethod.Body.Statements.OfType<ExpressionStatementSyntax>()
.Any(exp =>
{
var invocation = exp.Expression as InvocationExpressionSyntax;
if (!invocation?.Expression?.IsKind(SyntaxKind.SimpleMemberAccessExpression) ?? true) return false;
var memberAccess = (MemberAccessExpressionSyntax)invocation.Expression;
if (memberAccess.Name.Identifier.ToString() != "Dispose" || memberAccess.Name.Arity != 0) return false;
var memberAccessIdentificer = memberAccess.Expression as IdentifierNameSyntax;
if (memberAccessIdentificer == null) return false;
return fieldSymbol.Equals(semanticModel.GetSymbolInfo(memberAccessIdentificer).Symbol);
});
return hasDisposeCall;
}
internal static TypeDeclarationSyntax AddFieldTo(
TypeDeclarationSyntax destination,
IFieldSymbol field,
CodeGenerationOptions options,
IList<bool> availableIndices)
{
var declaration = GenerateFieldDeclaration(field, GetDestination(destination), options);
// Place the field after the last field or const, or at the start of the type
// declaration.
var members = Insert(destination.Members, declaration, options, availableIndices,
after: m => LastField(m, declaration), before: FirstMember);
return AddMembersTo(destination, members);
}
private static void AddVariableThatWasSkippedBeforeBecauseItLackedAInitializer(Dictionary<IFieldSymbol, VariableDeclaratorSyntax> variablesToMakeReadonly, IFieldSymbol fieldSymbol, AssignmentExpressionSyntax assignment)
{
var parent = assignment.Parent;
while (parent != null)
{
if (parent is AnonymousFunctionExpressionSyntax)
return;
if (parent is ConstructorDeclarationSyntax)
break;
parent = parent.Parent;
}
if (!fieldSymbol.IsReadOnly && !variablesToMakeReadonly.Keys.Contains(fieldSymbol))
foreach (var variable in fieldSymbol.DeclaringSyntaxReferences)
variablesToMakeReadonly.Add(fieldSymbol, (VariableDeclaratorSyntax)variable.GetSyntax());
}
private static bool IsAssignedOutsideConstructor(SymbolAnalysisContext context, IFieldSymbol fieldSymbol)
{
var containingType = fieldSymbol.ContainingType;
foreach (var typeDecl in containingType.DeclaringSyntaxReferences)
{
var isAssignedWalker = new IsAssignedOutsideConstructorWalker(fieldSymbol);
isAssignedWalker.Visit(typeDecl.GetSyntax());
if (isAssignedWalker.IsAssigned)
{
return true;
}
}
return false;
}
public static string GetWidgetFieldName (IFieldSymbol field)
{
foreach (AttributeData att in field.GetAttributes ()) {
var type = att.AttributeClass;
if (type.Name == "Widget" || type.Name == "WidgetAttribute") {
var pArgs = att.ConstructorArguments;
if (pArgs != null && pArgs.Length > 0) {
var exp = pArgs[0].Value;
if (exp != null)
return exp.ToString ();
} else {
return field.Name;
}
}
}
return field.Name;
}
private SDField GetParsedField(IFieldSymbol field)
{
var sdField = new SDField(field.GetIdentifier())
{
Name = field.Name,
DeclaringType = _typeRefParser.GetParsedTypeReference(field.ContainingType),
Accessibility = field.DeclaredAccessibility.ToString().ToLower(),
ReturnType = _typeRefParser.GetParsedTypeReference(field.Type),
ConstantValue = field.ConstantValue != null ? field.ConstantValue.ToString() : string.Empty,
IsConst = field.IsConst,
IsReadonly = field.IsReadOnly,
Documentations = DocumentationParser.ParseDocumentation(field)
};
ParserOptions.SDRepository.AddMember(sdField);
return sdField;
}
public static EnumMemberDeclarationSyntax GenerateEnumMemberDeclaration(
IFieldSymbol enumMember,
EnumDeclarationSyntax destinationOpt,
CodeGenerationOptions options)
{
var reusableSyntax = GetReuseableSyntaxNodeForSymbol<EnumMemberDeclarationSyntax>(enumMember, options);
if (reusableSyntax != null)
{
return reusableSyntax;
}
var value = CreateEnumMemberValue(destinationOpt, enumMember);
var member = SyntaxFactory.EnumMemberDeclaration(enumMember.Name.ToIdentifierToken())
.WithEqualsValue(value == null ? null : SyntaxFactory.EqualsValueClause(value: value));
return AddCleanupAnnotationsTo(
ConditionallyAddDocumentationCommentTo(member, enumMember, options));
}
private async Task<Document> AddDisposeCall(Document document, SyntaxNode declaration, IFieldSymbol fieldSymbol, IMethodSymbol disposeMethod, ITypeSymbol iDisposableType, ISymbol iDisposable_Dispose, CancellationToken cancellationToken)
{
SymbolEditor editor = SymbolEditor.Create(document);
await editor.EditOneDeclarationAsync(disposeMethod, (docEditor, disposeMethodNode) =>
{
var generator = docEditor.Generator;
// handle the case where a local in the Dispose method exists with the same name by generating this (or ClassName) and simplifying it
var path = fieldSymbol.IsStatic
? generator.IdentifierName(fieldSymbol.ContainingType.MetadataName)
: generator.ThisExpression();
var disposeMethodOfFieldType = fieldSymbol.Type.FindImplementationForInterfaceMember(iDisposable_Dispose) as IMethodSymbol;
// If the original interface was implemented implicitly then we can simply invoke through the name of the implementation.
// Note that in VB, the name of the method implementing the interface method can be different from the interface method name.
SyntaxNode statement;
if (disposeMethodOfFieldType.CanBeReferencedByName)
{
statement =
generator.ExpressionStatement(
generator.InvocationExpression(
generator.MemberAccessExpression(
generator.MemberAccessExpression(path, generator.IdentifierName(fieldSymbol.Name)).WithAdditionalAnnotations(Simplifier.Annotation),
generator.IdentifierName(disposeMethodOfFieldType.Name))));
}
// Otherwise dispatch through the interface
else
{
statement =
generator.ExpressionStatement(
generator.InvocationExpression(
generator.MemberAccessExpression(
generator.CastExpression(iDisposableType,
generator.MemberAccessExpression(path, generator.IdentifierName(fieldSymbol.Name)).WithAdditionalAnnotations(Simplifier.Annotation)),
generator.IdentifierName(DisposableFieldsShouldBeDisposedAnalyzer.Dispose))));
}
var body = generator.GetStatements(disposeMethodNode);
docEditor.SetStatements(disposeMethodNode, body.Concat(ImmutableArray.Create(statement)));
}).ConfigureAwait(false);
return editor.GetChangedDocuments().First();
}
private static bool ContainingTypeImplementsIDisposableAndCallsItOnTheField(SymbolAnalysisContext context, IFieldSymbol fieldSymbol, INamedTypeSymbol typeSymbol)
{
if (typeSymbol == null) return false;
var iDisposableInterface = typeSymbol.AllInterfaces.FirstOrDefault(i => i.ToString() == "System.IDisposable");
if (iDisposableInterface != null)
{
var disposableMethod = iDisposableInterface.GetMembers("Dispose").OfType<IMethodSymbol>().First(d => d.Arity == 0);
var disposeMethodSymbol = typeSymbol.FindImplementationForInterfaceMember(disposableMethod) as IMethodSymbol;
if (disposeMethodSymbol != null)
{
var disposeMethod = (MethodDeclarationSyntax)disposeMethodSymbol.DeclaringSyntaxReferences.FirstOrDefault()?.GetSyntax();
if (disposeMethod == null) return false;
if (disposeMethod.Modifiers.Any(SyntaxKind.AbstractKeyword)) return true;
var typeDeclaration = (TypeDeclarationSyntax)typeSymbol.DeclaringSyntaxReferences.FirstOrDefault().GetSyntax();
var semanticModel = context.Compilation.GetSemanticModel(typeDeclaration.SyntaxTree);
if (CallsDisposeOnField(fieldSymbol, disposeMethod, semanticModel)) return true;
}
}
return false;
}
private IFieldSymbol GetNamedField(
INamedTypeSymbol containingType, IFieldSymbol unnamedField, CancellationToken cancellationToken)
{
foreach (var member in containingType.GetMembers())
{
cancellationToken.ThrowIfCancellationRequested();
if (member.Kind == SymbolKind.Field)
{
var fieldSymbol = (IFieldSymbol)member;
if (unnamedField.Equals(fieldSymbol.CorrespondingTupleField) &&
!fieldSymbol.Name.Equals(unnamedField.Name))
{
return fieldSymbol;
}
}
}
return null;
}
private IList<ISymbol> GetNewFieldsForRuleNameRename(INamedTypeSymbol enumType, IFieldSymbol zeroValuedField)
{
// Diagnostic: In enum '{0}', change the name of '{1}' to 'None'.
// Fix: Rename zero-valued enum field to 'None'.
var newFields = new List<ISymbol>();
foreach (IFieldSymbol field in enumType.GetMembers().Where(m => m.Kind == SymbolKind.Field))
{
if (field != zeroValuedField)
{
newFields.Add(field);
}
else
{
var newInitializer = GetFieldInitializer(field);
var newField = CodeGenerationSymbolFactory.CreateFieldSymbol(field.GetAttributes(), field.DeclaredAccessibility, field.GetSymbolModifiers(),
field.Type, "None", field.HasConstantValue, field.ConstantValue, newInitializer);
newFields.Add(newField);
}
}
return newFields;
}
public static FieldDeclarationSyntax GenerateFieldDeclaration(
IFieldSymbol field, CodeGenerationDestination destination, CodeGenerationOptions options)
{
var reusableSyntax = GetReuseableSyntaxNodeForSymbol<VariableDeclaratorSyntax>(field, options);
if (reusableSyntax != null)
{
var variableDeclaration = reusableSyntax.Parent as VariableDeclarationSyntax;
if (variableDeclaration != null)
{
var newVariableDeclaratorsList = new SeparatedSyntaxList<VariableDeclaratorSyntax>().Add(reusableSyntax);
var newVariableDeclaration = variableDeclaration.WithVariables(newVariableDeclaratorsList);
var fieldDecl = variableDeclaration.Parent as FieldDeclarationSyntax;
if (fieldDecl != null)
{
return fieldDecl.WithDeclaration(newVariableDeclaration);
}
}
}
var initializerNode = CodeGenerationFieldInfo.GetInitializer(field) as ExpressionSyntax;
var initializer = initializerNode != null
? SyntaxFactory.EqualsValueClause(initializerNode)
: GenerateEqualsValue(field);
var fieldDeclaration = SyntaxFactory.FieldDeclaration(
AttributeGenerator.GenerateAttributeLists(field.GetAttributes(), options),
GenerateModifiers(field, options),
SyntaxFactory.VariableDeclaration(
field.Type.GenerateTypeSyntax(),
SyntaxFactory.SingletonSeparatedList(
AddAnnotationsTo(field, SyntaxFactory.VariableDeclarator(field.Name.ToIdentifierToken(), null, initializer)))));
return AddCleanupAnnotationsTo(
ConditionallyAddDocumentationCommentTo(fieldDeclaration, field, options));
}
public abstract SyntaxNode CreateFieldDeclaration(IFieldSymbol field, CodeGenerationDestination destination, CodeGenerationOptions options);
private string GenerateFieldName(IFieldSymbol field, string correspondingPropertyName)
{
return(char.ToLower(correspondingPropertyName[0]).ToString() + correspondingPropertyName.Substring(1));
}
private static async Task <GraphNode> GetOrCreateNodeForFieldAsync(Graph graph, IFieldSymbol field, Solution solution, CancellationToken cancellationToken)
{
var id = await GraphNodeIdCreation.GetIdForMemberAsync(field, solution, cancellationToken).ConfigureAwait(false);
var node = graph.Nodes.GetOrCreate(id);
node.AddCategory(CodeNodeCategories.Field);
if (field.ContainingType.TypeKind == TypeKind.Enum)
{
node[DgmlNodeProperties.Icon] = IconHelper.GetIconName("EnumMember", field.DeclaredAccessibility);
}
else
{
node[DgmlNodeProperties.Icon] = IconHelper.GetIconName("Field", field.DeclaredAccessibility);
}
return(node);
}
internal static EnumDeclarationSyntax AddEnumMemberTo(EnumDeclarationSyntax destination, IFieldSymbol enumMember, CodeGenerationOptions options)
{
var members = new List <SyntaxNodeOrToken>();
members.AddRange(destination.Members.GetWithSeparators());
var member = GenerateEnumMemberDeclaration(enumMember, destination, options);
if (members.Count == 0)
{
members.Add(member);
}
else if (members.LastOrDefault().Kind() == SyntaxKind.CommaToken)
{
members.Add(member);
members.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
else
{
var lastMember = members.Last();
var trailingTrivia = lastMember.GetTrailingTrivia();
members[members.Count - 1] = lastMember.WithTrailingTrivia();
members.Add(SyntaxFactory.Token(SyntaxKind.CommaToken).WithTrailingTrivia(trailingTrivia));
members.Add(member);
}
return(destination.EnsureOpenAndCloseBraceTokens()
.WithMembers(SyntaxFactory.SeparatedList <EnumMemberDeclarationSyntax>(members)));
}
private int CombineHashCodes(IFieldSymbol x, int currentHash)
{
return
(Hash.Combine(x.Name,
GetHashCode(x.ContainingSymbol, currentHash)));
}
protected virtual bool IsEligibleHeuristic(IFieldSymbol field, TPropertyDeclaration propertyDeclaration, Compilation compilation, CancellationToken cancellationToken)
{
return(true);
}
public Task <Document> AddFieldAsync(Solution solution, INamedTypeSymbol destination, IFieldSymbol field, CodeGenerationOptions options, CancellationToken cancellationToken)
{
return(GetEditAsync(
solution,
destination,
(t, opts, ai) => AddField(t, field, opts, ai),
options,
new[] { field },
cancellationToken));
}
public TDeclarationNode AddField <TDeclarationNode>(TDeclarationNode destination, IFieldSymbol field, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
{
return(AddField(destination, field, options ?? CodeGenerationOptions.Default, GetAvailableInsertionIndices(destination, cancellationToken)));
}
internal override bool IsViableField(IFieldSymbol field, SyntaxNode expression, SemanticModel semanticModel, ISyntaxFactsService syntaxFacts, CancellationToken cancellationToken)
{
return(IsViablePropertyOrField(field, expression, semanticModel, syntaxFacts, cancellationToken));
}
private async Task AddDescriptionForFieldAsync(IFieldSymbol symbol)
{
var parts = await GetFieldPartsAsync(symbol).ConfigureAwait(false);
// Don't bother showing disambiguating text for enum members. The icon displayed
// on Quick Info should be enough.
if (symbol.ContainingType != null && symbol.ContainingType.TypeKind == TypeKind.Enum)
{
AddToGroup(SymbolDescriptionGroups.MainDescription, parts);
}
else
{
AddToGroup(SymbolDescriptionGroups.MainDescription,
symbol.IsConst
? Description(FeaturesResources.constant)
: Description(FeaturesResources.field),
parts);
}
}
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.CanConvert(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);
}
EqualsValueClauseSyntax equalsValue = EqualsValueClause(expression);
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));
}
public override void VisitField(IFieldSymbol symbol)
{
symbol.Type.Accept(this);
}
public static int GetTupleElementIndex(this IFieldSymbol fieldSymbol)
{
Contract.Assert(fieldSymbol.ContainingType.IsTupleType);
return(fieldSymbol.DynamicGetProperty <int>("TupleElementIndex") + 1);
}
public WrappedFieldSymbol(IFieldSymbol fieldSymbol, IDocumentationCommentFormattingService docCommentFormattingService)
: base(fieldSymbol, canImplementImplicitly: false, docCommentFormattingService: docCommentFormattingService)
{
_symbol = fieldSymbol;
}
private static async Task <Document> GetUpdatedDocumentForRuleNameRenameAsync(Document document, IFieldSymbol field, CancellationToken cancellationToken)
{
Solution newSolution = await CodeAnalysis.Rename.Renamer.RenameSymbolAsync(document.Project.Solution, field, "None", null, cancellationToken).ConfigureAwait(false);
return(newSolution.GetDocument(document.Id) !);
}
public static SyntaxNode GetInitializer(IFieldSymbol field)
{
return(GetInitializer(GetInfo(field)));
}
private static ExpressionSyntax CreateEnumMemberValue(EnumDeclarationSyntax destinationOpt, IFieldSymbol enumMember)
{
if (!enumMember.HasConstantValue)
{
return(null);
}
if (!(enumMember.ConstantValue is byte) &&
!(enumMember.ConstantValue is sbyte) &&
!(enumMember.ConstantValue is ushort) &&
!(enumMember.ConstantValue is short) &&
!(enumMember.ConstantValue is int) &&
!(enumMember.ConstantValue is uint) &&
!(enumMember.ConstantValue is long) &&
!(enumMember.ConstantValue is ulong))
{
return(null);
}
var value = IntegerUtilities.ToInt64(enumMember.ConstantValue);
if (destinationOpt != null)
{
if (destinationOpt.Members.Count == 0)
{
if (value == 0)
{
return(null);
}
}
else
{
// Don't generate an initializer if no other members have them, and our value
// would be correctly inferred from our position.
if (destinationOpt.Members.Count == value &&
destinationOpt.Members.All(m => m.EqualsValue == null))
{
return(null);
}
// Existing members, try to stay consistent with their style.
var lastMember = destinationOpt.Members.LastOrDefault(m => m.EqualsValue != null);
if (lastMember != null)
{
var lastExpression = lastMember.EqualsValue.Value;
if (lastExpression.Kind() == SyntaxKind.LeftShiftExpression &&
IntegerUtilities.HasOneBitSet(value))
{
var binaryExpression = (BinaryExpressionSyntax)lastExpression;
if (binaryExpression.Left.Kind() == SyntaxKind.NumericLiteralExpression)
{
var numericLiteral = (LiteralExpressionSyntax)binaryExpression.Left;
if (numericLiteral.Token.ValueText == "1")
{
// The user is left shifting ones, stick with that pattern
var shiftValue = IntegerUtilities.LogBase2(value);
return(SyntaxFactory.BinaryExpression(
SyntaxKind.LeftShiftExpression,
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal("1", 1)),
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(shiftValue.ToString(), shiftValue))));
}
}
}
else if (lastExpression.Kind() == SyntaxKind.NumericLiteralExpression)
{
var numericLiteral = (LiteralExpressionSyntax)lastExpression;
var numericToken = numericLiteral.Token;
var numericText = numericToken.ToString();
if (numericText.StartsWith("0x") || numericText.StartsWith("0X"))
{
// Hex
return(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression,
SyntaxFactory.Literal(numericText.Substring(0, 2) + value.ToString("X"), value)));
}
}
}
}
}
var namedType = enumMember.Type as INamedTypeSymbol;
var underlyingType = namedType != null ? namedType.EnumUnderlyingType : null;
return(ExpressionGenerator.GenerateNonEnumValueExpression(
underlyingType,
enumMember.ConstantValue,
canUseFieldReference: true));
}
public override void VisitField(IFieldSymbol symbol)
{
_builder.Append(symbol.Type.Name, CodeFileTokenKind.TypeName);
_builder.Punctuation(SyntaxKind.DotToken);
_builder.Append(symbol.Name, CodeFileTokenKind.MemberName);
}
private static void CheckField(SymbolAnalysisContext context, INamedTypeSymbol containerClassSymbol, IFieldSymbol field)
{
CheckFieldOrProperty(field, containerClassSymbol, context,
f =>
{
var reference = f.DeclaringSyntaxReferences.FirstOrDefault();
var syntax = reference?.GetSyntax() as VariableDeclaratorSyntax;
return(syntax?.Identifier.GetLocation());
},
"field");
}
public static void Create(IFieldSymbol symbol, SymbolKeyWriter visitor)
{
visitor.WriteString(symbol.MetadataName);
visitor.WriteSymbolKey(symbol.ContainingType);
}
private bool IsHandled(SemanticModel model, SwitchStatementSyntax switchStatement, IFieldSymbol field)
{
//if any label in any section has a value equal to the field name, return true
return(switchStatement.Sections.Any(s => s.Labels.Any(l => l is CaseSwitchLabelSyntax && ((CaseSwitchLabelSyntax)l).Value != null && ((MemberAccessExpressionSyntax)((CaseSwitchLabelSyntax)l).Value).Name.Identifier.ValueText.Equals(field.Name))));
}
private bool IsNew(IFieldSymbol field)
{
return(field.DeclaringSyntaxReferences.Any(d => d.GetSyntax().GetAncestor <FieldDeclarationSyntax>().Modifiers.Any(SyntaxKind.NewKeyword)));
}
public static bool GetIsWithEvents(IFieldSymbol field)
{
return(GetIsWithEvents(GetInfo(field)));
}
private SwitchSectionSyntax GetSectionFromSymbol(SemanticModel model, IFieldSymbol field, TextSpan span)
{
return(SyntaxFactory.SwitchSection().WithLabels(SyntaxFactory.SingletonList <SwitchLabelSyntax>(SyntaxFactory.CaseSwitchLabel(
SyntaxFactory.IdentifierName(field.ToMinimalDisplayString(model, span.Start))))).WithStatements(SyntaxFactory.SingletonList <StatementSyntax>(SyntaxFactory.BreakStatement())));
}
public static bool GetIsUnsafe(IFieldSymbol field)
{
return(GetIsUnsafe(GetInfo(field)));
}
private static bool IsNullableValue(IFieldSymbol field)
{
return(field.Type.IsValueType && field.NullableAnnotation == NullableAnnotation.Annotated);
}
public override SyntaxNode CreateFieldDeclaration(IFieldSymbol field, CodeGenerationDestination destination, CodeGenerationOptions options)
{
return(destination == CodeGenerationDestination.EnumType
? EnumMemberGenerator.GenerateEnumMemberDeclaration(field, null, options)
: (SyntaxNode)FieldGenerator.GenerateFieldDeclaration(field, destination, options));
}
public override bool VisitField(IFieldSymbol symbol)
{
return(Visit(symbol.Type));
}
protected override TDeclarationNode AddField <TDeclarationNode>(TDeclarationNode destination, IFieldSymbol field, CSharpCodeGenerationOptions options, IList <bool>?availableIndices, CancellationToken cancellationToken)
{
CheckDeclarationNode <EnumDeclarationSyntax, TypeDeclarationSyntax, CompilationUnitSyntax>(destination);
if (destination is EnumDeclarationSyntax)
{
return(Cast <TDeclarationNode>(EnumMemberGenerator.AddEnumMemberTo(Cast <EnumDeclarationSyntax>(destination), field, options, cancellationToken)));
}
else if (destination is TypeDeclarationSyntax)
{
return(Cast <TDeclarationNode>(FieldGenerator.AddFieldTo(Cast <TypeDeclarationSyntax>(destination), field, options, availableIndices, cancellationToken)));
}
else
{
return(Cast <TDeclarationNode>(FieldGenerator.AddFieldTo(Cast <CompilationUnitSyntax>(destination), field, options, availableIndices, cancellationToken)));
}
}
protected abstract TDeclarationNode AddField <TDeclarationNode>(TDeclarationNode destination, IFieldSymbol field, CodeGenerationOptions options, IList <bool> availableIndices) where TDeclarationNode : SyntaxNode;
private async Task<ImmutableArray<SymbolDisplayPart>> GetFieldPartsAsync(IFieldSymbol symbol)
{
if (symbol.IsConst)
{
var initializerParts = await GetInitializerSourcePartsAsync(symbol).ConfigureAwait(false);
if (!initializerParts.IsDefaultOrEmpty)
{
var parts = ArrayBuilder<SymbolDisplayPart>.GetInstance();
parts.AddRange(ToMinimalDisplayParts(symbol, MinimallyQualifiedFormat));
parts.AddRange(Space());
parts.AddRange(Punctuation("="));
parts.AddRange(Space());
parts.AddRange(initializerParts);
return parts.ToImmutableAndFree();
}
}
return ToMinimalDisplayParts(symbol, MinimallyQualifiedFormatWithConstants);
}
private async Task <IEnumerable <SymbolDisplayPart> > GetInitializerSourcePartsAsync(IFieldSymbol symbol)
{
EqualsValueClauseSyntax initializer = null;
var variableDeclarator = await this.GetFirstDeclaration <VariableDeclaratorSyntax>(symbol).ConfigureAwait(false);
if (variableDeclarator != null)
{
initializer = variableDeclarator.Initializer;
}
if (initializer == null)
{
var enumMemberDeclaration = await this.GetFirstDeclaration <EnumMemberDeclarationSyntax>(symbol).ConfigureAwait(false);
if (enumMemberDeclaration != null)
{
initializer = enumMemberDeclaration.EqualsValue;
}
}
if (initializer != null)
{
return(await GetInitializerSourcePartsAsync(initializer).ConfigureAwait(false));
}
return(null);
}
