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)); }