private IEnumerable <Diagnostic> Analyze(INamedTypeSymbol marker, INamedTypeSymbol target, SemanticModel semanticModel,
BaseObjectCreationExpressionSyntax newObjSyntax)
{
// ImplicitObject has no type so instead we get the constructor, then the containing type of the constructor.
if (semanticModel.GetSymbolInfo(newObjSyntax).Symbol?.ContainingType is not INamedTypeSymbol type)
{
yield break;
}
if (!type.IsGenericType ||
type.GetAttributes()
.FirstOrDefault(a =>
SymbolEqualityComparer
.Default.Equals(a.AttributeClass, marker)) is not AttributeData genericTypeAttribute)
{
yield break;
}
if (genericTypeAttribute.ConstructorArguments.FirstOrDefault().Value is not int genericIndex)
{
yield break;
}
if (type.TypeArguments.ElementAtOrDefault(genericIndex) is not INamedTypeSymbol targetType)
{
yield break;
}
if (!targetType.GetAttributes().Any(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, target)))
{
yield return(Diagnostic.Create(Rule, newObjSyntax.GetLocation(), targetType.Name));
}
}
private static (IList <SignatureHelpItem>?items, int?selectedItem) GetDelegateTypeConstructors(
BaseObjectCreationExpressionSyntax objectCreationExpression,
SemanticModel semanticModel,
IStructuralTypeDisplayService structuralTypeDisplayService,
INamedTypeSymbol delegateType)
{
var invokeMethod = delegateType.DelegateInvokeMethod;
if (invokeMethod == null)
{
return(null, null);
}
var position = objectCreationExpression.SpanStart;
var item = CreateItem(
invokeMethod, semanticModel, position,
structuralTypeDisplayService,
isVariadic: false,
documentationFactory: null,
prefixParts: GetDelegateTypePreambleParts(invokeMethod, semanticModel, position),
separatorParts: GetSeparatorParts(),
suffixParts: GetDelegateTypePostambleParts(),
parameters: GetDelegateTypeParameters(invokeMethod, semanticModel, position));
return(SpecializedCollections.SingletonList(item), 0);
}
private bool TryGetObjectCreationExpression(
SyntaxNode root,
int position,
ISyntaxFactsService syntaxFacts,
SignatureHelpTriggerReason triggerReason,
CancellationToken cancellationToken,
out BaseObjectCreationExpressionSyntax expression
)
{
if (
!CommonSignatureHelpUtilities.TryGetSyntax(
root,
position,
syntaxFacts,
triggerReason,
IsTriggerToken,
IsArgumentListToken,
cancellationToken,
out expression
)
)
{
return(false);
}
return(expression.ArgumentList != null);
}
private static bool IsArgumentListToken(
BaseObjectCreationExpressionSyntax expression,
SyntaxToken token
)
{
return(expression.ArgumentList != null &&
expression.ArgumentList.Span.Contains(token.SpanStart) &&
token != expression.ArgumentList.CloseParenToken);
}
public sealed override IEnumerable <Diagnostic> Analyze(Compilation compilation, SemanticModel semanticModel, SyntaxNode node, CancellationToken cancel)
{
(var marker, var target) = this.GetAttributes(compilation);
return(node switch
{
InvocationExpressionSyntax invocationSyntax => this.Analyze(marker, target, semanticModel, invocationSyntax, cancel),
BaseObjectCreationExpressionSyntax newObjSyntax => this.Analyze(marker, target, semanticModel, newObjSyntax),
VariableDeclarationSyntax varDeclSyntax => this.Analyze(marker, target, semanticModel, varDeclSyntax),
ParameterSyntax paramSyntax => this.Analyze(marker, target, semanticModel, paramSyntax),
_ => Enumerable.Empty <Diagnostic>()
});
private static IEnumerable <ImmutableArray <IParameterSymbol> > GetParameterLists(
SemanticModel semanticModel,
int position,
SyntaxNode invocableNode,
CancellationToken cancellationToken)
{
return(invocableNode switch
{
InvocationExpressionSyntax invocationExpression => GetInvocationExpressionParameterLists(semanticModel, position, invocationExpression, cancellationToken),
ConstructorInitializerSyntax constructorInitializer => GetConstructorInitializerParameterLists(semanticModel, position, constructorInitializer, cancellationToken),
ElementAccessExpressionSyntax elementAccessExpression => GetElementAccessExpressionParameterLists(semanticModel, position, elementAccessExpression, cancellationToken),
BaseObjectCreationExpressionSyntax objectCreationExpression => GetObjectCreationExpressionParameterLists(semanticModel, position, objectCreationExpression, cancellationToken),
PrimaryConstructorBaseTypeSyntax recordBaseType => GetRecordBaseTypeParameterLists(semanticModel, position, recordBaseType, cancellationToken),
_ => null,
});
private IEnumerable <ImmutableArray <IParameterSymbol> > GetObjectCreationExpressionParameterLists(
SemanticModel semanticModel,
int position,
BaseObjectCreationExpressionSyntax objectCreationExpression,
CancellationToken cancellationToken)
{
var within = semanticModel.GetEnclosingNamedType(position, cancellationToken);
if (semanticModel.GetTypeInfo(objectCreationExpression, cancellationToken).Type is INamedTypeSymbol type && within != null && type.TypeKind != TypeKind.Delegate)
{
return(type.InstanceConstructors.Where(c => c.IsAccessibleWithin(within))
.Select(c => c.Parameters));
}
return(null);
}
public static void AddExistingItems(BaseObjectCreationExpressionSyntax objectCreation, ArrayBuilder <SyntaxNodeOrToken> nodesAndTokens)
{
if (objectCreation.Initializer != null)
{
nodesAndTokens.AddRange(objectCreation.Initializer.Expressions.GetWithSeparators());
}
// If we have an odd number of elements already, add a comma at the end so that we can add the rest of the
// items afterwards without a syntax issue.
if (nodesAndTokens.Count % 2 == 1)
{
var last = nodesAndTokens.Last();
nodesAndTokens.RemoveLast();
nodesAndTokens.Add(last.WithTrailingTrivia());
nodesAndTokens.Add(Token(SyntaxKind.CommaToken).WithTrailingTrivia(last.GetTrailingTrivia()));
}
}
public static BaseObjectCreationExpressionSyntax GetNewObjectCreation(
BaseObjectCreationExpressionSyntax baseObjectCreation,
SeparatedSyntaxList <ExpressionSyntax> expressions)
{
if (baseObjectCreation is ObjectCreationExpressionSyntax objectCreation &&
objectCreation.ArgumentList?.Arguments.Count == 0)
{
baseObjectCreation = objectCreation
.WithType(objectCreation.Type.WithTrailingTrivia(objectCreation.ArgumentList.GetTrailingTrivia()))
.WithArgumentList(null);
}
var firstExpression = expressions.First();
var initializerKind = firstExpression is AssignmentExpressionSyntax
? SyntaxKind.ObjectInitializerExpression
: SyntaxKind.CollectionInitializerExpression;
return(baseObjectCreation.WithInitializer(InitializerExpression(initializerKind, expressions)));
}
private static SignatureHelpItem ConvertNormalTypeConstructor(
IMethodSymbol constructor,
BaseObjectCreationExpressionSyntax objectCreationExpression,
SemanticModel semanticModel,
IStructuralTypeDisplayService structuralTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService)
{
var position = objectCreationExpression.SpanStart;
var item = CreateItem(
constructor, semanticModel, position,
structuralTypeDisplayService,
constructor.IsParams(),
constructor.GetDocumentationPartsFactory(semanticModel, position, documentationCommentFormattingService),
GetNormalTypePreambleParts(constructor, semanticModel, position),
GetSeparatorParts(),
GetNormalTypePostambleParts(),
constructor.Parameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService)).ToList());
return(item);
}
private static ImmutableArray <SignatureHelpItem> ConvertDelegateTypeConstructor(
BaseObjectCreationExpressionSyntax objectCreationExpression,
IMethodSymbol invokeMethod,
SemanticModel semanticModel,
IStructuralTypeDisplayService structuralTypeDisplayService,
int position)
{
var item = CreateItem(
invokeMethod, semanticModel,
objectCreationExpression.SpanStart,
structuralTypeDisplayService,
isVariadic: false,
documentationFactory: null,
prefixParts: GetDelegateTypePreambleParts(invokeMethod, semanticModel, position),
separatorParts: GetSeparatorParts(),
suffixParts: GetDelegateTypePostambleParts(),
parameters: GetDelegateTypeParameters(invokeMethod, semanticModel, position));
return(ImmutableArray.Create <SignatureHelpItem>(item));
}
private static (IList <SignatureHelpItem> items, int?selectedItem) GetNormalTypeConstructors(
Document document,
BaseObjectCreationExpressionSyntax objectCreationExpression,
SemanticModel semanticModel,
IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService,
INamedTypeSymbol normalType,
ISymbol within,
CancellationToken cancellationToken
)
{
var accessibleConstructors = normalType.InstanceConstructors
.WhereAsArray(c => c.IsAccessibleWithin(within))
.WhereAsArray(
s =>
s.IsEditorBrowsable(
document.ShouldHideAdvancedMembers(),
semanticModel.Compilation
)
)
.Sort(semanticModel, objectCreationExpression.SpanStart);
var symbolInfo = semanticModel.GetSymbolInfo(
objectCreationExpression,
cancellationToken
);
var selectedItem = TryGetSelectedIndex(accessibleConstructors, symbolInfo.Symbol);
var items = accessibleConstructors.SelectAsArray(
c =>
ConvertNormalTypeConstructor(
c,
objectCreationExpression,
semanticModel,
anonymousTypeDisplayService,
documentationCommentFormattingService
)
);
return(items, selectedItem);
}
ITypeSymbol GetTypeSymbol(SemanticModel semanticModel, BaseObjectCreationExpressionSyntax s) => s switch
{
private static async Task <Document> CreateObjectInitializer(Document document, SemanticModel semanticModel, BaseObjectCreationExpressionSyntax objectCreationExpression, TypeInfo typeInfo, CancellationToken cancellationToken)
{
var mutableMembers = GetMutableMembers(typeInfo, semanticModel.Compilation);
var availableSymbols = semanticModel.LookupSymbols(objectCreationExpression.SpanStart);
var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
var expressionList = CreateAssignmentExpressions(document, mutableMembers, availableSymbols);
expressionList = FormatExpressionList(expressionList, options);
var initializer = SyntaxFactory.InitializerExpression(SyntaxKind.ObjectInitializerExpression, expressionList);
SyntaxNode newNode = objectCreationExpression.WithInitializer(initializer);
var documentEditor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
documentEditor.ReplaceNode(objectCreationExpression, newNode);
return(documentEditor.GetChangedDocument());
}
private static bool HasObjectInitializer(BaseObjectCreationExpressionSyntax objectCreationExpression)
{
var childNodes = objectCreationExpression.ChildNodes();
return(childNodes.Any(n => n is InitializerExpressionSyntax));
}
