public static PropertyDeclarationSyntax AddModifiers(this PropertyDeclarationSyntax cl, params SyntaxKind[] modifiers)
{
if (modifiers == null)
{
return(cl);
}
return(cl.AddModifiers(modifiers.Select(x => SyntaxFactory.Token(x)).ToArray()));
}
private static async Task <Document> AddVirtualKeywordAsync(Document document, PropertyDeclarationSyntax declaration, CancellationToken cancellationToken)
{
// Add virtual keyword
PropertyDeclarationSyntax newDeclaration = declaration.AddModifiers(SyntaxFactory.Token(SyntaxKind.VirtualKeyword));
// Tell it to be formatted
PropertyDeclarationSyntax formatted = newDeclaration.WithAdditionalAnnotations(Formatter.Annotation);
// Replace old declaration
var oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
var newRoot = oldRoot.ReplaceNode(declaration, formatted);
return(document.WithSyntaxRoot(newRoot));
}
public CSharpSyntaxNode Convert(GetSetAccessor node)
{
PropertyDeclarationSyntax csProperty = SyntaxFactory.PropertyDeclaration(node.Type.ToCsNode <TypeSyntax>(), node.Name.Text);
csProperty = csProperty.AddModifiers(node.Modifiers.ToCsNodes <SyntaxToken>());
AccessorDeclarationSyntax csGetAccess = SyntaxFactory
.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithBody(node.GetAccessor.Body.ToCsNode <BlockSyntax>());
AccessorDeclarationSyntax csSetAccess = SyntaxFactory
.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithBody(node.SetAccessor.Body.ToCsNode <BlockSyntax>());
if (node.JsDoc.Count > 0)
{
csProperty = csProperty.WithLeadingTrivia(SyntaxFactory.Trivia(node.JsDoc[0].ToCsNode <DocumentationCommentTriviaSyntax>()));
}
return(csProperty.AddAccessorListAccessors(csGetAccess, csSetAccess));
}
public static PropertyDeclarationSyntax AddModifiers(this PropertyDeclarationSyntax syntax, params SyntaxKind[] modifier)
{
return(syntax.AddModifiers(modifier.Select(Token).ToArray()));
}
private IEnumerable <MemberDeclarationSyntax> getMembers(Type type, TypeNameResolver typeNameResolver)
{
// TODO: Add static members to a manager interface. (Daniel Potter, 11/8/2017)
foreach (MemberInfo memberInfo in type.GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
if (memberInfo.GetCustomAttribute(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute)) != null)
{
continue;
}
MemberExtensionKind extensionKind;
switch (memberInfo.MemberType)
{
case MemberTypes.Constructor:
// TODO: Constructors should be added to a manager interface. (Daniel
// Potter, 11/8/2017)
break;
case MemberTypes.Event:
var eventInfo = (EventInfo)memberInfo;
extensionKind = eventInfo.GetExtensionKind();
if (extensionKind == MemberExtensionKind.Override)
{
continue;
}
EventFieldDeclarationSyntax eventDeclaration = getEvent(eventInfo, typeNameResolver);
if (extensionKind == MemberExtensionKind.New)
{
eventDeclaration = eventDeclaration
.AddModifiers(Token(SyntaxKind.NewKeyword));
}
yield return(eventDeclaration);
break;
case MemberTypes.Field:
// TODO: Constants need to be handled somehow. (Daniel Potter, 11/8/2017)
break;
case MemberTypes.Method:
var methodInfo = (MethodInfo)memberInfo;
if (methodInfo.IsSpecialName)
{
continue;
}
extensionKind = methodInfo.GetExtensionKind();
if (extensionKind == MemberExtensionKind.Override)
{
continue;
}
MethodDeclarationSyntax methodDeclaration = getMethod(methodInfo, typeNameResolver);
if (extensionKind == MemberExtensionKind.New)
{
methodDeclaration = methodDeclaration
.AddModifiers(Token(SyntaxKind.NewKeyword));
}
yield return(methodDeclaration);
break;
case MemberTypes.Property:
var propertyInfo = (PropertyInfo)memberInfo;
extensionKind = propertyInfo.GetExtensionKind();
if (extensionKind == MemberExtensionKind.Override)
{
continue;
}
if (propertyInfo.GetIndexParameters().Length > 0)
{
IndexerDeclarationSyntax indexerDeclaration = getIndexer(propertyInfo, typeNameResolver);
if (extensionKind == MemberExtensionKind.New)
{
indexerDeclaration = indexerDeclaration
.AddModifiers(Token(SyntaxKind.NewKeyword));
}
yield return(indexerDeclaration);
}
else
{
PropertyDeclarationSyntax propertyDeclaration = getProperty(propertyInfo, typeNameResolver);
if (extensionKind == MemberExtensionKind.New)
{
propertyDeclaration = propertyDeclaration
.AddModifiers(Token(SyntaxKind.NewKeyword));
}
yield return(propertyDeclaration);
}
break;
case MemberTypes.NestedType:
// TODO: Nested types need to be handled somehow. (Daniel Potter, 11/8/2017)
break;
default:
// TODO: Log these for diagnostics. (Daniel Potter, 11/8/2017)
break;
}
}
}
public static PropertyDeclarationSyntax PublicModifier(this PropertyDeclarationSyntax prop)
{
return(prop.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)));
}
public static PropertyDeclarationSyntax WithModifiers(this PropertyDeclarationSyntax node, params SyntaxKind[] modifiers)
{
return(node.AddModifiers(CreateModifiers(modifiers)));
}
