     return .visitChildren
   }
 
+  public override func visit(_ node: MemberDeclListItemSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+    if let semicolon = node.semicolon, semicolon.presence == .missing {
+      if !node.decl.hasError {
+        // Only diagnose the missing semicolon if the decl doesn't contain any errors.
+        // If the decl contains errors, the root cause is most likely something different and not the missing semicolon.
+        let position = semicolon.previousToken(viewMode: .sourceAccurate)?.endPositionBeforeTrailingTrivia
+        addDiagnostic(semicolon, position: position, .consecutiveDeclarationsOnSameLine, fixIts: [
+          FixIt(message: .insertSemicolon, changes: .makePresentBeforeTrivia(semicolon))
+        ], handledNodes: [semicolon.id])
+      } else {
+        handledNodes.append(semicolon.id)
+      }
+    }
+    return .visitChildren
+  }
+
+  public override func visit(_ node: MissingDeclSyntax) -> SyntaxVisitorContinueKind {
+    return handleMissingSyntax(node)
+  }
+
+  public override func visit(_ node: MissingExprSyntax) -> SyntaxVisitorContinueKind {
+    return handleMissingSyntax(node)
+  }
+
+  public override func visit(_ node: MissingPatternSyntax) -> SyntaxVisitorContinueKind {
+    return handleMissingSyntax(node)
+  }
+
+  public override func visit(_ node: MissingStmtSyntax) -> SyntaxVisitorContinueKind {
+    return handleMissingSyntax(node)
+  }
+
+  public override func visit(_ node: MissingSyntax) -> SyntaxVisitorContinueKind {
+    return handleMissingSyntax(node)
+  }
+
+  public override func visit(_ node: MissingTypeSyntax) -> SyntaxVisitorContinueKind {
+    return handleMissingSyntax(node)
+  }
+
+  public override func visit(_ node: OperatorDeclSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+    if let unexpected = node.unexpectedAfterOperatorPrecedenceAndTypes,
+       unexpected.contains(where: { $0.is(PrecedenceGroupAttributeListSyntax.self) }) == true {
+      addDiagnostic(unexpected, .operatorShouldBeDeclaredWithoutBody, fixIts: [
+        FixIt(message: .removeOperatorBody, changes: .makeMissing(unexpected))
+      ], handledNodes: [unexpected.id])
+    }
+
+    func diagnoseIdentifierInOperatorName(unexpected: UnexpectedNodesSyntax?, name: TokenSyntax) {
+      guard let unexpected = unexpected else {
+        return
+      }
+      let message: DiagnosticMessage?
+      if let identifier = unexpected.onlyToken(where: { $0.tokenKind.isIdentifier }) {
+        message = IdentifierNotAllowedInOperatorName(identifier: identifier)
+      } else if let tokens = unexpected.onlyTokens(satisfying: { _ in true }) {
+        message = TokensNotAllowedInOperatorName(tokens: tokens)
+      } else {
+        message = nil
+      }
+      if let message = message {
+        let fixIts: [FixIt]
+        if node.identifier.presence == .present {
+          fixIts = [FixIt(message: RemoveNodesFixIt(unexpected), changes: .makeMissing(unexpected))]
+        } else {
+          fixIts = []
+        }
+        addDiagnostic(unexpected, message, highlights: [Syntax(unexpected)], fixIts: fixIts, handledNodes: [unexpected.id, node.identifier.id])
+      }
+    }
+
+    diagnoseIdentifierInOperatorName(unexpected: node.unexpectedBetweenOperatorKeywordAndIdentifier, name: node.identifier)
+    diagnoseIdentifierInOperatorName(unexpected: node.unexpectedBetweenIdentifierAndOperatorPrecedenceAndTypes, name: node.identifier)
+
+    return .visitChildren
+  }
+
   public override func visit(_ node: PrecedenceGroupAssignmentSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren

    return .visitChildren
  }

  public override func visit(_ node: SwitchCaseSyntax) -> SyntaxVisitorContinueKind {
    if shouldSkip(node) {
      return .skipChildren

    return .skipChildren
  }

  public override func visit(_ node: TokenSyntax) -> SyntaxVisitorContinueKind {
    if shouldSkip(node) {
      return .skipChildren
    }
