private MethodDeclarationSyntax GetGetInstanceMethod(string className)
{
var comment = GetDocCommentWithText("Get new element instance");
var md = SF.MethodDeclaration(
SF.IdentifierName(className),
SF.Identifier("GetInstance")
)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword).WithLeadingTrivia(SF.Trivia(comment)), SF.Token(SyntaxKind.StaticKeyword))
.AddParameterListParameters(
SF.Parameter(SF.Identifier("parentElement"))
.WithType(SF.IdentifierName(nameof(CombinedWebElementInfo)))
)
.WithExpressionBody(
SF.ArrowExpressionClause(
SF.ObjectCreationExpression(SF.IdentifierName(className))
.WithInitializer(
SF.InitializerExpression(
SyntaxKind.ObjectInitializerExpression
)
.AddExpressions(
SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SF.IdentifierName(nameof(WebElementInfo.Parent)), SF.IdentifierName("parentElement"))
)
)
)
)
.WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken));
return(md);
}
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))
)
));
}
protected override IEnumerable <AccessorDeclarationSyntax> GetAccessors()
{
yield return(SF.AccessorDeclaration(
SyntaxKind.GetAccessorDeclaration,
SF.List <AttributeListSyntax>(),
SF.TokenList(),
SF.ParseToken("get"),
null,
SF.ArrowExpressionClause
(
SF.ParseToken("=>"),
CreateGetPropertyInvocationExpression()
),
SF.ParseToken(";")
));
if (!Property.IsImmutable())
{
yield return(SF.AccessorDeclaration(
SyntaxKind.SetAccessorDeclaration,
SF.List <AttributeListSyntax>(),
SF.TokenList(),
SF.ParseToken("set"),
null,
SF.ArrowExpressionClause
(
SF.ParseToken("=>"),
CreateSetPropertyInvocationExpression()
),
SF.ParseToken(";")
));
}
}
private SyntaxList <MemberDeclarationSyntax> CreateVersion()
{
var list = new SyntaxList <MemberDeclarationSyntax>();
/*
* var versionField = $"private unsigned long m_version = 0";
*
* var versionAcc = $"public unsigned long Version => m_version";
*
* var versionFieldParsed = SF.ParseStatement( versionField );
*
* var versionAccParsed = SF.ParseStatement( versionAcc );
*/
var versionField = SU.Field("m_version", "ulong", SF.ParseExpression("0"), SyntaxKind.ProtectedKeyword);
var versionAcc = SF.PropertyDeclaration(SF.IdentifierName("ulong"), "Version");
versionAcc = versionAcc.WithExpressionBody(SF.ArrowExpressionClause(SF.ParseExpression("m_version")))
.WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken))
.WithModifiers(new SyntaxTokenList(SF.Token(SyntaxKind.PublicKeyword)));
list = list.Add(versionField);
list = list.Add(versionAcc);
return(list);
}
private MemberDeclarationSyntax ExplicitInterfaceMember()
{
var decoratedValueTypeSyntax = ValueTypeSyntax;
if (Symbol.ReturnsByRef)
{
decoratedValueTypeSyntax = F.RefType(decoratedValueTypeSyntax);
}
else if (Symbol.ReturnsByRefReadonly)
{
decoratedValueTypeSyntax = F.RefType(decoratedValueTypeSyntax).WithReadOnlyKeyword(F.Token(SyntaxKind.ReadOnlyKeyword));
}
var mockedProperty = F.PropertyDeclaration(decoratedValueTypeSyntax, Symbol.Name)
.WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol)));
if (Symbol.IsReadOnly)
{
ExpressionSyntax elementAccess = F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(MemberMockName),
F.IdentifierName("Value"));
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
elementAccess = TypesForSymbols.WrapByRef(elementAccess, ValueTypeSyntax);
}
mockedProperty = mockedProperty.WithExpressionBody(F.ArrowExpressionClause(elementAccess))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken));
}
else
{
if (!Symbol.IsWriteOnly)
{
mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
F.IdentifierName(MemberMockName),
F.IdentifierName("Value"))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
if (!Symbol.IsReadOnly)
{
mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithExpressionBody(
F.ArrowExpressionClause(
F.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(MemberMockName),
F.IdentifierName("Value")),
F.IdentifierName("value"))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
}
return(mockedProperty);
}
private MemberDeclarationSyntax ExplicitInterfaceMember()
{
var decoratedValueTypeSyntax = ValueTypeSyntax;
if (Symbol.ReturnsByRef)
{
decoratedValueTypeSyntax = F.RefType(decoratedValueTypeSyntax);
}
else if (Symbol.ReturnsByRefReadonly)
{
decoratedValueTypeSyntax = F.RefType(decoratedValueTypeSyntax).WithReadOnlyKeyword(F.Token(SyntaxKind.ReadOnlyKeyword));
}
var mockedIndexer = F.IndexerDeclaration(decoratedValueTypeSyntax)
.WithParameterList(KeyType.BuildParameterList())
.WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol)));
var arguments = KeyType.BuildArgumentList();
if (Symbol.IsReadOnly)
{
ExpressionSyntax elementAccess = F.ElementAccessExpression(F.IdentifierName(MemberMockName))
.WithExpressionsAsArgumentList(arguments);
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
elementAccess = TypesForSymbols.WrapByRef(elementAccess, ValueTypeSyntax);
}
mockedIndexer = mockedIndexer.WithExpressionBody(F.ArrowExpressionClause(elementAccess))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken));
}
else
{
if (!Symbol.IsWriteOnly)
{
mockedIndexer = mockedIndexer.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.ElementAccessExpression(F.IdentifierName(MemberMockName))
.WithExpressionsAsArgumentList(arguments)))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
if (!Symbol.IsReadOnly)
{
mockedIndexer = mockedIndexer.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(
F.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
F.ElementAccessExpression(F.IdentifierName(MemberMockName)).WithExpressionsAsArgumentList(arguments),
F.IdentifierName("value"))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken)));
}
}
return(mockedIndexer);
}
private MemberDeclarationSyntax ExplicitInterfaceMember()
{
var mockedIndexer = F.IndexerDeclaration(ValueWithReadonlyTypeSyntax)
.WithParameterList(F.BracketedParameterList(F.SeparatedList(Symbol.Parameters.Select(a =>
F.Parameter(F.Identifier(a.Name)).WithType(TypesForSymbols.ParseTypeName(a.Type, a.NullableOrOblivious()))))))
.WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol)));
if (Symbol.IsReadOnly)
{
ExpressionSyntax invocation = F.InvocationExpression(F.IdentifierName(MemberMockName),
F.ArgumentList(F.SeparatedList(Symbol.Parameters.Select(a => F.Argument(F.IdentifierName(a.Name))))));
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
invocation = F.RefExpression(invocation);
}
mockedIndexer = mockedIndexer
.WithExpressionBody(F.ArrowExpressionClause(invocation))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken));
}
else
{
if (!Symbol.IsWriteOnly)
{
var argumentList = F.SeparatedList(Symbol.Parameters.Select(a => F.Argument(F.IdentifierName(a.Name))));
mockedIndexer = mockedIndexer.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(F.IdentifierName(MemberMockName))
.WithArgumentList(F.ArgumentList(argumentList))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
if (!Symbol.IsReadOnly)
{
var argumentList = F.SeparatedList(Symbol.Parameters.Select(a => F.Argument(F.IdentifierName(a.Name))))
.Add(F.Argument(F.IdentifierName("value")));
mockedIndexer = mockedIndexer.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(F.IdentifierName(MemberMockName),
F.ArgumentList(argumentList))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
}
return(mockedIndexer);
}
public AccessorDeclarationSyntax Build()
{
var acc = SF.AccessorDeclaration(_kind).AddModifiers(_modifiers.Build().ToArray());;
if (_expr != null)
{
return(acc.WithExpressionBody(SF.ArrowExpressionClause(_expr.Value.Build())).WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)));
}
else if (_block != null)
{
return(acc.WithBody(_block.Value.Build()));
}
else
{
return(acc.WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)));
}
}
private MemberDeclarationSyntax ExplicitInterfaceMember()
{
var parameters = F.SeparatedList(Symbol.Parameters.Select(p => TypesForSymbols.AsParameterSyntax(p)));
if (ArglistParameterName != null)
{
parameters = parameters.Add(F.Parameter(F.Token(SyntaxKind.ArgListKeyword)));
}
var arguments = Symbol.Parameters.AsArgumentList();
if (ArglistParameterName != null && TypesForSymbols.RuntimeArgumentHandle() != null)
{
arguments = arguments.Add(F.Argument(F.LiteralExpression(SyntaxKind.ArgListExpression, F.Token(SyntaxKind.ArgListKeyword))));
}
var mockedMethod = F.MethodDeclaration(ReturnType, Symbol.Name)
.WithParameterList(F.ParameterList(parameters))
.WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol)));
if (Symbol.TypeParameters.Any())
{
mockedMethod = mockedMethod.WithTypeParameterList(TypeParameterList());
}
var invocation = Symbol.TypeParameters.Any()
? (ExpressionSyntax)F.GenericName(MemberMockName)
.WithTypeArgumentList(F.TypeArgumentList(
F.SeparatedList(Symbol.TypeParameters.Select(typeParameter =>
TypesForSymbols.ParseTypeName(typeParameter, false)))))
: F.IdentifierName(MemberMockName);
invocation = F.InvocationExpression(invocation, F.ArgumentList(arguments));
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
invocation = F.RefExpression(invocation);
}
mockedMethod = mockedMethod
.WithExpressionBody(F.ArrowExpressionClause(invocation))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken));
return(mockedMethod);
}
public ConstructorDeclarationSyntax Build()
{
var ctor = SF.ConstructorDeclaration(_name)
.AddModifiers(_modifiers.Build().ToArray())
.AddParameterListParameters(_parameters.Select(p => p.Build()).ToArray());
if (_expr != null)
{
return(ctor.WithExpressionBody(SF.ArrowExpressionClause(_expr.Value.Build())).WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)));
}
else if (_block != null)
{
return(ctor.WithBody(_block.Value.Build()));
}
else
{
return(ctor.WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)));
}
}
public MethodDeclarationSyntax Build()
{
var method = SF.MethodDeclaration(ParseType(_type), _name).AddModifiers(_modifiers.Build().ToArray()).AddParameterListParameters(_parameters.Select(p => p.Build()).ToArray());
if (_typeParameters.Count > 0)
{
method = method.WithTypeParameterList(SF.TypeParameterList(SF.SeparatedList(_typeParameters.Select(SF.TypeParameter))));
}
if (_expr != null)
{
return(method.WithExpressionBody(SF.ArrowExpressionClause(_expr.Value.Build())).WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)));
}
else if (_block != null)
{
return(method.WithBody(_block.Value.Build()));
}
else
{
return(method.WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)));
}
}
private MemberDeclarationSyntax ExplicitInterfaceMember()
{
var mockedProperty = F.PropertyDeclaration(ValueWithReadonlyTypeSyntax, Symbol.Name)
.WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol)));
if (Symbol.IsReadOnly)
{
ExpressionSyntax invocation = F.InvocationExpression(F.IdentifierName(MemberMockName));
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
invocation = F.RefExpression(invocation);
}
mockedProperty = mockedProperty
.WithExpressionBody(F.ArrowExpressionClause(invocation))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken));
}
else
{
if (!Symbol.IsWriteOnly)
{
mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(F.IdentifierName(MemberMockName))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
if (!Symbol.IsReadOnly)
{
mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(F.IdentifierName(MemberMockName),
F.ArgumentList(F.SeparatedList(new[] { F.Argument(F.IdentifierName("value")) })))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
}
return(mockedProperty);
}
protected MemberDeclarationSyntax ExplicitInterfaceMember()
{
var baseReturnType = Symbol.ReturnsVoid
? F.PredefinedType(F.Token(SyntaxKind.VoidKeyword))
: TypesForSymbols.ParseTypeName(Symbol.ReturnType, Symbol.ReturnTypeIsNullableOrOblivious());
var returnType = baseReturnType;
if (Symbol.ReturnsByRef)
{
returnType = F.RefType(returnType);
}
else if (Symbol.ReturnsByRefReadonly)
{
returnType = F.RefType(returnType).WithReadOnlyKeyword(F.Token(SyntaxKind.ReadOnlyKeyword));
}
var mockedMethod = ExplicitInterfaceMemberMethodDeclaration(returnType);
var memberMockInstance = ExplicitInterfaceMemberMemberMockInstance();
ExpressionSyntax invocation = F.InvocationExpression(
F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
memberMockInstance, F.IdentifierName("Call")))
.WithExpressionsAsArgumentList(ParametersType.BuildArgumentListWithOriginalNames());
// look at the return parameters. If we don't have any we can just make the call.
// if we only have one and that's the return value, we can just return it.
if (ReturnValuesType.Count == 0 ||
ReturnValuesType.Count == 1 && ReturnValuesType[0].IsReturnValue)
{
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
invocation = TypesForSymbols.WrapByRef(invocation, baseReturnType);
}
mockedMethod = mockedMethod.WithExpressionBody(F.ArrowExpressionClause(invocation))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken));
}
// if we only have one and that's not a return value, we can just assign it to the out or ref parameter it corresponds to.
else if (ReturnValuesType.Count == 1)
{
mockedMethod = mockedMethod.WithBody(F.Block(F.ExpressionStatement(F.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
F.IdentifierName(ReturnValuesType[0].OriginalName), invocation))));
}
else
{
// if we have more than one, put it in a temporary variable. (consider name clashes with method parameter names)
var x = new Uniquifier(Symbol.Parameters.Select(m => m.Name));
string tmp = x.GetUniqueName("tmp");
var statements = new List <StatementSyntax>
{
F.LocalDeclarationStatement(F.VariableDeclaration(F.IdentifierName("var")).WithVariables(
F.SingletonSeparatedList(F.VariableDeclarator(F.Identifier(tmp)).WithInitializer(F.EqualsValueClause(invocation)))))
};
// then for any out or ref parameters, set their values from the temporary variable.
foreach (var rv in ReturnValuesType.Where(a => !a.IsReturnValue))
{
statements.Add(F.ExpressionStatement(F.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
F.IdentifierName(rv.OriginalName),
F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(tmp),
F.IdentifierName(rv.TupleSafeName)))));
}
// finally, if there is a 'proper' return type, return the corresponding value from the temporary variable.
foreach (var rv in ReturnValuesType.Where(a => a.IsReturnValue))
{
ExpressionSyntax memberAccess = F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(tmp),
F.IdentifierName(rv.TupleSafeName));
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
memberAccess = TypesForSymbols.WrapByRef(memberAccess, baseReturnType);
}
statements.Add(F.ReturnStatement(memberAccess));
}
mockedMethod = mockedMethod.WithBody(F.Block(statements));
}
return(mockedMethod);
}
private MemberDeclarationSyntax ExplicitInterfaceMember()
{
var mockedProperty = F.EventDeclaration(EventHandlerTypeSyntax, Symbol.Name)
.WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol)));
mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.AddAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(
F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(MemberMockName),
F.IdentifierName("Add")))
.WithExpressionsAsArgumentList(F.IdentifierName("value"))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.RemoveAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(
F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
F.IdentifierName(MemberMockName), F.IdentifierName("Remove")))
.WithExpressionsAsArgumentList(F.IdentifierName("value"))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken)));
return(mockedProperty);
}
