internal static SyntaxNode GenerateNamespaceDeclaration(
ICodeGenerationService service,
INamespaceSymbol @namespace,
CodeGenerationOptions options,
CancellationToken cancellationToken
)
{
options ??= CodeGenerationOptions.Default;
GetNameAndInnermostNamespace(
@namespace,
options,
out var name,
out var innermostNamespace
);
var declaration = GetDeclarationSyntaxWithoutMembers(
@namespace,
innermostNamespace,
name,
options
);
declaration = options.GenerateMembers
? service.AddMembers(
declaration,
innermostNamespace.GetMembers(),
options,
cancellationToken
)
: declaration;
return(AddFormatterAndCodeGeneratorAnnotationsTo(declaration));
}
public static MemberDeclarationSyntax GenerateNamedTypeDeclaration(
ICodeGenerationService service,
INamedTypeSymbol namedType,
CodeGenerationDestination destination,
CodeGenerationOptions options,
CancellationToken cancellationToken)
{
options ??= CodeGenerationOptions.Default;
var declaration = GetDeclarationSyntaxWithoutMembers(namedType, destination, options);
if (namedType.IsComImport)
{
// If we're generating a ComImport type, then do not attempt to do any
// reordering of members.
options = options.With(autoInsertionLocation: false, sortMembers: false);
}
// If we are generating members then make sure to exclude properties that cannot be generated.
// Reason: Calling AddProperty on a propertysymbol that can't be generated (like one with params) causes
// the getter and setter to get generated instead. Since the list of members is going to include
// the method symbols for the getter and setter, we don't want to generate them twice.
declaration = options.GenerateMembers && namedType.TypeKind != TypeKind.Delegate
? service.AddMembers(declaration,
GetMembers(namedType).Where(s => s.Kind != SymbolKind.Property || PropertyGenerator.CanBeGenerated((IPropertySymbol)s)),
options,
cancellationToken)
: declaration;
return(AddFormatterAndCodeGeneratorAnnotationsTo(ConditionallyAddDocumentationCommentTo(declaration, namedType, options, cancellationToken)));
}
public static MemberDeclarationSyntax GenerateNamedTypeDeclaration(
ICodeGenerationService service,
INamedTypeSymbol namedType,
CodeGenerationDestination destination,
CodeGenerationOptions options,
CancellationToken cancellationToken)
{
options = options ?? CodeGenerationOptions.Default;
var declaration = GetDeclarationSyntaxWithoutMembers(namedType, destination, options);
if (namedType.IsComImport)
{
// If we're generating a ComImport type, then do not attempt to do any
// reordering of members.
options = options.With(autoInsertionLocation: false, sortMembers: false);
}
// If we are generating members then make sure to exclude properties that cannot be generated.
// Reason: Calling AddProperty on a propertysymbol that can't be generated (like one with params) causes
// the getter and setter to get generated instead. Since the list of members is going to include
// the method symbols for the getter and setter, we don't want to generate them twice.
declaration = options.GenerateMembers && namedType.TypeKind != TypeKind.Delegate
? service.AddMembers(declaration,
GetMembers(namedType).Where(s => s.Kind != SymbolKind.Property || PropertyGenerator.CanBeGenerated((IPropertySymbol)s)),
options,
cancellationToken)
: declaration;
return AddCleanupAnnotationsTo(ConditionallyAddDocumentationCommentTo(declaration, namedType, options));
}
public static MemberDeclarationSyntax UpdateNamedTypeDeclaration(
ICodeGenerationService service,
MemberDeclarationSyntax declaration,
IList <ISymbol> newMembers,
CodeGenerationOptions options,
CancellationToken cancellationToken)
{
declaration = RemoveAllMembers(declaration);
declaration = service.AddMembers(declaration, newMembers, options, cancellationToken);
return(AddFormatterAndCodeGeneratorAnnotationsTo(declaration));
}
public static SyntaxNode UpdateCompilationUnitOrNamespaceDeclaration(
ICodeGenerationService service,
SyntaxNode declaration,
IList<ISymbol> newMembers,
CodeGenerationOptions options,
CancellationToken cancellationToken)
{
declaration = RemoveAllMembers(declaration);
declaration = service.AddMembers(declaration, newMembers, options, cancellationToken);
return AddCleanupAnnotationsTo(declaration);
}
public static SyntaxNode UpdateCompilationUnitOrNamespaceDeclaration(
ICodeGenerationService service,
SyntaxNode declaration,
IList <ISymbol> newMembers,
CodeGenerationOptions options,
CancellationToken cancellationToken)
{
declaration = RemoveAllMembers(declaration);
declaration = service.AddMembers(declaration, newMembers, options, cancellationToken);
return(AddCleanupAnnotationsTo(declaration));
}
public static SyntaxNode UpdateCompilationUnitOrNamespaceDeclaration(
ICodeGenerationService service,
SyntaxNode declaration,
IList <ISymbol> newMembers,
CSharpCodeGenerationContextInfo info,
CancellationToken cancellationToken)
{
declaration = RemoveAllMembers(declaration);
declaration = service.AddMembers(declaration, newMembers, info, cancellationToken);
return(AddFormatterAndCodeGeneratorAnnotationsTo(declaration));
}
public static MemberDeclarationSyntax UpdateNamedTypeDeclaration(
ICodeGenerationService service,
MemberDeclarationSyntax declaration,
IList<ISymbol> newMembers,
CodeGenerationOptions options,
CancellationToken cancellationToken)
{
declaration = RemoveAllMembers(declaration);
declaration = service.AddMembers(declaration, newMembers, options, cancellationToken);
return AddCleanupAnnotationsTo(declaration);
}
internal static SyntaxNode GenerateNamespaceDeclaration(
ICodeGenerationService service,
INamespaceSymbol @namespace,
CodeGenerationOptions options,
CancellationToken cancellationToken)
{
options = options ?? CodeGenerationOptions.Default;
GetNameAndInnermostNamespace(@namespace, options, out var name, out var innermostNamespace);
var declaration = GetDeclarationSyntaxWithoutMembers(@namespace, innermostNamespace, name, options);
declaration = options.GenerateMembers
? service.AddMembers(declaration, innermostNamespace.GetMembers(), options, cancellationToken)
: declaration;
return AddCleanupAnnotationsTo(declaration);
}
internal static SyntaxNode GenerateNamespaceDeclaration(
ICodeGenerationService service,
INamespaceSymbol @namespace,
CodeGenerationDestination destination,
CSharpCodeGenerationContextInfo info,
CancellationToken cancellationToken)
{
GetNameAndInnermostNamespace(@namespace, info, out var name, out var innermostNamespace);
var declaration = GetDeclarationSyntaxWithoutMembers(
@namespace, innermostNamespace, name, destination, info);
declaration = info.Context.GenerateMembers
? service.AddMembers(declaration, innermostNamespace.GetMembers(), info, cancellationToken)
: declaration;
return(AddFormatterAndCodeGeneratorAnnotationsTo(declaration));
}
private static RecordDeclarationSyntax GenerateRecordMembers(
ICodeGenerationService service,
CodeGenerationOptions options,
RecordDeclarationSyntax recordDeclaration,
ImmutableArray <ISymbol> members,
CancellationToken cancellationToken)
{
// For a record, add record parameters if we have a primary constructor.
var primaryConstructor = members.OfType <IMethodSymbol>().FirstOrDefault(m => CodeGenerationConstructorInfo.GetIsPrimaryConstructor(m));
if (primaryConstructor != null)
{
var parameterList = ParameterGenerator.GenerateParameterList(primaryConstructor.Parameters, isExplicit: false, options);
recordDeclaration = recordDeclaration.WithParameterList(parameterList);
// remove the primary constructor from the list of members to generate.
members = members.Remove(primaryConstructor);
// remove any properties that were created by the primary constructor
members = members.WhereAsArray(m => m is not IPropertySymbol property || !primaryConstructor.Parameters.Any(p => p.Name == property.Name));
}
// remove any implicit overrides to generate.
members = members.WhereAsArray(m => !m.IsImplicitlyDeclared);
// If there are no members, just make a simple record with no body
if (members.Length == 0)
{
recordDeclaration = recordDeclaration.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
}
else
{
// Otherwise, give the record a body.
recordDeclaration = recordDeclaration.WithOpenBraceToken(SyntaxFactory.Token(SyntaxKind.OpenBraceToken))
.WithCloseBraceToken(SyntaxFactory.Token(SyntaxKind.CloseBraceToken));
}
if (options.GenerateMembers)
{
recordDeclaration = service.AddMembers(recordDeclaration, members, options, cancellationToken);
}
return(recordDeclaration);
}
internal static SyntaxNode GenerateNamespaceDeclaration(
ICodeGenerationService service,
INamespaceSymbol @namespace,
CodeGenerationOptions options)
{
options = options ?? CodeGenerationOptions.Default;
string name;
INamespaceSymbol innermostNamespace;
GetNameAndInnermostNamespace(@namespace, options, out name, out innermostNamespace);
var declaration = GetDeclarationSyntaxWithoutMembers(@namespace, innermostNamespace, name, options);
declaration = options.GenerateMembers
? service.AddMembers(declaration, innermostNamespace.GetMembers(), options)
: declaration;
return(AddCleanupAnnotationsTo(declaration));
}
public static MemberDeclarationSyntax GenerateNamedTypeDeclaration(
ICodeGenerationService service,
INamedTypeSymbol namedType,
CodeGenerationDestination destination,
CodeGenerationOptions options)
{
options = options ?? CodeGenerationOptions.Default;
var declaration = GetDeclarationSyntaxWithoutMembers(namedType, destination, options);
// If we are generating members then make sure to exclude properties that cannot be generated.
// Reason: Calling AddProperty on a propertysymbol that can't be generated (like one with params) causes
// the getter and setter to get generated instead. Since the list of members is going to include
// the method symbols for the getter and setter, we don't want to generate them twice.
declaration = options.GenerateMembers && namedType.TypeKind != TypeKind.Delegate
? service.AddMembers(declaration,
GetMembers(namedType).Where(s => s.Kind != SymbolKind.Property || PropertyGenerator.CanBeGenerated((IPropertySymbol)s)),
options)
: declaration;
return(AddCleanupAnnotationsTo(ConditionallyAddDocumentationCommentTo(declaration, namedType, options)));
}
public static MemberDeclarationSyntax GenerateNamedTypeDeclaration(
ICodeGenerationService service,
INamedTypeSymbol namedType,
CodeGenerationDestination destination,
CSharpCodeGenerationContextInfo info,
CancellationToken cancellationToken)
{
var declaration = GetDeclarationSyntaxWithoutMembers(namedType, destination, info);
// If we are generating members then make sure to exclude properties that cannot be generated.
// Reason: Calling AddProperty on a propertysymbol that can't be generated (like one with params) causes
// the getter and setter to get generated instead. Since the list of members is going to include
// the method symbols for the getter and setter, we don't want to generate them twice.
var members = GetMembers(namedType).Where(s => s.Kind != SymbolKind.Property || PropertyGenerator.CanBeGenerated((IPropertySymbol)s))
.ToImmutableArray();
if (namedType.IsRecord)
{
declaration = GenerateRecordMembers(service, info, (RecordDeclarationSyntax)declaration, members, cancellationToken);
}
else
{
// If we're generating a ComImport type, then do not attempt to do any
// reordering of members.
if (namedType.IsComImport)
{
info = info.WithContext(info.Context.With(autoInsertionLocation: false, sortMembers: false));
}
if (info.Context.GenerateMembers && namedType.TypeKind != TypeKind.Delegate)
{
declaration = service.AddMembers(declaration, members, info, cancellationToken);
}
}
return(AddFormatterAndCodeGeneratorAnnotationsTo(ConditionallyAddDocumentationCommentTo(declaration, namedType, info, cancellationToken)));
}