public ClassDeclarationSyntax StubMethod(ClassDeclarationSyntax classDclr, IMethodSymbol methodSymbol, INamedTypeSymbol stubbedInterface, SemanticModel semanticModel)
{
if (!methodSymbol.IsOrdinaryMethod())
{
return(classDclr);
}
MethodDeclarationSyntax methodDclr = SF.MethodDeclaration(
SF.ParseTypeName(methodSymbol.ReturnType.GetFullyQualifiedName()), methodSymbol.GetGenericName());
methodDclr = methodDclr.WithParameterList(methodDclr.ParameterList.AddParameters(
RoslynUtils.GetMethodParameterSyntaxList(methodSymbol).ToArray()));
methodDclr = methodDclr.WithSemicolonToken(SF.Token(SyntaxKind.None))
.WithExplicitInterfaceSpecifier(
SF.ExplicitInterfaceSpecifier(
SF.IdentifierName(methodSymbol.GetContainingInterfaceGenericQualifiedName())));
string delegateTypeName = NamingUtils.GetDelegateTypeName(methodSymbol, stubbedInterface);
string parameters = StubbingUtils.FormatParameters(methodSymbol);
var outParameters = methodSymbol.Parameters.Where(p => p.RefKind == RefKind.Out);
var methodBlock = StubbingUtils.GetInvocationBlockSyntax(delegateTypeName, methodSymbol.GetGenericName(),
parameters, outParameters, methodSymbol.ReturnType, semanticModel);
classDclr = classDclr.AddMembers(methodDclr.WithBody(methodBlock));
return(classDclr);
}
public ClassDeclarationSyntax StubMethod(ClassDeclarationSyntax classDclr, IMethodSymbol methodSymbol,
INamedTypeSymbol stubbedInterface)
{
if (!methodSymbol.IsOrdinaryMethod())
{
return(classDclr);
}
MethodDeclarationSyntax methodDclr = SF.MethodDeclaration(
SF.ParseTypeName(methodSymbol.ReturnType.GetFullyQualifiedName()), methodSymbol.GetGenericName());
methodDclr = methodDclr.WithParameterList(methodDclr.ParameterList.AddParameters(
RoslynUtils.GetMethodParameterSyntaxList(methodSymbol).ToArray()));
methodDclr = methodDclr.WithSemicolonToken(SF.Token(SyntaxKind.None))
.WithExplicitInterfaceSpecifier(
SF.ExplicitInterfaceSpecifier(
SF.IdentifierName(methodSymbol.GetContainingInterfaceGenericQualifiedName())));
string delegateTypeName = NamingUtils.GetDelegateTypeName(methodSymbol, stubbedInterface);
string parameters = StubbingUtils.FormatParameters(methodSymbol);
string callDelegateStmt = StubbingUtils.GenerateInvokeDelegateStmt(delegateTypeName, methodSymbol.GetGenericName(), parameters);
if (!methodSymbol.ReturnsVoid)
{
callDelegateStmt = callDelegateStmt.Insert(0, "return ");
}
classDclr = classDclr.AddMembers(
methodDclr.WithBody(SF.Block(SF.ParseStatement(callDelegateStmt))));
return(classDclr);
}
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);
}
public ClassDeclarationSyntax StubMethod(ClassDeclarationSyntax classDclr, IMethodSymbol methodSymbol, INamedTypeSymbol stubbedInterface, SemanticModel semanticModel)
{
// only handle EventAdd and ignore EventRemove because we only need to stub the event once
if (!methodSymbol.IsEventAdd())
{
return(classDclr);
}
// add the event implementation to the stub
IEventSymbol eventSymbol = (IEventSymbol)methodSymbol.AssociatedSymbol;
EventFieldDeclarationSyntax eventDclr = ToEventDclr(eventSymbol);
classDclr = classDclr.AddMembers(eventDclr);
string eventName = eventSymbol.Name;
bool isCustomDelegateEvent = IsCustomDelegateBasedEvent(eventSymbol, semanticModel);
ParameterSyntax[] parameters = GetEventParameters(eventSymbol, isCustomDelegateEvent);
string onEventArgs;
string eventTriggerArgs;
if (isCustomDelegateEvent)
{
IMethodSymbol delegateInvokeMethodSymbol = ((INamedTypeSymbol)(eventSymbol.OriginalDefinition).Type).DelegateInvokeMethod;
onEventArgs = StubbingUtils.FormatParameters(delegateInvokeMethodSymbol);
eventTriggerArgs = onEventArgs;
}
else
{
onEventArgs = "sender";
eventTriggerArgs = "sender";
if (parameters.Count() == 2)
{
onEventArgs += ", args";
eventTriggerArgs += ", args";
}
else if (parameters.Count() == 1)
{
onEventArgs += ", null";
}
}
string eventType = GetEventType(eventSymbol);
string onEventMethodName = "On_" + eventName;
// Create OnEvent method
MethodDeclarationSyntax onEventMethodDclr = SF.MethodDeclaration(SF.ParseTypeName("void"), onEventMethodName)
.AddModifiers(SF.Token(SyntaxKind.ProtectedKeyword))
.AddParameterListParameters(parameters)
.WithBody(SF.Block(
SF.ParseStatement($"{eventType} handler = {eventName};\n"),
SF.ParseStatement($"if (handler != null) {{ handler({onEventArgs}); }}\n")
));
classDclr = classDclr.AddMembers(onEventMethodDclr);
// Create event trigger method
string eventTriggerMethodName = eventName + "_Raise";
MethodDeclarationSyntax eventTriggerMethod = SF.MethodDeclaration(SF.ParseTypeName("void"),
eventTriggerMethodName)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword))
.AddParameterListParameters(parameters)
.WithBody(SF.Block(
SF.ParseStatement($"{onEventMethodName}({eventTriggerArgs});\n")
));
classDclr = classDclr.AddMembers(eventTriggerMethod);
return(classDclr);
}
public ClassDeclarationSyntax StubMethod(ClassDeclarationSyntax classDclr, IMethodSymbol methodSymbol, INamedTypeSymbol stubbedInterface, SemanticModel semanticModel)
{
// only handle EventAdd and ignore EventRemove because we only need to stub the event once
if (!methodSymbol.IsEventAdd())
{
return(classDclr);
}
// add the event implementation to the stub
IEventSymbol eventSymbol = (IEventSymbol)methodSymbol.AssociatedSymbol;
EventFieldDeclarationSyntax eventDclr = ToEventDclr(eventSymbol);
classDclr = classDclr.AddMembers(eventDclr);
string eventName = eventSymbol.Name;
bool isCustomDelegateEvent = IsCustomDelegateBasedEvent(eventSymbol, semanticModel);
ParameterSyntax[] parameters = GetEventParameters(eventSymbol, isCustomDelegateEvent);
string onEventArgs;
string eventTriggerArgs;
string methodReturnType = "void";
string customDelegateReturnType = "";
bool hasReturnType = false;
if (isCustomDelegateEvent)
{
IMethodSymbol delegateInvokeMethodSymbol = ((INamedTypeSymbol)(eventSymbol.OriginalDefinition).Type).DelegateInvokeMethod;
onEventArgs = StubbingUtils.FormatParameters(delegateInvokeMethodSymbol);
eventTriggerArgs = onEventArgs;
if (!delegateInvokeMethodSymbol.ReturnsVoid)
{
hasReturnType = true;
customDelegateReturnType = delegateInvokeMethodSymbol.ReturnType.GetFullyQualifiedName();
methodReturnType = $"global::System.Collections.Generic.IEnumerable<{customDelegateReturnType}>";
}
}
else
{
onEventArgs = "sender";
eventTriggerArgs = "sender";
if (parameters.Count() == 2)
{
onEventArgs += ", args";
eventTriggerArgs += ", args";
}
else if (parameters.Count() == 1)
{
onEventArgs += ", null";
}
}
string eventType = GetEventType(eventSymbol);
string onEventMethodName = "On_" + eventName;
// Create OnEvent method
BlockSyntax onEventMethodDclrBlock;
if (hasReturnType)
{
onEventMethodDclrBlock = SF.Block(
SF.ParseStatement($"{eventType} handler = {eventName};\n"),
SF.ParseStatement("if (handler == null) {{ yield break; }}\n"),
SF.ParseStatement($"foreach (var listener in handler.GetInvocationList()){{ if (listener.DynamicInvoke({onEventArgs}) is {customDelegateReturnType} ret){{ yield return ret; }} }}"));
}
else
{
onEventMethodDclrBlock = SF.Block(
SF.ParseStatement($"{eventType} handler = {eventName};\n"),
SF.ParseStatement($"if (handler != null) {{ handler({onEventArgs}); }}\n"));
}
MethodDeclarationSyntax onEventMethodDclr = SF.MethodDeclaration(SF.ParseTypeName(methodReturnType), onEventMethodName)
.AddModifiers(SF.Token(SyntaxKind.ProtectedKeyword))
.AddParameterListParameters(parameters)
.WithBody(onEventMethodDclrBlock);
classDclr = classDclr.AddMembers(onEventMethodDclr);
// Create event trigger method
string eventTriggerMethodName = eventName + "_Raise";
BlockSyntax eventTriggerMethodBlock;
if (hasReturnType)
{
eventTriggerMethodBlock = SF.Block(SF.ParseStatement($"return {onEventMethodName}({eventTriggerArgs});\n"));
}
else
{
eventTriggerMethodBlock = SF.Block(SF.ParseStatement($"{onEventMethodName}({eventTriggerArgs});\n"));
}
MethodDeclarationSyntax eventTriggerMethod = SF.MethodDeclaration(SF.ParseTypeName(methodReturnType),
eventTriggerMethodName)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword))
.AddParameterListParameters(parameters)
.WithBody(eventTriggerMethodBlock);
classDclr = classDclr.AddMembers(eventTriggerMethod);
return(classDclr);
}
