/// <summary> /// Creates a default declaration for an operator equality overload. /// </summary> /// <param name="generator"> /// The <see cref="SyntaxGenerator"/> used to create the declaration. /// </param> /// <param name="containingType"> /// A symbol specifying the type of the operands of the comparison operator. /// </param> /// <returns> /// A <see cref="SyntaxNode"/> representing the declaration. /// </returns> public static SyntaxNode DefaultOperatorEqualityDeclaration(this SyntaxGenerator generator, INamedTypeSymbol containingType) { var leftArgument = generator.IdentifierName(LeftIdentifierName); var rightArgument = generator.IdentifierName(RightIdentifierName); List<SyntaxNode> statements = new List<SyntaxNode>(); if (containingType.TypeKind == TypeKind.Class) { statements.Add( generator.IfStatement( generator.InvocationExpression( generator.IdentifierName(ReferenceEqualsMethodName), leftArgument, generator.NullLiteralExpression()), new[] { generator.ReturnStatement( generator.InvocationExpression( generator.IdentifierName(ReferenceEqualsMethodName), rightArgument, generator.NullLiteralExpression())) })); } statements.Add( generator.ReturnStatement( generator.InvocationExpression( generator.MemberAccessExpression( leftArgument, EqualsMethodName), rightArgument))); return generator.ComparisonOperatorDeclaration(OperatorKind.Equality, containingType, statements.ToArray()); }
/// <summary> /// Creates a default declaration for an operator inequality overload. /// </summary> /// <param name="generator"> /// The <see cref="SyntaxGenerator"/> used to create the declaration. /// </param> /// <param name="containingType"> /// A symbol specifying the type of the operands of the comparison operator. /// </param> /// <returns> /// A <see cref="SyntaxNode"/> representing the declaration. /// </returns> public static SyntaxNode DefaultOperatorInequalityDeclaration(this SyntaxGenerator generator, INamedTypeSymbol containingType) { var leftArgument = generator.IdentifierName(LeftIdentifierName); var rightArgument = generator.IdentifierName(RightIdentifierName); var returnStatement = generator.ReturnStatement( generator.LogicalNotExpression( generator.ValueEqualsExpression( leftArgument, rightArgument))); return generator.ComparisonOperatorDeclaration(OperatorKind.Inequality, containingType, returnStatement); }
/// <summary> /// Creates a default declaration for an operator greater than or equal overload. /// </summary> /// <param name="generator"> /// The <see cref="SyntaxGenerator"/> used to create the declaration. /// </param> /// <param name="containingType"> /// A symbol specifying the type of the operands of the comparison operator. /// </param> /// <returns> /// A <see cref="SyntaxNode"/> representing the declaration. /// </returns> public static SyntaxNode DefaultOperatorGreaterThanOrEqualDeclaration(this SyntaxGenerator generator, INamedTypeSymbol containingType) { var leftArgument = generator.IdentifierName(LeftIdentifierName); var rightArgument = generator.IdentifierName(RightIdentifierName); SyntaxNode expression; if (containingType.TypeKind == TypeKind.Class) { expression = generator.ConditionalExpression( generator.InvocationExpression( generator.IdentifierName(ReferenceEqualsMethodName), leftArgument, generator.NullLiteralExpression()), generator.InvocationExpression( generator.IdentifierName(ReferenceEqualsMethodName), rightArgument, generator.NullLiteralExpression()), generator.GreaterThanOrEqualExpression( generator.InvocationExpression( generator.MemberAccessExpression(leftArgument, generator.IdentifierName(CompareToMethodName)), rightArgument), generator.LiteralExpression(0))); } else { expression = generator.GreaterThanOrEqualExpression( generator.InvocationExpression( generator.MemberAccessExpression(leftArgument, generator.IdentifierName(CompareToMethodName)), rightArgument), generator.LiteralExpression(0)); } var returnStatement = generator.ReturnStatement(expression); return generator.ComparisonOperatorDeclaration(OperatorKind.GreaterThanOrEqual, containingType, returnStatement); }