LG

Outils pour utilisateurs

Outils du site

Piste :
prog:clang-tidy

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentesRévision précédente
Prochaine révision		Révision précédente
prog:clang-tidy [2024/03/22 13:58] – Ajout de "Cache" rootprog:clang-tidy [2024/12/23 09:44] (Version actuelle) – [readability-identifier-naming] : précision sur GlobalFunction root
Ligne 74: Ligne 74:
 // NOLINTEND(google*) // NOLINTEND(google*)
 </code> </code>
 +
 +=====Détail des règles=====
 +
 +====readability-identifier-naming====
 +
 +Priorité de la convention de nommage:
 +
 +Voir directement le code source avec les méthodes [[https://github.com/llvm/llvm-project/blob/2c739dfd53fde0995f91c8a2c11ec803041bac86/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp#L1122|findStyleKind]], [[https://github.com/llvm/llvm-project/blob/2c739dfd53fde0995f91c8a2c11ec803041bac86/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp#L1475|findStyleKindForField]] et [[https://github.com/llvm/llvm-project/blob/2c739dfd53fde0995f91c8a2c11ec803041bac86/clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp#L1501C34-L1501C53|findStyleKindForVar]].
 +
 +Ci-dessous, ''defined(Xxxx)'' signifie que ''XxxxCase'', ''XxxxPrefix'', ''XxxxSuffix'', ''XxxxIgnoredRegex'' ou ''XxxxHungarianPrefix'' est dans les règles.
 +
 +| Algo | Exemple |
 +|<code>
 +variable objective-C:
 +  si SK_ObjcIvar:
 +    SK_ObjcIvar
 +  sinon
 +    fin
 +</code>|<code cpp>
 +</code>|
 +|<code>
 +typedef:
 +  si SK_Typedef:
 +    SK_Typedef
 +  sinon
 +    fin
 +</code>|<code cpp>
 +typedef int INTeGER;
 +</code>|
 +|<code>
 +using:
 +  si SK_TypeAlias:
 +    SK_TypeAlias
 +  sinon
 +    fin
 +</code>|<code cpp>
 +using DOUbLE = double;
 +</code>|
 +|<code>
 +namespace:
 +  si inline namespace && SK_InlineNamespace:
 +    SK_InlineNamespace
 +  si SK_Namespace
 +    SK_Namespace
 +  fin
 +</code>|<code cpp>
 +inline namespace NAMEsPACE {}
 +
 +namespace nAMEPACE {}
 +</code>|
 +|<code>
 +enum:
 +  si enum && SK_Enum:
 +    SK_Enum
 +  fin
 +
 +field in enum:
 +  si enum class && SK_ScopedEnumConstant:
 +    SK_ScopedEnumConstant
 +  si SK_EnumConstant:
 +    SK_EnumConstant
 +  si SK_Constant:
 +    SK_Constant
 +  fin</code>|<code cpp>
 +enum eNUM { EnuM_CONST };
 +
 +enum class eNUM { ENUM_Const };
 +</code>|
 +|<code>
 +union ou struct ou class:
 +  si abstract (une méthode virtuelle pure) && SK_AbstractClass:
 +    SK_AbstractClass
 +  si struct && SK_Struct:
 +    SK_Struct
 +  si struct && SK_Class:
 +    SK_Class
 +  si class && SK_Class:
 +    SK_Class
 +  si class && SK_Struct:
 +    SK_Struct
 +  si union && SK_Union:
 +    SK_Union
 +  si enum && SK_Enum:
 +    SK_Enum
 +  fin
 +</code>|<code cpp>
 +class ABStract {
 +  virtual fOo() = 0;
 +};
 +
 +struct STRuct {};
 +
 +class ClAsS {};
 +
 +union UnIon {};
 +
 +enum class eNUM {};
 +</code>|
 +|<code>
 +membre d'une classe:
 +  si CheckAnonFieldInParent && struct/union parent est anonyme:
 +    Appliquer les règles ci-dessous en
 +      considérant le private/protected/public du parent.
 +  si const:
 +    si SK_ConstantMember:
 +      SK_ConstantMember
 +    si SK_Constant:
 +      SK_Constant
 +  si private && SK_PrivateMember:
 +    SK_PrivateMember
 +  si protected && SK_ProtectedMember:
 +    SK_ProtectedMember
 +  si public && SK_PublicMember:
 +    SK_PublicMember
 +  si SK_Member:
 +    SK_Member
 +  fin
 +</code>|<code cpp>
 +class {
 +  const int InT;
 +
 +private:
 +  short ShorT;
 +
 +protected:
 +  double DoublE;
 +
 +public:
 +  float FloaT;
 +}</code>|
 +|<code>
 +paramètre:
 +  // Possible en C++ ?!?
 +  si constexpr && SK_ConstexprVariable:
 +    SK_ConstexprVariable
 +  si const:
 +    si pointeur && SK_ConstantPointerParameter:
 +      SK_ConstantPointerParameter
 +    si SK_ConstantParameter:
 +      SK_ConstantParameter
 +    si SK_Constant:
 +      SK_Constant
 +  si variadic && SK_ParameterPack:
 +    SK_ParameterPack
 +  si pointeur && SK_PointerParameter:
 +    SK_PointerParameter
 +  si SK_Parameter:
 +    SK_Parameter
 +  fin
 +</code>|<code cpp>
 +template <class... Types>
 +void fOo(const int *IiI, const short &ShorT,
 +         int *JjJ, short SsS, Types... arGs);
 +</code>|
 +|<code>
 +variable:
 +  si constexpr && SK_ConstexprVariable:
 +    SK_ConstexprVariable
 +  si const:
 +    si static && membre && SK_ClassConstant:
 +      SK_ClassConstant
 +    si global && pointeur && SK_GlobalConstantPointer:
 +      SK_GlobalConstantPointer
 +    si global && SK_GlobalConstant:
 +      SK_GlobalConstant
 +    si local && static && SK_StaticConstant:
 +      SK_StaticConstant
 +    si local && pointeur && SK_LocalConstantPointer:
 +      SK_LocalConstantPointer
 +    si local && SK_LocalConstant:
 +      SK_LocalConstant
 +    // Plus restrictif que la condition précédente ?!?
 +    si local && dans le bloc principal
 +      de la fonction/méthode && SK_LocalConstant:
 +        SK_LocalConstant
 +    si SK_Constant:
 +      SK_Constant
 +  fin
 +  si static && membre && SK_ClassMember:
 +    SK_ClassMember
 +  si global && pointeur && SK_GlobalPointer:
 +    SK_GlobalPointer
 +  si global && SK_GlobalVariable:
 +    SK_GlobalVariable
 +  si local && static && SK_StaticVariable:
 +    SK_StaticVariable
 +  si local && pointeur && SK_LocalPointer:
 +    SK_LocalPointer
 +  si local && SK_LocalVariable:
 +    SK_LocalVariable
 +  // Plus restrictif que la condition précédente ?!?
 +  si local && dans le bloc principal
 +    de la fonction/méthode && SK_LocalVariable:
 +      SK_LocalVariable
 +  si SK_Variable:
 +    SK_Variable
 +  fin
 +</code>|<code cpp>
 +constexpr int eE = 150;
 +
 +class Cc {
 +  static const int Ee = 150;
 +};
 +
 +const int *Jj = nullptr;
 +const int jJ = 0;
 +
 +void fOo() {
 +  static const int zZZz = 150;
 +  const int *ZzzZ = nullptr;
 +  {
 +    const int ZZzz = 150;
 +  }
 +  const int ZZzZ = 150;
 +};
 +
 +class Cc2 {
 +  static int Ee2 = 150;
 +};
 +
 +int *Jj2 = nullptr;
 +int jJ2 = 0;
 +
 +void fOo2() {
 +  static int zZZz2 = 150;
 +  int *ZzzZ2 = nullptr;
 +  {
 +    int ZZzz2 = 150;
 +  }
 +  int ZZzZ2 = 150;
 +};
 +</code>|
 +|<code>
 +méthode:
 +  si override:
 +    ignore
 +  si constexpr && SK_ConstexprMethod:
 +    SK_ConstexprMethod
 +  si constexpr && SK_ConstexprFunction:
 +    SK_ConstexprFunction
 +  si static && SK_ClassMethod:
 +    SK_ClassMethod
 +  si virtual && SK_VirtualMethod:
 +    SK_VirtualMethod
 +  si private && SK_PrivateMethod:
 +    SK_PrivateMethod
 +  si protected && SK_ProtectedMethod:
 +    SK_ProtectedMethod
 +  si public && SK_PublicMethod:
 +    SK_PublicMethod
 +  si SK_Method:
 +    SK_Method
 +  si SK_Function:
 +    SK_Function
 +  ignore
 +</code>|<code cpp>
 +class A{
 +    public:
 +    virtual void fOo()= 0;
 +};
 +
 +class B:public A{
 +    public:
 +    void fOo() override;
 +
 +    constexpr int fOo2();
 +    static void fOo3();
 +
 +    virtual void fOo4();
 +
 +    private:
 +     void fOo5();
 +    protected:
 +     void fOo6();
 +    public:
 +     void fOo7();
 +};
 +</code>|
 +|<code>
 +fonction:
 +  si constexpr && SK_ConstexprFunction:
 +    SK_ConstexprFunction
 +  // C'est quoi une fonction non globale ?
 +  si global && SK_GlobalFunction:
 +    SK_GlobalFunction
 +  si SK_Function:
 +    SK_Function
 +  ignore
 +</code>|<code cpp>
 +constexpr void b1r();
 +void bAr();
 +</code>|
 +|<code>
 +typename dans template:
 +  si SK_TypeTemplateParameter:
 +    SK_TypeTemplateParameter
 +  si SK_TemplateParameter:
 +    SK_TemplateParameter
 +  ignore
 +
 +value in template:
 +  si SK_ValueTemplateParameter:
 +    SK_ValueTemplateParameter
 +  si SK_TemplateParameter:
 +    SK_TemplateParameter
 +  ignore
 +
 +template <typename> class / typename:
 +  si SK_TemplateTemplateParameter:
 +    SK_TemplateTemplateParameter
 +  si SK_TemplateParameter:
 +    SK_TemplateParameter
 +  ignore
 +</code>|<code cpp>
 +template<typename TypeName, int VaLuE,
 +  template<typename> typename TypeTypeName>
 +void FoBa();
 +</code>|
 +|<code>
 +concept && SK_Concept:
 +  SK_Concept</code>|<code cpp>
 +template<class T, class U>
 +concept ConCepT = std::is_base_of<U, T>::value;
 +</code>|
 +|<code>
 +define && SK_MacroDefinition:
 +  SK_MacroDefinition</code>|<code cpp>
 +#define MaCrO
 +</code>|
  
 =====Extensions===== =====Extensions=====
Ligne 109: Ligne 438:
   * Installation   * Installation
  
-Il suffit de copier le script python ''clang-tidy-cache'' dans ''/usr/local/bin''.+Il suffit de copier les scripts python ''clang-tidy'' et ''clang-tidy-cache'' dans ''/usr/local/bin''.
  
   * Execution   * Execution
  
 <code bash> <code bash>
-CTCACHE_CLANG_TIDY=/usr/bin/clang-tidy CTCACHE_DIR=~/.cache/clang-tidy-cache run-clang-tidy -clang-tidy-binary /usr/local/bin/clang-tidy-cache+CTCACHE_CLANG_TIDY=/usr/bin/clang-tidy CTCACHE_DIR=~/.cache/clang-tidy-cache run-clang-tidy -clang-tidy-binary /usr/local/bin/clang-tidy
 </code> </code>
prog/clang-tidy.1711112286.txt.gz · Dernière modification : 2024/03/22 13:58 de root