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