ydb/contrib/libs/clang16/include/clang/AST/ODRDiagsEmitter.h

#pragma once

#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif

//===- ODRDiagsEmitter.h - Emits diagnostic for ODR mismatches --*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_AST_ODRDIAGSEMITTER_H
#define LLVM_CLANG_AST_ODRDIAGSEMITTER_H

#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclObjC.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/LangOptions.h"

namespace clang {

class ODRDiagsEmitter {
public:
  ODRDiagsEmitter(DiagnosticsEngine &Diags, const ASTContext &Context,
                  const LangOptions &LangOpts)
      : Diags(Diags), Context(Context), LangOpts(LangOpts) {}

  /// Diagnose ODR mismatch between 2 FunctionDecl.
  ///
  /// Returns true if found a mismatch and diagnosed it.
  bool diagnoseMismatch(const FunctionDecl *FirstFunction,
                        const FunctionDecl *SecondFunction) const;

  /// Diagnose ODR mismatch between 2 EnumDecl.
  ///
  /// Returns true if found a mismatch and diagnosed it.
  bool diagnoseMismatch(const EnumDecl *FirstEnum,
                        const EnumDecl *SecondEnum) const;

  /// Diagnose ODR mismatch between 2 CXXRecordDecl.
  ///
  /// Returns true if found a mismatch and diagnosed it.
  /// To compare 2 declarations with merged and identical definition data
  /// you need to provide pre-merge definition data in \p SecondDD.
  bool
  diagnoseMismatch(const CXXRecordDecl *FirstRecord,
                   const CXXRecordDecl *SecondRecord,
                   const struct CXXRecordDecl::DefinitionData *SecondDD) const;

  /// Diagnose ODR mismatch between 2 RecordDecl that are not CXXRecordDecl.
  ///
  /// Returns true if found a mismatch and diagnosed it.
  bool diagnoseMismatch(const RecordDecl *FirstRecord,
                        const RecordDecl *SecondRecord) const;

  /// Diagnose ODR mismatch between 2 ObjCInterfaceDecl.
  ///
  /// Returns true if found a mismatch and diagnosed it.
  bool diagnoseMismatch(
      const ObjCInterfaceDecl *FirstID, const ObjCInterfaceDecl *SecondID,
      const struct ObjCInterfaceDecl::DefinitionData *SecondDD) const;

  /// Diagnose ODR mismatch between ObjCInterfaceDecl with different
  /// definitions.
  bool diagnoseMismatch(const ObjCInterfaceDecl *FirstID,
                        const ObjCInterfaceDecl *SecondID) const {
    assert(FirstID->data().Definition != SecondID->data().Definition &&
           "Don't diagnose differences when definitions are merged already");
    return diagnoseMismatch(FirstID, SecondID, &SecondID->data());
  }

  /// Diagnose ODR mismatch between 2 ObjCProtocolDecl.
  ///
  /// Returns true if found a mismatch and diagnosed it.
  /// To compare 2 declarations with merged and identical definition data
  /// you need to provide pre-merge definition data in \p SecondDD.
  bool diagnoseMismatch(
      const ObjCProtocolDecl *FirstProtocol,
      const ObjCProtocolDecl *SecondProtocol,
      const struct ObjCProtocolDecl::DefinitionData *SecondDD) const;

  /// Diagnose ODR mismatch between ObjCProtocolDecl with different definitions.
  bool diagnoseMismatch(const ObjCProtocolDecl *FirstProtocol,
                        const ObjCProtocolDecl *SecondProtocol) const {
    assert(FirstProtocol->data().Definition !=
               SecondProtocol->data().Definition &&
           "Don't diagnose differences when definitions are merged already");
    return diagnoseMismatch(FirstProtocol, SecondProtocol,
                            &SecondProtocol->data());
  }

  /// Get the best name we know for the module that owns the given
  /// declaration, or an empty string if the declaration is not from a module.
  static std::string getOwningModuleNameForDiagnostic(const Decl *D);

private:
  using DeclHashes = llvm::SmallVector<std::pair<const Decl *, unsigned>, 4>;

