LG

Outils pour utilisateurs

Outils du site

Piste : • clang-tidy
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/12/05 00:09] – [readability-identifier-naming] : détail de l'algo rootprog:clang-tidy [2025/10/30 09:59] (Version actuelle) – [kokulshan/clang-tidy-cache] : suppression car l'autre projet a une meilleure popularité root
Ligne 85: Ligne 85:
 Ci-dessous, ''defined(Xxxx)'' signifie que ''XxxxCase'', ''XxxxPrefix'', ''XxxxSuffix'', ''XxxxIgnoredRegex'' ou ''XxxxHungarianPrefix'' est dans les règles. Ci-dessous, ''defined(Xxxx)'' signifie que ''XxxxCase'', ''XxxxPrefix'', ''XxxxSuffix'', ''XxxxIgnoredRegex'' ou ''XxxxHungarianPrefix'' est dans les règles.
  
-<code> +| Algo | Exemple | 
-si (variable Objective-C && defined(ObjcIvar)) +|<code> 
-  => ObjcIvar+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 {}
  
-si (typedef && defined(Typedef)) +namespace nAMEPACE {} 
-  => Typedef+</code>| 
 +|<code> 
 +enum: 
 +  si enum && SK_Enum: 
 +    SK_Enum 
 +  fin
  
-si (using && defined(TypeAlias)) +field in enum: 
-  => TypeAlias+  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 };
  
-si (namespace) +enum class eNUM { ENUM_Const }; 
-  si (namespace est inline) && defined(InlineNamespace) +</code>| 
-    =>InlineNamespace+|<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; 
 +};
  
-  si defined(Namespace) +struct STRuct {};
-    =>Namespace+
  
-si (enum && defined(Enum)) +class ClAsS {};
-  => Enum+
  
-si (valeur d'un enum) +union UnIon {};
-  si (enum class && defined(ScopedEnumConstant)) +
-    => ScopedEnumConstant +
-  si (defined(EnumConstant)) +
-    => EnumConstant +
-  si (defined(Constant)) +
-    => Constant +
-  => Ignore+
  
-si (union ou struct ou class) +enum class eNUM {}; 
-  si (abstract (au moins une méthode virtuelle pure) && defined(AbstractClass)) +</code>| 
-    => AbstractClass +|<code> 
-  si (struct && defined(Struct)) +membre d'une classe: 
-    => Struct +  si CheckAnonFieldInParent && struct/union parent est anonyme: 
-  si (struct && defined(Class)) +    Appliquer les règles ci-dessous en 
-    => Class +      considérant le private/protected/public du parent. 
-  si (class && defined(Class)) +  si const: 
-    => Class +    si SK_ConstantMember: 
-  si (class && defined(Struct)) +      SK_ConstantMember 
-    => Struct +    si SK_Constant: 
-  si (union && defined(Union)) +      SK_Constant 
-    => Union +  si private && SK_PrivateMember: 
-  si (enum && defined(Enum)) +    SK_PrivateMember 
-    => Enum +  si protected && SK_ProtectedMember: 
-  => Ignore+    SK_ProtectedMember 
 +  si public && SK_PublicMember: 
 +    SK_PublicMember 
 +  si SK_Member: 
 +    SK_Member 
 +  fin 
 +</code>|<code cpp> 
 +class { 
 +  const int InT;
  
-si (membre d'une classe) +private: 
-  si (option CheckAnonFieldInParent && struct/union parent est anonyme) +  short ShorT;
-    Appliquer les règles ci-dessous en considérant le private/protected/public du parent.+
  
 +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;
  
-</code>+class Cc { 
 +  static const int Ee = 150; 
 +};
  
-=====Extensions=====+const int *Jj = nullptr; 
 +const int jJ = 0;
  
-[[http://bbannier.github.io/blog/2015/05/02/Writing-a-basic-clang-static-analysis-check.html|Writing a basic clang static analysis check]] {{ :prog:clang:writing_a_basic_clang_static_analysis_check_2021-06-30_06_21_21_.html |Archive du 02/05/2015 le 30/06/2021}}+void fOo() { 
 +  static const int zZZz = 150; 
 +  const int *ZzzZ = nullptr; 
 +  { 
 +    const int ZZzz = 150; 
 +  } 
 +  const int ZZzZ = 150; 
 +};
  
-Et une version à jour du système de compilation : [[https://clang.llvm.org/docs/LibASTMatchersTutorial.html|Tutorial for building tools using LibTooling and LibASTMatchers]], {{ :prog:clang:tutorial_for_building_tools_using_libtooling_and_libastmatchers_clang_17.0.0git_documentation_23_05_2023_08_35_52_.html |Archive du clang 17.0.0 master le 23/05/2023}}+class Cc2 { 
 +  static int Ee2 = 150; 
 +};
  
-[[https://clang.llvm.org/extra/clang-tidy/Contributing.html|Getting Involved]] {{ :prog:clang:getting_involved_extra_clang_tools_17.0.0git_documentation_24_05_2023_09_20_28_.html |Archive du clang 17.0.0 master le 24/05/2023}}+int *Jj2 = nullptr; 
 +int jJ2 = 0;
  
-=====Cache=====+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; 
 +};
  
-====kokulshan/clang-tidy-cache====+class B:public A{ 
 +    public: 
 +    void fOo() override;
  
-[[https://github.com/kokulshan/clang-tidy-cache|Site web]]+    constexpr int fOo2(); 
 +    static void fOo3();
  
-  * Installation+    virtual void fOo4();
  
-Il faut avoir installé go.+    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
  
-<code bash> +value in template: 
-make +  si SK_ValueTemplateParameter: 
-</code>+    SK_ValueTemplateParameter 
 +  si SK_TemplateParameter: 
 +    SK_TemplateParameter 
 +  ignore
  
-  * Exécution+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===== 
 + 
 +[[http://bbannier.github.io/blog/2015/05/02/Writing-a-basic-clang-static-analysis-check.html|Writing a basic clang static analysis check]] {{ :prog:clang:writing_a_basic_clang_static_analysis_check_2021-06-30_06_21_21_.html |Archive du 02/05/2015 le 30/06/2021}} 
 + 
 +Et une version à jour du système de compilation : [[https://clang.llvm.org/docs/LibASTMatchersTutorial.html|Tutorial for building tools using LibTooling and LibASTMatchers]], {{ :prog:clang:tutorial_for_building_tools_using_libtooling_and_libastmatchers_clang_17.0.0git_documentation_23_05_2023_08_35_52_.html |Archive du clang 17.0.0 master le 23/05/2023}} 
 + 
 +[[https://clang.llvm.org/extra/clang-tidy/Contributing.html|Getting Involved]] {{ :prog:clang:getting_involved_extra_clang_tools_17.0.0git_documentation_24_05_2023_09_20_28_.html |Archive du clang 17.0.0 master le 24/05/2023}} 
 + 
 +=====Cache=====
  
-<code bash> 
-CLANG_TIDY_CACHE_BINARY=/usr/bin/clang-tidy-17 CLANG_TIDY_CACHE_DIR=~/.cache/clang-tidy-cache run-clang-tidy-17 -clang-tidy-binary /usr/local/bin/clang-tidy-cache 
-</code> 
  
 ====matus-chochlik/ctcache==== ====matus-chochlik/ctcache====
prog/clang-tidy.1733353745.txt.gz · Dernière modification : de root