public static ArrowExpressionClauseSyntax GenerateSpanNameValues(MemberDeclarationMeta memberdecl) //=> { byte, byte, byte, byte}
{
SeparatedSyntaxList <ExpressionSyntax> ArrayInitExpr(MemberDeclarationMeta memberdecl)
{
SeparatedSyntaxList <ExpressionSyntax> expr = new SeparatedSyntaxList <ExpressionSyntax>();
foreach (var byteItem in Encoding.UTF8.GetBytes(memberdecl.StringFieldNameAlias))
{
expr = expr.Add(Basics.NumberLiteral(byteItem));
}
return(expr);
}
ArrayRankSpecifierSyntax ArrayRank(MemberDeclarationMeta memberdecl)
{
return(SF.ArrayRankSpecifier().AddSizes(Basics.NumberLiteral(memberdecl.StringFieldNameAlias.Length)));
}
return(SF.ArrowExpressionClause(
SF.ArrayCreationExpression(
SF.ArrayType(
SF.PredefinedType(SF.Token(SyntaxKind.ByteKeyword)),
SF.SingletonList <ArrayRankSpecifierSyntax>(ArrayRank(memberdecl))),
SF.InitializerExpression(SyntaxKind.ArrayInitializerExpression, ArrayInitExpr(memberdecl))
)
));
}
static Dictionary <string, VariableDeclarationSyntax> SplitVariableDeclarations(VBSyntax.VariableDeclaratorSyntax declarator, VBasic.VisualBasicSyntaxVisitor <CSharpSyntaxNode> nodesVisitor, SemanticModel semanticModel)
{
var rawType = (TypeSyntax)declarator.AsClause?.TypeSwitch(
(VBSyntax.SimpleAsClauseSyntax c) => c.Type,
(VBSyntax.AsNewClauseSyntax c) => VBasic.SyntaxExtensions.Type(c.NewExpression),
_ => { throw new NotImplementedException($"{_.GetType().FullName} not implemented!"); }
)?.Accept(nodesVisitor) ?? SyntaxFactory.ParseTypeName("var");
var initializer = (ExpressionSyntax)declarator.AsClause?.TypeSwitch(
(VBSyntax.SimpleAsClauseSyntax _) => declarator.Initializer?.Value,
(VBSyntax.AsNewClauseSyntax c) => c.NewExpression
)?.Accept(nodesVisitor) ?? (ExpressionSyntax)declarator.Initializer?.Value.Accept(nodesVisitor);
var newDecls = new Dictionary <string, VariableDeclarationSyntax>();
foreach (var name in declarator.Names)
{
var type = rawType;
if (!SyntaxTokenExtensions.IsKind(name.Nullable, VBasic.SyntaxKind.None))
{
if (type is ArrayTypeSyntax)
{
type = ((ArrayTypeSyntax)type).WithElementType(
SyntaxFactory.NullableType(((ArrayTypeSyntax)type).ElementType));
initializer = null;
}
else
{
type = SyntaxFactory.NullableType(type);
}
}
var rankSpecifiers = NodesVisitor.ConvertArrayRankSpecifierSyntaxes(name.ArrayRankSpecifiers, name.ArrayBounds, nodesVisitor, semanticModel, false);
if (rankSpecifiers.Count > 0)
{
var rankSpecifiersWithSizes = NodesVisitor.ConvertArrayRankSpecifierSyntaxes(name.ArrayRankSpecifiers, name.ArrayBounds, nodesVisitor, semanticModel);
if (!rankSpecifiersWithSizes.SelectMany(ars => ars.Sizes).OfType <OmittedArraySizeExpressionSyntax>().Any())
{
initializer =
SyntaxFactory.ArrayCreationExpression(
SyntaxFactory.ArrayType(type, rankSpecifiersWithSizes));
}
type = SyntaxFactory.ArrayType(type, rankSpecifiers);
}
VariableDeclarationSyntax decl;
var v = SyntaxFactory.VariableDeclarator(ConvertIdentifier(name.Identifier, semanticModel), null, initializer == null ? null : SyntaxFactory.EqualsValueClause(initializer));
string k = type.ToString();
if (newDecls.TryGetValue(k, out decl))
{
newDecls[k] = decl.AddVariables(v);
}
else
{
newDecls[k] = SyntaxFactory.VariableDeclaration(type, SyntaxFactory.SingletonSeparatedList(v));
}
}
return(newDecls);
}
public ClassDeclarationSyntax GenerateHelper()
{
if (!HasImports)
{
return(null);
}
var xAttributeList = SyntaxFactory.FieldDeclaration(
SyntaxFactory.List <AttributeListSyntax>(),
SyntaxFactory.TokenList(SyntaxFactory.Token(CSSyntaxKind.PrivateKeyword), SyntaxFactory.Token(CSSyntaxKind.StaticKeyword)),
CommonConversions.CreateVariableDeclarationAndAssignment(
"namespaceAttributes", SyntaxFactory.InitializerExpression(
CSSyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
from x in _xNamespaceFields
let fieldIdentifierName = SyntaxFactory.IdentifierName(x.Declaration.Variables.Single().Identifier)
let namespaceNameExpression = SyntaxFactory.MemberAccessExpression(CSSyntaxKind.SimpleMemberAccessExpression, fieldIdentifierName, SyntaxFactory.IdentifierName("NamespaceName"))
let attributeNameExpression = fieldIdentifierName.IsEquivalentTo(DefaultIdentifierName) ? CommonConversions.Literal("xmlns") : BuildXmlnsAttributeName(fieldIdentifierName)
let arguments = SyntaxFactory.Argument(attributeNameExpression).Yield().Concat(SyntaxFactory.Argument(namespaceNameExpression))
select SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName("XAttribute")).WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(arguments))))),
SyntaxFactory.ArrayType(SyntaxFactory.IdentifierName("XAttribute"), SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression()))))));
var boilerplate = SyntaxFactory.ParseStatement(@"
TContainer Apply<TContainer>(TContainer x) where TContainer : XContainer
{
foreach (var d in x.Descendants()) {
foreach (var n in namespaceAttributes) {
var a = d.Attribute(n.Name);
if (a != null && a.Value == n.Value) {
a.Remove();
}
}
}
x.Add(namespaceAttributes);
return x;
}") as LocalFunctionStatementSyntax;
var applyMethod = SyntaxFactory.MethodDeclaration(
SyntaxFactory.List <AttributeListSyntax>(),
SyntaxFactory.TokenList(SyntaxFactory.Token(CSSyntaxKind.InternalKeyword), SyntaxFactory.Token(CSSyntaxKind.StaticKeyword)),
boilerplate.ReturnType,
null,
boilerplate.Identifier,
boilerplate.TypeParameterList,
boilerplate.ParameterList,
boilerplate.ConstraintClauses,
boilerplate.Body,
boilerplate.ExpressionBody);
return(SyntaxFactory.ClassDeclaration(
SyntaxFactory.List <AttributeListSyntax>(),
SyntaxFactory.TokenList(SyntaxFactory.Token(CSSyntaxKind.InternalKeyword), SyntaxFactory.Token(CSSyntaxKind.StaticKeyword)),
HelperClassUniqueIdentifierName.Identifier,
null, null,
SyntaxFactory.List <TypeParameterConstraintClauseSyntax>(),
SyntaxFactory.List(_xNamespaceFields.Concat <MemberDeclarationSyntax>(xAttributeList).Concat(applyMethod))
));
}
private PropertyDeclarationSyntax CreateArray(SymbolData symbol)
{
var type = SF.ArrayType(
SF.ParseTypeName(SymbolTypeConverter.Convert(symbol)),
SF.List(new ArrayRankSpecifierSyntax[]
{
SF.ArrayRankSpecifier(),
}));
return(CreatePropertyImpl(type, symbol));
}
private ExpressionStatementSyntax CreateNewArrayAssignment(VBSyntax.ExpressionSyntax vbArrayExpression,
ExpressionSyntax csArrayExpression, List <ExpressionSyntax> convertedBounds,
int nodeSpanStart)
{
var arrayRankSpecifierSyntax = SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SeparatedList(convertedBounds));
var convertedType = (IArrayTypeSymbol)_semanticModel.GetTypeInfo(vbArrayExpression).ConvertedType;
var typeSyntax = GetTypeSyntaxFromTypeSymbol(convertedType.ElementType, nodeSpanStart);
var arrayCreation =
SyntaxFactory.ArrayCreationExpression(SyntaxFactory.ArrayType(typeSyntax,
SyntaxFactory.SingletonList(arrayRankSpecifierSyntax)));
var assignmentExpressionSyntax =
SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, csArrayExpression, arrayCreation);
var newArrayAssignment = SyntaxFactory.ExpressionStatement(assignmentExpressionSyntax);
return(newArrayAssignment);
}
ArgumentListSyntax GetArgumentListSyntax()
{
var arguments = GetArgumentExpressions().Select(e => SF.Argument(e));
return(SF.ArgumentList(SF.SeparatedList(arguments)));
IEnumerable <ExpressionSyntax> GetArgumentExpressions()
{
if (Method.IsStatic)
{
yield return(SF.TypeOfExpression(Symbols.GetNameSyntax(Type)));
}
yield return(CreateArgumentsArray());
}
ArrayCreationExpressionSyntax CreateArgumentsArray()
{
return(SF.ArrayCreationExpression(
SF.Token(SyntaxKind.NewKeyword),
SF.ArrayType(SF.ParseTypeName("object[]")),
SF.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SF.Token(SyntaxKind.OpenBraceToken),
SF.SeparatedList(GetArguments()),
SF.Token(SyntaxKind.CloseBraceToken)
)
));
IEnumerable <ExpressionSyntax> GetArguments()
{
if (Method.Parameters == null)
{
yield break;
}
foreach (Parameter parameter in Method.Parameters)
{
yield return(Symbols.GetNameSyntax(parameter));
}
}
}
}
private (TypeSyntax, ExpressionSyntax) AdjustFromName(TypeSyntax rawType,
ModifiedIdentifierSyntax name, ExpressionSyntax initializer)
{
var type = rawType;
if (!SyntaxTokenExtensions.IsKind(name.Nullable, SyntaxKind.None))
{
if (type is ArrayTypeSyntax)
{
type = ((ArrayTypeSyntax)type).WithElementType(
SyntaxFactory.NullableType(((ArrayTypeSyntax)type).ElementType));
initializer = null;
}
else
{
type = SyntaxFactory.NullableType(type);
}
}
var rankSpecifiers = ConvertArrayRankSpecifierSyntaxes(name.ArrayRankSpecifiers, name.ArrayBounds, false);
if (rankSpecifiers.Count > 0)
{
var rankSpecifiersWithSizes = ConvertArrayRankSpecifierSyntaxes(name.ArrayRankSpecifiers,
name.ArrayBounds);
if (!rankSpecifiersWithSizes.SelectMany(ars => ars.Sizes).OfType <OmittedArraySizeExpressionSyntax>().Any())
{
initializer =
SyntaxFactory.ArrayCreationExpression(
SyntaxFactory.ArrayType(type, rankSpecifiersWithSizes));
}
type = SyntaxFactory.ArrayType(type, rankSpecifiers);
}
return(type, initializer);
}
private static ArrayTypeSyntax CharArrayType()
{
return(SyntaxFactory.ArrayType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.CharKeyword))));
}
/// <summary>
/// Create a class that implements <see cref="ICommand"/>.
///
/// The implementation will execute the given <see cref="method"/>.
/// </summary>
/// <param name="id">The unique identifier of the command for <see cref="ICommand.Id"/>.</param>
/// <param name="className">The new class name.</param>
/// <param name="moduleType">The type that contains the <see cref="method"/>.</param>
/// <param name="method">The method that should be executed when <see cref="ICommand.ExecuteAsync"/> is called.</param>
/// <returns>The <see cref="ClassDeclarationSyntax"/>.</returns>
private ClassDeclarationSyntax CreateCommandClass(
string id,
IReadOnlyList <string> aliases,
string className,
Type moduleType,
MethodInfo method)
{
var permission = ModuleUtils.GetPermissionName(moduleType, method);
var moduleName = ModuleUtils.GetModuleName(moduleType);
var attr = method.GetCustomAttribute <CommandAttribute>();
var guildOnly = attr.GuildOnly;
var permissionGroup = attr.PermissionGroup.ToString();
return(S.ClassDeclaration(className)
.AddBaseListTypes(S.SimpleBaseType(CommandType))
.AddMembers(
// ICommand.Id
S.PropertyDeclaration(StringType, nameof(ICommand.Id))
.AddAccessorListAccessors(
S.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.AddBodyStatements(S.ReturnStatement(S.LiteralExpression(SyntaxKind.StringLiteralExpression, S.Literal(id))))
.WithSemicolonToken(S.Token(SyntaxKind.SemicolonToken))
)
.AddModifiers(S.Token(SyntaxKind.PublicKeyword)),
// ICommand.Aliases
S.PropertyDeclaration(ReadOnlyStringList, nameof(ICommand.Aliases))
.AddAccessorListAccessors(
S.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.AddBodyStatements(S.ReturnStatement(S.ArrayCreationExpression(
S.ArrayType(StringType)
.WithRankSpecifiers(S.SingletonList(S.ArrayRankSpecifier(S.SingletonSeparatedList <ExpressionSyntax>(S.OmittedArraySizeExpression())))),
S.InitializerExpression(SyntaxKind.ArrayInitializerExpression,
new SeparatedSyntaxList <ExpressionSyntax>()
.AddRange(aliases.Select(s => S.LiteralExpression(SyntaxKind.StringLiteralExpression, S.Literal(s))))))))
.WithSemicolonToken(S.Token(SyntaxKind.SemicolonToken))
)
.AddModifiers(S.Token(SyntaxKind.PublicKeyword)),
// ICommand.Module
S.PropertyDeclaration(StringType, nameof(ICommand.Module))
.AddAccessorListAccessors(
S.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.AddBodyStatements(S.ReturnStatement(S.LiteralExpression(SyntaxKind.StringLiteralExpression, S.Literal(moduleName))))
.WithSemicolonToken(S.Token(SyntaxKind.SemicolonToken))
)
.AddModifiers(S.Token(SyntaxKind.PublicKeyword)),
// ICommand.Permission
S.PropertyDeclaration(StringType, nameof(ICommand.Permission))
.AddAccessorListAccessors(
S.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.AddBodyStatements(S.ReturnStatement(S.LiteralExpression(SyntaxKind.StringLiteralExpression, S.Literal(permission))))
.WithSemicolonToken(S.Token(SyntaxKind.SemicolonToken))
)
.AddModifiers(S.Token(SyntaxKind.PublicKeyword)),
// ICommand.PermissionGroup
S.PropertyDeclaration(S.ParseName(nameof(PermissionGroup)), nameof(ICommand.PermissionGroup))
.AddAccessorListAccessors(
S.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.AddBodyStatements(S.ReturnStatement(S.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, S.IdentifierName(nameof(PermissionGroup)), S.IdentifierName(permissionGroup))))
.WithSemicolonToken(S.Token(SyntaxKind.SemicolonToken))
)
.AddModifiers(S.Token(SyntaxKind.PublicKeyword)),
// ICommand.GuildOnly
S.PropertyDeclaration(BoolType, nameof(ICommand.GuildOnly))
.AddAccessorListAccessors(
S.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.AddBodyStatements(S.ReturnStatement(S.LiteralExpression(guildOnly ? SyntaxKind.TrueLiteralExpression : SyntaxKind.FalseLiteralExpression)))
.WithSemicolonToken(S.Token(SyntaxKind.SemicolonToken))
)
.AddModifiers(S.Token(SyntaxKind.PublicKeyword)),
// ICommand.ExecuteAsync
S.MethodDeclaration(TaskType, nameof(ICommand.ExecuteAsync))
.AddModifiers(S.Token(SyntaxKind.PublicKeyword), S.Token(SyntaxKind.AsyncKeyword))
.AddParameterListParameters(Parameter(ArgumentContext, MessageContextType))
.AddBodyStatements(
S.ExpressionStatement(InvokeCommand(moduleType, method))
)
));
}
IEnumerable <MemberDeclarationSyntax> CreateConstructors()
{
SyntaxToken typeName = Symbols.GetNameSyntaxToken(Type);
if (Type.Initializer != null)
{
yield return(SF.ConstructorDeclaration
(
SF.List <AttributeListSyntax>(),
SF.TokenList(SF.Token(
Type.IsAbstract || Type.Initializer.IsProtected
? SyntaxKind.ProtectedKeyword
: SyntaxKind.PublicKeyword
)),
typeName,
Type.Initializer.GetParameterListSyntax(Namespaces, Symbols),
SF.ConstructorInitializer
(
SyntaxKind.BaseConstructorInitializer,
SF.ArgumentList(
SF.SeparatedList(new[]
{
SF.Argument(
SF.ObjectCreationExpression(
SF.Token(SyntaxKind.NewKeyword),
SF.ParseTypeName("DeputyProps"),
SF.ArgumentList(SF.SeparatedList(
new[] { GetBaseArgument() }
)),
null
)
)
})
)
),
SF.Block(),
null
));
}
yield return(SF.ConstructorDeclaration
(
SF.List <AttributeListSyntax>(),
SF.TokenList(SF.Token(SyntaxKind.ProtectedKeyword)),
typeName,
SF.ParseParameterList("(ByRefValue reference)"),
SF.ConstructorInitializer
(
SyntaxKind.BaseConstructorInitializer,
SF.ParseArgumentList("(reference)")
),
SF.Block(),
null
));
// This constructor allows child classes to supply their own parameter lists. It is always protected.
yield return(SF.ConstructorDeclaration
(
SF.List <AttributeListSyntax>(),
SF.TokenList(SF.Token(SyntaxKind.ProtectedKeyword)),
typeName,
SF.ParseParameterList("(DeputyProps props)"),
SF.ConstructorInitializer
(
SyntaxKind.BaseConstructorInitializer,
SF.ParseArgumentList("(props)")
),
SF.Block(),
null
));
ArgumentSyntax GetBaseArgument()
{
var deputyArguments = (Type.Initializer.Parameters ?? Enumerable.Empty <Parameter>())
.Select(p => Symbols.GetNameSyntaxToken(p))
.Select(i => SF.IdentifierName(i));
// In C#, arrays of reference types are covariant. Because of this, passing a string[]
// to a method that takes `params object[] args` will interperet the string array *as*
// args, rather than as args' first element. To workaround with, we remove the params
// keyword from DeputyBase's constructor, and always explicitly create an array of
// objects when calling it.
return(SF.Argument(
SF.ArrayCreationExpression(
SF.Token(SyntaxKind.NewKeyword),
SF.ArrayType(SF.ParseTypeName("object[]")),
SF.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SF.SeparatedList <ExpressionSyntax>(deputyArguments)
)
)
));
}
}
public PropertyDeclarationSyntax GenerateArrayProperty(string propertyName, string typeName)
{
return(SF.PropertyDeclaration(SF.ArrayType(SF.IdentifierName(typeName)), SF.Identifier(propertyName)));
}
public PropertyDeclarationSyntax GenerateArrayProperty(string propertyName, PrimitiveType type)
{
return(SF.PropertyDeclaration(SF.ArrayType(SF.PredefinedType(SF.Token(FromPrimitive(type)))), SF.Identifier(propertyName)));
}