  // Used with err_module_odr_violation_mismatch_decl,
  // note_module_odr_violation_mismatch_decl,
  // err_module_odr_violation_mismatch_decl_unknown,
  // and note_module_odr_violation_mismatch_decl_unknown
  // This list should be the same Decl's as in ODRHash::isSubDeclToBeProcessed
  enum ODRMismatchDecl {
    EndOfClass,
    PublicSpecifer,
    PrivateSpecifer,
    ProtectedSpecifer,
    StaticAssert,
    Field,
    CXXMethod,
    TypeAlias,
    TypeDef,
    Var,
    Friend,
    FunctionTemplate,
    ObjCMethod,
    ObjCIvar,
    ObjCProperty,
    Other
  };

  struct DiffResult {
    const Decl *FirstDecl = nullptr, *SecondDecl = nullptr;
    ODRMismatchDecl FirstDiffType = Other, SecondDiffType = Other;
  };

  // If there is a diagnoseable difference, FirstDiffType and
  // SecondDiffType will not be Other and FirstDecl and SecondDecl will be
  // filled in if not EndOfClass.
  static DiffResult FindTypeDiffs(DeclHashes &FirstHashes,
                                  DeclHashes &SecondHashes);

  DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const {
    return Diags.Report(Loc, DiagID);
  }

  // Use this to diagnose that an unexpected Decl was encountered
  // or no difference was detected. This causes a generic error
  // message to be emitted.
  void diagnoseSubMismatchUnexpected(DiffResult &DR,
                                     const NamedDecl *FirstRecord,
                                     StringRef FirstModule,
                                     const NamedDecl *SecondRecord,
                                     StringRef SecondModule) const;

  void diagnoseSubMismatchDifferentDeclKinds(DiffResult &DR,
                                             const NamedDecl *FirstRecord,
                                             StringRef FirstModule,
                                             const NamedDecl *SecondRecord,
                                             StringRef SecondModule) const;

  bool diagnoseSubMismatchField(const NamedDecl *FirstRecord,
                                StringRef FirstModule, StringRef SecondModule,
                                const FieldDecl *FirstField,
                                const FieldDecl *SecondField) const;

  bool diagnoseSubMismatchTypedef(const NamedDecl *FirstRecord,
                                  StringRef FirstModule, StringRef SecondModule,
                                  const TypedefNameDecl *FirstTD,
                                  const TypedefNameDecl *SecondTD,
                                  bool IsTypeAlias) const;

  bool diagnoseSubMismatchVar(const NamedDecl *FirstRecord,
                              StringRef FirstModule, StringRef SecondModule,
                              const VarDecl *FirstVD,
                              const VarDecl *SecondVD) const;

  /// Check if protocol lists are the same and diagnose if they are different.
  ///
  /// Returns true if found a mismatch and diagnosed it.
  bool diagnoseSubMismatchProtocols(const ObjCProtocolList &FirstProtocols,
                                    const ObjCContainerDecl *FirstContainer,
                                    StringRef FirstModule,
                                    const ObjCProtocolList &SecondProtocols,
                                    const ObjCContainerDecl *SecondContainer,
                                    StringRef SecondModule) const;

  /// Check if Objective-C methods are the same and diagnose if different.
  ///
  /// Returns true if found a mismatch and diagnosed it.
  bool diagnoseSubMismatchObjCMethod(const NamedDecl *FirstObjCContainer,
                                     StringRef FirstModule,
                                     StringRef SecondModule,
                                     const ObjCMethodDecl *FirstMethod,
                                     const ObjCMethodDecl *SecondMethod) const;

  /// Check if Objective-C properties are the same and diagnose if different.
  ///
  /// Returns true if found a mismatch and diagnosed it.
  bool
  diagnoseSubMismatchObjCProperty(const NamedDecl *FirstObjCContainer,
                                  StringRef FirstModule, StringRef SecondModule,
                                  const ObjCPropertyDecl *FirstProp,
                                  const ObjCPropertyDecl *SecondProp) const;

private:
  DiagnosticsEngine &Diags;
  const ASTContext &Context;
  const LangOptions &LangOpts;
};

} // namespace clang

#endif

#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif