public static BaseMethodDeclarationSyntax?Generate(IHandleWrapper handle, ISet <string> excludeMembersAttributes, ISet <string> excludeAttributes, Nullability currentNullability, int level)
{
if (!(handle is MethodWrapper method))
{
return(null);
}
if (method.Attributes.TryGetNullableContext(out var nullableContext))
{
currentNullability = nullableContext;
}
var attributes = GeneratorFactory.Generate(method.Attributes, excludeMembersAttributes, excludeAttributes);
var modifiers = method.GetModifiers();
var parameters = GetParameters(method, excludeMembersAttributes, excludeAttributes, currentNullability);
var(constraints, typeParameters) = method.GetTypeParameters(excludeMembersAttributes, excludeAttributes, currentNullability);
var name = method.Name;
method.ReturnAttributes.TryGetNullable(out var returnNullability);
switch (method.MethodKind)
{
case SymbolMethodKind.Constructor:
return(ConstructorDeclaration(attributes, modifiers, parameters, method.DeclaringType.Name, level));
case SymbolMethodKind.Destructor:
return(DestructorDeclaration(attributes, modifiers, method.DeclaringType.Name, level));
case SymbolMethodKind.ExplicitInterfaceImplementation:
{
var explicitInterface = ExplicitInterfaceSpecifier(method.ExplicitType !.ReflectionFullName);
var returnType = method.ReturningType.GetTypeSyntax(method, currentNullability, returnNullability);
return(MethodDeclaration(attributes, default !, returnType, explicitInterface, name, parameters, constraints, typeParameters, level));
}
public static AttributeSyntax?Generate(IHandleWrapper member)
{
if (!(member is AttributeWrapper customAttribute))
{
return(null);
}
var arguments = new List <AttributeArgumentSyntax>(customAttribute.FixedArguments.Count + customAttribute.NamedArguments.Count);
foreach (var fixedArgument in customAttribute.FixedArguments)
{
var valueSyntax = SyntaxHelper.GetValueExpression(fixedArgument.Type, fixedArgument.Value);
if (valueSyntax == null)
{
throw new Exception("Invalid fixed arguments for attribute.");
}
arguments.Add(AttributeArgument(valueSyntax));
}
foreach (var namedArgument in customAttribute.NamedArguments)
{
var valueSyntax = SyntaxHelper.GetValueExpression(namedArgument.Type, namedArgument.Value);
if (valueSyntax == null)
{
throw new Exception("Invalid named arguments for attribute:" + namedArgument.Name);
}
arguments.Add(AttributeArgument(NameEquals(IdentifierName(namedArgument.Name)), valueSyntax));
}
return(Attribute(customAttribute.FullName, arguments));
}
public static TypeParameterSyntax?Generate(IHandleWrapper handle, ISet <string> excludeMembersAttributes, ISet <string> excludeAttributes)
{
if (!(handle is GenericParameterWrapper typeParameterWrapper))
{
return(null);
}
return(TypeParameter(GeneratorFactory.Generate(typeParameterWrapper.Attributes, excludeMembersAttributes, excludeAttributes), GetVarianceToken(typeParameterWrapper.Variance), typeParameterWrapper.Name));
}
public MutexKiller(ILogging logger)
{
_logger = logger;
_handleWrapper = new HandleWrapper();
_mutexList = new List <string>()
{
"Life is Feudal: MMO",
"lif client instance"
};
}
public static EventFieldDeclarationSyntax?Generate(IHandleWrapper member, ISet <string> excludeMembersAttributes, ISet <string> excludeAttributes, Nullability currentNullability, int level)
{
if (!(member is EventWrapper eventWrapper))
{
return(null);
}
var variables = new[] { VariableDeclarator(eventWrapper.Name) };
eventWrapper.Attributes.TryGetNullable(out var nullability);
var declaration = VariableDeclaration(eventWrapper.EventType.GetTypeSyntax(eventWrapper, currentNullability, nullability), variables);
return(EventFieldDeclaration(GeneratorFactory.Generate(eventWrapper.Attributes, excludeMembersAttributes, excludeAttributes), eventWrapper.GetModifiers(), declaration, level));
}
internal GenericContext(IHandleWrapper wrapper)
{
if (wrapper == null)
{
throw new ArgumentNullException(nameof(wrapper));
}
ClassTypeParameters = Array.Empty <GenericParameterWrapper>();
MethodTypeParameters = Array.Empty <GenericParameterWrapper>();
switch (wrapper)
{
case TypeWrapper typeWrapper:
ClassTypeParameters = typeWrapper.GenericParameters;
MethodTypeParameters = Array.Empty <GenericParameterWrapper>();
break;
case MethodWrapper methodWrapper:
var declaringTypeDefinition = methodWrapper.DeclaringType;
ClassTypeParameters = declaringTypeDefinition.GenericParameters;
MethodTypeParameters = methodWrapper.GenericParameters;
break;
case PropertyWrapper propertyWrapper:
ClassTypeParameters = propertyWrapper.DeclaringType.GenericParameters;
MethodTypeParameters = Array.Empty <GenericParameterWrapper>();
break;
case IHasGenericParameters genericParameters:
ClassTypeParameters = genericParameters.GenericParameters;
break;
default:
ClassTypeParameters = Array.Empty <GenericParameterWrapper>();
MethodTypeParameters = Array.Empty <GenericParameterWrapper>();
break;
}
if (ClassTypeParameters.Any(x => x == null))
{
throw new ArgumentNullException(nameof(wrapper));
}
}
public static FieldDeclarationSyntax?Generate(IHandleWrapper member, ISet <string> excludeMembersAttributes, ISet <string> excludeAttributes, Nullability currentNullability, int level)
{
if (!(member is FieldWrapper field))
{
return(null);
}
var modifiers = field.GetModifiers();
field.Attributes.TryGetNullable(out var nullability);
VariableDeclarationSyntax variableDeclaration;
if (field.TryGetFixed(out var bufferSize, out var fixedArrayType))
{
var arrayType = ArrayType(fixedArrayType.GetTypeSyntax(field, currentNullability, nullability), new[] { ArrayRankSpecifier(new int?[] { bufferSize }) });
var variables = new[] { VariableDeclarator(field.Name, EqualsValueClause(ArrayCreationExpression(arrayType))) };
variableDeclaration = VariableDeclaration(arrayType, variables);
}
else if (field.IsConst)
{
var valueSyntax = SyntaxHelper.GetValueExpression(field.FieldType, field.DefaultValue !);
if (valueSyntax == null)
{
throw new Exception("Could not generate a const value for field " + field.Name);
}
var variables = new[] { VariableDeclarator(field.Name, EqualsValueClause(valueSyntax)) };
variableDeclaration = VariableDeclaration(field.FieldType.GetTypeSyntax(field, currentNullability, nullability), variables);
}
else
{
variableDeclaration = VariableDeclaration(field.FieldType.GetTypeSyntax(field, currentNullability, nullability), new[] { VariableDeclarator(field.Name) });
}
return(FieldDeclaration(GeneratorFactory.Generate(field.Attributes, excludeMembersAttributes, excludeAttributes), modifiers, variableDeclaration, level));
}
