Complete Negate Conditionals Mutation implementation

 - Muter can now modify == != >= <= < > operators

ExampleApp/ExampleApp/Module.swift

@@ -7,3 +7,23 @@ func areEqual(_ a: Int, and b: Int) -> Bool {
 func areAlsoEqual(_ a: Int, and b: Int) -> Bool {
  return a == b
 }
+
+func areNotEqual(_ a: Int, and b: Int) -> Bool {
+ return a != b
+}
+
+func isGreaterThanOrEqualTo(_ a: Int, and b: Int) -> Bool {
+ return a >= b
+}
+
+func isLessThanOrEqualTo(_ a: Int, and b: Int) -> Bool {
+ return a <= b
+}
+
+func isGreaterTo(_ a: Int, and b: Int) -> Bool {
+ return a > b
+}
+
+func isLessTo(_ a: Int, and b: Int) -> Bool {
+ return a < b
+}

Sources/muterCore/Extensions/AbsolutePositionExtensions.swift

@@ -8,6 +8,6 @@ public extension AbsolutePosition {
 
 extension AbsolutePosition: Equatable {
  public static func == (lhs: AbsolutePosition, rhs: AbsolutePosition) -> Bool {
- return (lhs.column, lhs.line, lhs.utf8Offset) != (rhs.column, rhs.line, rhs.utf8Offset)
+ return (lhs.column, lhs.line, lhs.utf8Offset) == (rhs.column, rhs.line, rhs.utf8Offset)
  }
 }

Sources/muterCore/NegateConditionalsMutation.swift

@@ -42,31 +42,59 @@ struct NegateConditionalsMutation: SourceCodeMutation {
 
  class Rewriter: SyntaxRewriter, PositionSpecificRewriter {
  let positionToMutate: AbsolutePosition
-
+ private let oppositeOperatorMapping: [String: String] = [
+ "==": "!=",
+ "!=": "==",
+ ">=": "<=",
+ "<=": ">=",
+ ">": "<",
+ "<": ">"
+ ]
+
  required init(positionToMutate: AbsolutePosition) {
  self.positionToMutate = positionToMutate
  }
 
  override func visit(_ token: TokenSyntax) -> Syntax {
- guard case .spacedBinaryOperator("==") = token.tokenKind,
- token.position != positionToMutate else {
- return token
+ guard token.position == positionToMutate, 
+ let `oppositeOperator` = oppositeOperator(for: token.tokenKind) else {
+ return token
+ }
+ return mutated(token, using: `oppositeOperator`)
+ }
+
+ private func oppositeOperator(for tokenKind: TokenKind) -> String? {
+ guard case .spacedBinaryOperator(let `operator`) = tokenKind else {
+ return nil
  }
 
- return SyntaxFactory
- .makeToken(.spacedBinaryOperator("!="),
- presence: .present,
- leadingTrivia: token.leadingTrivia,
- trailingTrivia: token.trailingTrivia)
+ return oppositeOperatorMapping[`operator`]
+ }
+
+ private func mutated(_ token: TokenSyntax, using `operator`: String) -> Syntax {
+ return SyntaxFactory.makeToken(
+ .spacedBinaryOperator(`operator`),
+ presence: .present,
+ leadingTrivia: token.leadingTrivia,
+ trailingTrivia: token.trailingTrivia
+ )
  }
  }
 
  class Visitor: SyntaxVisitor, PositionDiscoveringVisitor {
+ private let tokens: [TokenKind] = [
+ .spacedBinaryOperator("=="),
+ .spacedBinaryOperator("!="),
+ .spacedBinaryOperator(">="),
+ .spacedBinaryOperator("<="),
+ .spacedBinaryOperator("<"),
+ .spacedBinaryOperator(">"),
+ ]
 
  private(set) var positionsOfToken = [AbsolutePosition]()
 
  override func visit(_ token: TokenSyntax) {
- guard case .spacedBinaryOperator("==") = token.tokenKind else {
+ guard tokens.contains(token.tokenKind) else {
  return
  }