public static async Task ComputeRefactoringAsync(RefactoringContext context, IndexerDeclarationSyntax indexerDeclaration) { if (!indexerDeclaration.HasSingleLineDocumentationComment()) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); BaseDocumentationCommentInfo info = DocumentationCommentGenerator.GenerateFromBase(indexerDeclaration, semanticModel, context.CancellationToken); if (info.Success) { RegisterRefactoring(context, indexerDeclaration, info); } } }
private static Task <Document> RefactorAsync( Document document, IndexerDeclarationSyntax indexerDeclaration, CancellationToken cancellationToken) { IndexerDeclarationSyntax newNode = indexerDeclaration .WithSemicolonToken(default(SyntaxToken)) .WithAccessorList(MakeMemberAbstractHelper.ExpandAccessorList(indexerDeclaration.AccessorList)) .WithModifiers(indexerDeclaration.Modifiers.Replace(SyntaxKind.AbstractKeyword, VirtualKeyword())) .WithTriviaFrom(indexerDeclaration) .WithFormatterAnnotation(); return(document.ReplaceNodeAsync(indexerDeclaration, newNode, cancellationToken)); }
public static async Task ComputeRefactoringAsync(RefactoringContext context, IndexerDeclarationSyntax indexerDeclaration) { if (!indexerDeclaration.HasSingleLineDocumentationComment()) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); IPropertySymbol propertySymbol = semanticModel.GetDeclaredSymbol(indexerDeclaration); if (propertySymbol?.IsErrorType() == false) { ComputeRefactoring <IPropertySymbol>(context, indexerDeclaration, propertySymbol, propertySymbol.OverriddenProperty); } } }
public override void VisitIndexerDeclaration(IndexerDeclarationSyntax node) { VisitAttributeLists(node.AttributeLists); if (!ShouldVisit) { return; } TypeSyntax type = node.Type; if (type != null) { VisitType(type); } if (!ShouldVisit) { return; } BracketedParameterListSyntax parameterList = node.ParameterList; if (node != null) { VisitBracketedParameterList(parameterList); } if (!ShouldVisit) { return; } AccessorListSyntax accessorList = node.AccessorList; if (accessorList != null) { VisitAccessorList(accessorList); } else { ArrowExpressionClauseSyntax expressionBody = node.ExpressionBody; if (expressionBody != null) { VisitArrowExpressionClause(expressionBody); } } }
public override void VisitIndexerDeclaration(IndexerDeclarationSyntax node) { foreach (AttributeListSyntax attributeList in node.AttributeLists) { attributeList.Accept(this); } node.AccessorList?.Accept(this); node.ExplicitInterfaceSpecifier?.Accept(this); node.ExpressionBody?.Accept(this); node.ParameterList?.Accept(this); node.Type?.Accept(this); base.VisitIndexerDeclaration(node); }
public override SyntaxNode VisitIndexerDeclaration(IndexerDeclarationSyntax node) { if (node == null) { return(null); } var symbol = _semanticModel.GetDeclaredSymbol(node); node = (IndexerDeclarationSyntax)base.VisitIndexerDeclaration(node); if (!IsPrivateOrInternal(symbol.DeclaredAccessibility)) { node = (IndexerDeclarationSyntax)ApplyDocComment(node, symbol.GetDocumentationCommentId()); } return(node); }
public static bool ContainsOnlyThrowNewException(IndexerDeclarationSyntax indexerDeclaration, SemanticModel semanticModel, CancellationToken cancellationToken) { ArrowExpressionClauseSyntax expressionBody = indexerDeclaration.ExpressionBody; if (expressionBody != null) { return(ContainsOnlyThrowNewException(expressionBody, semanticModel, cancellationToken)); } else { return(indexerDeclaration.AccessorList? .Accessors .All(f => ContainsOnlyThrowNewException(f.BodyOrExpressionBody(), semanticModel, cancellationToken)) == true); } }
/// <summary> /// Try getting the <see cref="IPropertySymbol"/> for the node. /// Gets the semantic model for the tree if the node is not in the tree corresponding to <paramref name="semanticModel"/>. /// </summary> /// <param name="semanticModel">The <see cref="SemanticModel"/>.</param> /// <param name="node">The <see cref="IndexerDeclarationSyntax"/>.</param> /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param> /// <param name="symbol">The symbol if found.</param> /// <returns>True if a symbol was found.</returns> public static bool TryGetSymbol(this SemanticModel semanticModel, IndexerDeclarationSyntax node, CancellationToken cancellationToken, [NotNullWhen(true)] out IPropertySymbol?symbol) { if (semanticModel is null) { throw new ArgumentNullException(nameof(semanticModel)); } if (node is null) { throw new ArgumentNullException(nameof(node)); } symbol = GetDeclaredSymbolSafe(semanticModel, node, cancellationToken); return(symbol != null); }
private static IndexerDeclarationSyntax MakeAbstract(IndexerDeclarationSyntax indexerDeclaration) { if (indexerDeclaration == null) { throw new ArgumentNullException(nameof(indexerDeclaration)); } AccessorListSyntax accessorList = AccessorList(); if (indexerDeclaration.ExpressionBody != null) { accessorList = accessorList .AddAccessors( AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithSemicolonToken(Token(SyntaxKind.SemicolonToken))); } else { AccessorDeclarationSyntax getter = indexerDeclaration.Getter(); if (getter != null) { accessorList = accessorList.AddAccessors(getter .WithBody(null) .WithSemicolonToken(Token(SyntaxKind.SemicolonToken))); } AccessorDeclarationSyntax setter = indexerDeclaration.Setter(); if (setter != null) { accessorList = accessorList.AddAccessors(setter .WithBody(null) .WithSemicolonToken(Token(SyntaxKind.SemicolonToken))); } } SyntaxTokenList modifiers = indexerDeclaration.Modifiers; if (!modifiers.Contains(SyntaxKind.AbstractKeyword)) { modifiers = modifiers.Add(Token(SyntaxKind.AbstractKeyword)); } return(indexerDeclaration .WithExpressionBody(null) .WithSemicolonToken(Token(SyntaxKind.None)) .WithAccessorList(accessorList) .WithModifiers(modifiers)); }
public override SyntaxNode VisitIndexerDeclaration(IndexerDeclarationSyntax node) { bool isPubliclyVisible = node.IsPubliclyVisible(); node = (IndexerDeclarationSyntax)base.VisitIndexerDeclaration(node); if (isPubliclyVisible && !node.HasSingleLineDocumentationComment()) { return(DocumentationCommentGenerator.GenerateAndAttach(node, _settings)); } else { return(node); } }
private static IndexerDeclarationSyntax ExpandIndexer(IndexerDeclarationSyntax indexerDeclaration) { IEnumerable <AccessorDeclarationSyntax> accessors = indexerDeclaration .AccessorList .Accessors .Select(f => f.WithBody(Block()).WithoutSemicolonToken()); AccessorListSyntax accessorList = AccessorList(List(accessors)); accessorList = Remover.RemoveWhitespaceOrEndOfLine(accessorList) .WithCloseBraceToken(accessorList.CloseBraceToken.WithLeadingTrivia(NewLineTrivia())); return(indexerDeclaration .WithSemicolonToken(default(SyntaxToken)) .WithAccessorList(accessorList)); }
public override SyntaxNode VisitIndexerDeclaration(IndexerDeclarationSyntax node) { bool isPubliclyVisible = IsPubliclyVisible(node); node = (IndexerDeclarationSyntax)base.VisitIndexerDeclaration(node); if (isPubliclyVisible && !node.HasDocumentationComment()) { return(AddDocumentationComment(node)); } else { return(node); } }
public static IndexerDeclarationSyntax ToStatementBody(IndexerDeclarationSyntax property) { var accessor = SyntaxFactory .AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithBody(SyntaxFactory.Block(SyntaxFactory.ReturnStatement(property.ExpressionBody.Expression.WithLeadingTrivia(SyntaxFactory.Space)))); var accessorDeclList = new SyntaxList <AccessorDeclarationSyntax>(); accessorDeclList = accessorDeclList.Add(accessor); return(property .WithAccessorList(SyntaxFactory.AccessorList(accessorDeclList)) .WithExpressionBody(null) .WithSemicolonToken(SyntaxFactory.MissingToken(SyntaxKind.SemicolonToken)) .WithTrailingTrivia(property.GetTrailingTrivia())); }
private static SyntaxNode HandleIndexerDeclaration(IndexerDeclarationSyntax node) { TypeSyntax type = node.Type; if (type == null || type.IsMissing) { return(null); } SyntaxTokenList modifiers = AddModifier(node.Modifiers, ref type, SyntaxKind.PrivateKeyword); return(node .WithType(type) .WithModifiers(modifiers) .WithoutFormatting()); }
public override SyntaxNode VisitIndexerDeclaration(IndexerDeclarationSyntax node) { if (generator.GetAttributes(node).Any(attr => generator.GetName(attr) == "CompilerGenerated")) { return(base.VisitIndexerDeclaration(node)); } var trivia = node.GetTrailingTrivia(); // NOTE: Most of this code could be shared with VisitPropertyDeclaration but the mutating With* // and props like ExpressionBody aren't available in the shared base BasePropertyDeclarationSyntax type :( var canRead = (node.ExpressionBody != null || node.AccessorList?.Accessors.Any(x => x.IsKind(SyntaxKind.GetAccessorDeclaration)) == true); var canWrite = node.AccessorList?.Accessors.Any(x => x.IsKind(SyntaxKind.SetAccessorDeclaration)) == true; if (node.ExpressionBody != null) { node = node.RemoveNode(node.ExpressionBody, SyntaxRemoveOptions.KeepNoTrivia); } if (node.AccessorList?.Accessors.Any() == true) { node = node.RemoveNodes(node.AccessorList.Accessors, SyntaxRemoveOptions.KeepNoTrivia); } if (canRead && !canWrite) { node = node.WithExpressionBody( ArrowExpressionClause(ExecutePipeline(node.Type, node.ParameterList.Parameters))); } else { if (canRead) { node = node.AddAccessorListAccessors(AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) .WithExpressionBody(ArrowExpressionClause(ExecutePipeline(node.Type, node.ParameterList.Parameters))) .WithSemicolonToken(Token(SyntaxKind.SemicolonToken))); } if (canWrite) { node = node.AddAccessorListAccessors(AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) .WithExpressionBody(ArrowExpressionClause( ExecutePipeline(null, node.ParameterList.Parameters.Concat(new[] { Parameter(Identifier("value")).WithType(node.Type) })))) .WithSemicolonToken(Token(SyntaxKind.SemicolonToken))); } } return(base.VisitIndexerDeclaration(node.WithTrailingTrivia(trivia))); }
private static IndexerDeclarationSyntax UseExpressionBodyIfDesired( Workspace workspace, IndexerDeclarationSyntax declaration, ParseOptions options) { if (declaration.ExpressionBody == null) { var expressionBodyPreference = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers).Value; if (TryGetExpressionBody(declaration.AccessorList, options, expressionBodyPreference, out var expressionBody, out var semicolonToken)) { declaration = declaration.WithAccessorList(null) .WithExpressionBody(expressionBody) .WithSemicolonToken(semicolonToken); } } return(declaration); }
public static void Analyze(SyntaxNodeAnalysisContext context, IndexerDeclarationSyntax indexerDeclaration) { if (indexerDeclaration.IsParentKind(SyntaxKind.InterfaceDeclaration) || indexerDeclaration.Modifiers.Contains(SyntaxKind.AbstractKeyword)) { ArrowExpressionClauseSyntax expressionBody = indexerDeclaration.ExpressionBody; if (expressionBody != null) { ReportDiagnostic(context, indexerDeclaration, expressionBody); } else { Analyze(context, indexerDeclaration, indexerDeclaration.AccessorList); } } }
public override void VisitIndexerDeclaration(IndexerDeclarationSyntax node) { if (HasModifier(node, "private") || HasModifier(node, "internal")) { return; } var returnType = _typeConverter.GetType(node.Type); // Improve the autocomplete on data[symbol] if data is a Slice and symbol a Symbol // In C# this is of type dynamic, which by default gets converted to typing.Any // To improve the autocomplete a bit we convert it to Union[TradeBar, QuoteBar, List[Tick], Any] if (_currentClass?.Type.ToPythonString() == "QuantConnect.Data.Slice") { returnType = new PythonType("Union", "typing") { TypeParameters = { new PythonType("TradeBar", "QuantConnect.Data.Market"), new PythonType("QuoteBar", "QuantConnect.Data.Market"), new PythonType("List", "System.Collections.Generic") { TypeParameters = { new PythonType("Tick","QuantConnect.Data.Market") } }, new PythonType("Any", "typing") } }; } if (returnType.Namespace == "System" && returnType.Name == "Object") { returnType = new PythonType("Any", "typing"); } VisitMethod(node, "__getitem__", node.ParameterList.Parameters, returnType); var symbol = _typeConverter.GetSymbol(node); if (symbol is IPropertySymbol propertySymbol && !propertySymbol.IsReadOnly) { VisitMethod(node, "__setitem__", node.ParameterList.Parameters, new PythonType("None")); var valueParameter = new Parameter("value", returnType); _currentClass.Methods.Last().Parameters.Add(valueParameter); } }
private static IndexerDeclarationSyntax UseExpressionBodyIfDesired( CSharpCodeGenerationContextInfo info, IndexerDeclarationSyntax declaration) { if (declaration.ExpressionBody == null) { if (TryGetExpressionBody( declaration, info.LanguageVersion, info.Options.PreferExpressionBodiedIndexers.Value, out var expressionBody, out var semicolonToken)) { declaration = declaration.WithAccessorList(null) .WithExpressionBody(expressionBody) .WithSemicolonToken(semicolonToken); } } return(declaration); }
internal static OverriddenSymbolInfo Create( IndexerDeclarationSyntax indexerDeclaration, SemanticModel semanticModel, CancellationToken cancellationToken = default(CancellationToken)) { if (indexerDeclaration == null) { return(Default); } if (semanticModel == null) { throw new ArgumentNullException(nameof(semanticModel)); } return(CreateImpl(indexerDeclaration, semanticModel, cancellationToken)); }
public static async Task ComputeRefactoringAsync(RefactoringContext context, IndexerDeclarationSyntax indexerDeclaration) { if (indexerDeclaration.HasDocumentationComment()) { return; } SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); DocumentationCommentData data = DocumentationCommentGenerator.GenerateFromBase(indexerDeclaration, semanticModel, context.CancellationToken); if (!data.Success) { return; } RegisterRefactoring(context, indexerDeclaration, data); }
public static void ComputeRefactoring(RefactoringContext context, IndexerDeclarationSyntax indexerDeclaration) { SyntaxTokenList modifiers = indexerDeclaration.Modifiers; if (modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.StaticKeyword)) { return; } if ((indexerDeclaration.Parent as ClassDeclarationSyntax)?.Modifiers.Contains(SyntaxKind.AbstractKeyword) != true) { return; } context.RegisterRefactoring( "Make indexer abstract", cancellationToken => RefactorAsync(context.Document, indexerDeclaration, cancellationToken)); }
private void HandleIndexerDeclaration(SyntaxNodeAnalysisContext context) { IndexerDeclarationSyntax declaration = context.Node as IndexerDeclarationSyntax; SyntaxKind defaultVisibility = SyntaxKind.PrivateKeyword; if (this.IsInterfaceMemberDeclaration(declaration) || declaration.ExplicitInterfaceSpecifier != null) { defaultVisibility = SyntaxKind.PublicKeyword; } if (declaration != null && this.NeedsComment(declaration.Modifiers, defaultVisibility)) { if (!XmlCommentHelper.HasDocumentation(declaration)) { context.ReportDiagnostic(Diagnostic.Create(Descriptor, declaration.ThisKeyword.GetLocation())); } } }
public static ParametersInfo Create(IndexerDeclarationSyntax indexerDeclaration, bool allowMissing = false) { BaseParameterListSyntax parameterList = indexerDeclaration.ParameterList; if (!CheckParameterList(parameterList, allowMissing)) { return(Default); } CSharpSyntaxNode body = indexerDeclaration.AccessorList ?? (CSharpSyntaxNode)indexerDeclaration.ExpressionBody; if (!Check(body, allowMissing)) { return(Default); } return(new ParametersInfo(default(TypeParameterListSyntax), parameterList, body)); }
internal static void Analyze(SyntaxNodeAnalysisContext context, IndexerDeclarationSyntax indexerDeclaration) { SyntaxTokenList modifiers = indexerDeclaration.Modifiers; if (modifiers.Contains(SyntaxKind.OverrideKeyword) && !modifiers.Contains(SyntaxKind.SealedKeyword) && indexerDeclaration .AccessorList? .Accessors .All(accessor => CanRefactor(indexerDeclaration, accessor, context.SemanticModel, context.CancellationToken)) == true && !indexerDeclaration.ContainsDirectives) { context.ReportDiagnostic( DiagnosticDescriptors.RemoveRedundantOverridingMember, indexerDeclaration, indexerDeclaration.GetTitle()); } }
/// <summary> /// Determines whether the <see cref="IndexerDeclarationSyntax"/> has a specified /// indexer parameter (it's string representation). Basically, an indexer parameter /// is what contained inside the square brackets. For example, for <code><this[int i]/code> /// the indexer parameter will be "int i". /// </summary> /// <param name="indexer"> /// The target indexer that may contain the expected parameter. /// </param> /// <param name="param"> /// The string representation of the indexer parameter. /// Basically, an indexer parameter is what contained inside the square brackets. /// For example, for <code><this[int i]/code> the indexer parameter will be "int i". /// </param> /// <returns> /// <see cref="true"/> when the string representation of the indexer parameter matches /// the actual indexer parameter, else <see cref="false"/>. /// </returns> public static bool HasIndexerParam(this IndexerDeclarationSyntax indexer, string param) { _ = indexer ?? throw new ArgumentNullException(nameof(indexer)); _ = param ?? throw new ArgumentNullException(nameof(param)); if (string.IsNullOrEmpty(param)) { throw new ArgumentException( "The provided string representation of the indexer parameter cannot be empty.", nameof(param)); } SyntaxNode?match = indexer.ParameterList?.ChildNodes() .FirstOrDefault( x => x.GetType() == typeof(ParameterSyntax) && x.ToString() == param); return(match != null); }
internal static SourcePropertySymbol Create( SourceMemberContainerTypeSymbol containingType, Binder bodyBinder, IndexerDeclarationSyntax syntax, BindingDiagnosticBag diagnostics ) { var location = syntax.ThisKeyword.GetLocation(); return(Create( containingType, bodyBinder, syntax, DefaultIndexerName, location, diagnostics )); }
public override SyntaxNode VisitIndexerDeclaration(IndexerDeclarationSyntax node) { string currentMethodOld = currentMethod; currentMethod = node.ToString(); try { if (RemoveProperty(node)) { return(null); } return(base.VisitIndexerDeclaration(node)); } finally { currentMethod = currentMethodOld; } }
public static Task <Document> RefactorAsync( Document document, IndexerDeclarationSyntax indexerDeclaration, CancellationToken cancellationToken = default) { AccessorListSyntax accessorList = AccessorList(); if (indexerDeclaration.ExpressionBody != null) { accessorList = accessorList .AddAccessors( AutoGetAccessorDeclaration()); } else { AccessorDeclarationSyntax getter = indexerDeclaration.Getter(); if (getter != null) { accessorList = accessorList.AddAccessors(getter .WithBody(null) .WithSemicolonToken(SemicolonToken())); } AccessorDeclarationSyntax setter = indexerDeclaration.Setter(); if (setter != null) { accessorList = accessorList.AddAccessors(setter .WithBody(null) .WithSemicolonToken(SemicolonToken())); } } IndexerDeclarationSyntax newNode = indexerDeclaration .WithExpressionBody(null) .WithSemicolonToken(default(SyntaxToken)) .WithAccessorList(accessorList) .InsertModifier(SyntaxKind.AbstractKeyword) .RemoveModifier(SyntaxKind.VirtualKeyword) .WithTriviaFrom(indexerDeclaration) .WithFormatterAnnotation(); return(document.ReplaceNodeAsync(indexerDeclaration, newNode, cancellationToken)); }
private static SyntaxToken ToToken(SyntaxNode node) { /* * CSharpSyntaxNode + [X] VariableDeclaratorSyntax (0) | + <= FieldDeclarationSyntax | + <= EventFieldDeclarationSyntax + MemberDeclarationSyntax + BaseMethodDeclarationSyntax | + [X] ConstructorDeclarationSyntax (1) | + [X] ConversionOperatorDeclarationSyntax (2) | + [X] DestructorDeclarationSyntax (3) | + [X] MethodDeclarationSyntax (4) | + [X] OperatorDeclarationSyntax (5) + BasePropertyDeclarationSyntax | + [X] EventDeclarationSyntax (6) | + [X] IndexerDeclarationSyntax (7) | + [X] PropertyDeclarationSyntax (8) + [X] BaseTypeDeclarationSyntax (9) | + [-] EnumDeclarationSyntax | + TypeDeclarationSyntax | + [-] ClassDeclarationSyntax | + [-] InterfaceDeclarationSyntax | + [-] StructDeclarationSyntax + [X] DelegateDeclarationSyntax (10) + [X] EnumMemberDeclarationSyntax (11) */ return(node switch { BaseTypeDeclarationSyntax s => s.Identifier, DelegateDeclarationSyntax s => s.Identifier, ConstructorDeclarationSyntax s => s.Identifier, DestructorDeclarationSyntax s => s.Identifier, VariableDeclaratorSyntax s => s.Identifier, PropertyDeclarationSyntax s => s.Identifier, IndexerDeclarationSyntax s => s.ThisKeyword, MethodDeclarationSyntax s => s.Identifier, OperatorDeclarationSyntax s => s.OperatorToken, ConversionOperatorDeclarationSyntax s => s.ImplicitOrExplicitKeyword, EnumMemberDeclarationSyntax s => s.Identifier, EventDeclarationSyntax s => s.Identifier, _ => default,
public override void VisitIndexerDeclaration(IndexerDeclarationSyntax node) { base.VisitIndexerDeclaration(node); }
public override void VisitIndexerDeclaration(IndexerDeclarationSyntax node) { VisitIndexerOrPropertyDeclarationSyntax(node); base.VisitIndexerDeclaration(node); }
public void VisitIndexerDeclaration(IndexerDeclarationSyntax node) { if (node == null) throw new ArgumentNullException("node"); node.Validate(); WriteLeadingTrivia(node); BasePropertyDeclarationProlog(node); _writer.WriteKeyword(PrinterKeyword.This); node.ParameterList.Accept(this); node.AccessorList.Accept(this); WriteTrailingTrivia(node); }