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); }