public ClassDeclarationSyntax StubProperty(ClassDeclarationSyntax classDclr, IPropertySymbol propertySymbol, INamedTypeSymbol stubbedInterface, SemanticModel semanticModel)
{
string indexerType = propertySymbol.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
BasePropertyDeclarationSyntax propDclr = null;
if (propertySymbol.GetMethod != null)
{
IMethodSymbol getMethodSymbol = propertySymbol.GetMethod;
string parameters = StubbingUtils.FormatParameters(getMethodSymbol);
string delegateTypeName = NamingUtils.GetDelegateTypeName(getMethodSymbol, stubbedInterface);
var accessorDclr = SF.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, SF.Block(
SF.List(new[]
{
StubbingUtils.GetInvocationBlockSyntax(delegateTypeName, getMethodSymbol.Name, parameters,
Enumerable.Empty <IParameterSymbol>(), getMethodSymbol.ReturnType, semanticModel)
})));
propDclr = CreatePropertyDclr(getMethodSymbol, indexerType);
propDclr = propDclr.AddAccessorListAccessors(accessorDclr);
}
if (propertySymbol.SetMethod != null)
{
var voidType = semanticModel.Compilation.GetTypeByMetadataName("System.Void");
IMethodSymbol setMethodSymbol = propertySymbol.SetMethod;
string parameters = $"{StubbingUtils.FormatParameters(setMethodSymbol)}";
string delegateTypeName = NamingUtils.GetDelegateTypeName(setMethodSymbol, stubbedInterface);
var accessorDclr = SF.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration, SF.Block(
SF.List(new[]
{
StubbingUtils.GetInvocationBlockSyntax(delegateTypeName, setMethodSymbol.Name, parameters,
Enumerable.Empty <IParameterSymbol>(), voidType, semanticModel)
})));
if (propDclr == null)
{
propDclr = CreatePropertyDclr(setMethodSymbol, indexerType);
}
propDclr = propDclr.AddAccessorListAccessors(accessorDclr);
}
classDclr = classDclr.AddMembers(propDclr);
return(classDclr);
}
public ClassDeclarationSyntax StubProperty(ClassDeclarationSyntax classDclr, IPropertySymbol propertySymbol,
INamedTypeSymbol stubbedInterface)
{
string indexerType = propertySymbol.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
BasePropertyDeclarationSyntax propDclr = null;
if (propertySymbol.GetMethod != null)
{
IMethodSymbol getMethodSymbol = propertySymbol.GetMethod;
string parameters = StubbingUtils.FormatParameters(getMethodSymbol);
string delegateTypeName = NamingUtils.GetDelegateTypeName(getMethodSymbol, stubbedInterface);
var accessorDclr = SF.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, SF.Block(
SF.List(new[]
{
SF.ParseStatement("return " + StubbingUtils.GenerateInvokeDelegateStmt(delegateTypeName, getMethodSymbol.Name, parameters))
})));
propDclr = CreatePropertyDclr(getMethodSymbol, indexerType);
propDclr = propDclr.AddAccessorListAccessors(accessorDclr);
}
if (propertySymbol.SetMethod != null)
{
IMethodSymbol setMethodSymbol = propertySymbol.SetMethod;
string parameters = $"{StubbingUtils.FormatParameters(setMethodSymbol)}";
string delegateTypeName = NamingUtils.GetDelegateTypeName(setMethodSymbol, stubbedInterface);
var accessorDclr = SF.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration, SF.Block(
SF.List(new[]
{
SF.ParseStatement(StubbingUtils.GenerateInvokeDelegateStmt(delegateTypeName, setMethodSymbol.Name, parameters))
})));
if (propDclr == null)
{
propDclr = CreatePropertyDclr(setMethodSymbol, indexerType);
}
propDclr = propDclr.AddAccessorListAccessors(accessorDclr);
}
classDclr = classDclr.AddMembers(propDclr);
return(classDclr);
}
private IEnumerable <MemberDeclarationSyntax> GetPropertiesAndMethods()
{
for (var interfaceIndex = 0; interfaceIndex < _interfacesToImplement.Length; interfaceIndex++)
{
var interfaceType = _interfacesToImplement[interfaceIndex];
var typedFieldName = interfaceIndex == 0 ? (ExpressionSyntax)FieldName : ParenthesizedExpression(CastExpression(interfaceType.ToTypeSyntax(), FieldName));
var explicitInterfaceSpecifier = ExplicitInterfaceSpecifier((NameSyntax)interfaceType.ToTypeSyntax());
foreach (var propertyInfo in interfaceType.GetProperties().OrderBy(p => p.Name, StringComparer.Ordinal))
{
ParameterInfo[] indexParameters = propertyInfo.GetIndexParameters();
MethodInfo getter = propertyInfo.GetGetMethod();
MethodInfo setter = propertyInfo.GetSetMethod();
BasePropertyDeclarationSyntax propertyDeclarationSyntax = (indexParameters.Length == 0
? (BasePropertyDeclarationSyntax)PropertyDeclaration(propertyInfo.PropertyType.ToTypeSyntax(), propertyInfo.Name)
: IndexerDeclaration(propertyInfo.PropertyType.ToTypeSyntax())
.AddParameterListParameters(indexParameters.Select(p => Parameter(Identifier(p.Name)).WithType(p.ParameterType.ToTypeSyntax())).ToArray()))
.WithExplicitInterfaceSpecifier(explicitInterfaceSpecifier)
.AddAttributeLists(ExcludeFromCodeCoverageAttributeSyntax)
.WithAdditionalAnnotations(new SyntaxAnnotation(DeclaringTypeKind, (getter?.GetBaseDefinition() ?? setter?.GetBaseDefinition())?.DeclaringType.FullName));
if (getter != null)
{
propertyDeclarationSyntax = propertyDeclarationSyntax.AddAccessorListAccessors(
AccessorDeclaration(
SyntaxKind.GetAccessorDeclaration,
Block(ReturnStatement(
indexParameters.Length == 0
? (ExpressionSyntax)MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, FieldName, IdentifierName(propertyInfo.Name))
: ElementAccessExpression(FieldName).AddArgumentListArguments(indexParameters.Select(p => Argument(IdentifierName(p.Name))).ToArray())))));
}
if (setter != null)
{
ExpressionSyntax assignmentTarget = indexParameters.Length == 0
? (ExpressionSyntax)MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, typedFieldName, IdentifierName(propertyInfo.Name))
: ElementAccessExpression(FieldName).AddArgumentListArguments(indexParameters.Select(p => Argument(IdentifierName(p.Name))).ToArray());
propertyDeclarationSyntax = propertyDeclarationSyntax.AddAccessorListAccessors(
AccessorDeclaration(
SyntaxKind.SetAccessorDeclaration,
Block(ExpressionStatement(AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
assignmentTarget,
IdentifierName("value"))))));
}
yield return(propertyDeclarationSyntax);
}
IOrderedEnumerable <MethodInfo> orderedMethods = interfaceType
.GetMethods()
.Except(interfaceType.GetProperties().SelectMany(p => p.GetAccessors()))
.OrderBy(m => m.Name, StringComparer.Ordinal)
.ThenBy(m => string.Join(", ", m.GetParameters().Select(p => p.ParameterType.FullName)), StringComparer.Ordinal);
foreach (var methodInfo in orderedMethods)
{
var method = MethodDeclaration(methodInfo.ReturnType.ToTypeSyntax(), methodInfo.Name)
.WithExplicitInterfaceSpecifier(explicitInterfaceSpecifier)
.AddParameterListParameters(
methodInfo.GetParameters().Select(p =>
Parameter(Identifier(p.Name))
.WithType(p.ParameterType.ToTypeSyntax())
.WithModifiers(p.IsDefined(typeof(ParamArrayAttribute), false) ? TokenList(Token(SyntaxKind.ParamsKeyword)) : TokenList()))
.ToArray())
.AddAttributeLists(ExcludeFromCodeCoverageAttributeSyntax)
.WithBody(Block())
.WithAdditionalAnnotations(new SyntaxAnnotation(DeclaringTypeKind, methodInfo.GetBaseDefinition().DeclaringType.FullName));
if (methodInfo.IsGenericMethod)
{
method = method.WithTypeParameterList(TypeParameterList(SeparatedList(methodInfo.GetGenericArguments().Select(t => TypeParameter(t.Name)))));
}
var methodName = methodInfo.IsGenericMethod
? GenericName(methodInfo.Name).AddTypeArgumentListArguments(methodInfo.GetGenericArguments().Select(t => t.ToTypeSyntax()).ToArray())
: (SimpleNameSyntax)IdentifierName(methodInfo.Name);
var invocation = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
typedFieldName,
methodName),
ArgumentList(SeparatedList(methodInfo.GetParameters().Select(p => Argument(IdentifierName(p.Name))))));
var block = Block(methodInfo.ReturnType == typeof(void) ? ExpressionStatement(invocation) : (StatementSyntax)ReturnStatement(invocation));
method = method.WithBody(block);
yield return(method);
}
}
}
